adrianbonpin
9cc4fa5c97
build-extension / build (push) Successful in 37s
Squash merge of feat/ismis-helper into prod.
485 lines
19 KiB
JavaScript
485 lines
19 KiB
JavaScript
(function (root, factory) {
|
|
if (typeof module === 'object' && module.exports) {
|
|
module.exports = factory();
|
|
} else {
|
|
root.ISMIStools = Object.assign(root.ISMIStools || {}, factory());
|
|
}
|
|
})(typeof self !== 'undefined' ? self : this, function () {
|
|
'use strict';
|
|
|
|
function getPDFLib() {
|
|
return (typeof self !== 'undefined' && self.PDFLib) ||
|
|
(typeof globalThis !== 'undefined' && globalThis.PDFLib);
|
|
}
|
|
|
|
function wrapText(text, font, size, maxWidth) {
|
|
const words = String(text).split(/\s+/).filter(Boolean);
|
|
const lines = [];
|
|
let line = '';
|
|
for (const word of words) {
|
|
const candidate = line ? line + ' ' + word : word;
|
|
if (font.widthOfTextAtSize(candidate, size) <= maxWidth) {
|
|
line = candidate;
|
|
} else {
|
|
if (line) lines.push(line);
|
|
line = word;
|
|
}
|
|
}
|
|
if (line) lines.push(line);
|
|
return lines.length ? lines : [''];
|
|
}
|
|
|
|
// Format the raw schedule string to match the official PDF style:
|
|
// comma-separate day codes, trim duplicated room suffixes, and split
|
|
// multiple meeting segments onto separate lines.
|
|
function formatSchedule(schedule) {
|
|
let s = String(schedule || '').replace(/\s+/g, ' ').trim();
|
|
if (!s) return s;
|
|
// Collapse duplicated TC anywhere in the string.
|
|
while (/TC\s+TC/.test(s)) s = s.replace(/TC\s+TC/g, 'TC');
|
|
// Join adjacent day codes with commas.
|
|
s = s.replace(/\b(M|Tu|T|W|Th|F|Sa|Su)\s+(M|Tu|T|W|Th|F|Sa|Su)\b/g, '$1,$2');
|
|
// Split concatenated meeting segments (room ending in TC followed by a
|
|
// day code) onto separate lines.
|
|
s = s.replace(/(TC)\s+(?=(?:Su|Sa|Th|Tu|M|W|F|T)\b)/g, '$1\n');
|
|
return s;
|
|
}
|
|
|
|
// Reformat a full name to "Lastname, Firstname Middle" when the source gives
|
|
// it as "Firstname Middle Lastname" (no comma). If a comma is already
|
|
// present the name is returned unchanged.
|
|
function formatFullName(name) {
|
|
const s = String(name || '').trim();
|
|
if (!s || /,/.test(s)) return s;
|
|
const parts = s.split(/\s+/);
|
|
if (parts.length < 2) return s;
|
|
const last = parts.pop();
|
|
return last + ', ' + parts.join(' ');
|
|
}
|
|
// Format a faculty/teacher name to match the official PDF's style:
|
|
// "First [MiddleInitial] Last" (no comma). Handles a source like
|
|
// "Surname, First Middle" by dropping full middle names while keeping
|
|
// honorifics/titles (e.g. FR.) and single-letter middle initials.
|
|
const HONORIFICS = new Set(['FR', 'REV', 'DR', 'SR', 'BR', 'PROF', 'ENGR', 'ATTY', 'HON', 'MR', 'MS', 'MRS', 'BRO', 'SIS']);
|
|
function formatTeacher(name) {
|
|
let v = String(name || '').trim();
|
|
if (!v) return v;
|
|
let surname = '', given = [];
|
|
if (/,/.test(v)) {
|
|
const idx = v.lastIndexOf(',');
|
|
surname = v.slice(0, idx).trim();
|
|
given = v.slice(idx + 1).trim().split(/\s+/).filter(Boolean);
|
|
} else {
|
|
const tok = v.split(/\s+/).filter(Boolean);
|
|
if (tok.length === 0) return v;
|
|
if (tok.length === 1) return v;
|
|
given = tok.slice(0, -1);
|
|
surname = tok[tok.length - 1];
|
|
}
|
|
const out = [];
|
|
let seenFirstName = false;
|
|
for (const tok of given) {
|
|
const bare = tok.replace(/\.$/, '').toUpperCase();
|
|
const isTitle = HONORIFICS.has(bare);
|
|
const isInitial = tok.length === 1 || (bare.length === 1 && /\.$/.test(tok));
|
|
if (isTitle || isInitial) {
|
|
out.push(tok);
|
|
} else if (!seenFirstName) {
|
|
out.push(tok);
|
|
seenFirstName = true;
|
|
}
|
|
// full middle names (after the first name) are dropped
|
|
}
|
|
if (surname) out.push(surname);
|
|
return out.join(' ');
|
|
}
|
|
|
|
function wrapLines(text, font, size, maxWidth) {
|
|
const out = [];
|
|
String(text == null ? '' : text).split(/\n/).forEach((seg) => {
|
|
out.push(...wrapText(seg, font, size, maxWidth));
|
|
});
|
|
return out.length ? out : [''];
|
|
}
|
|
|
|
// Truncate a string to the longest prefix that fits within maxWidth at the
|
|
// given size, hard-cutting mid-word with no ellipsis. Mirrors the official
|
|
// PDF which cuts off course descriptions that exceed the column width.
|
|
function truncateToWidth(text, font, size, maxWidth) {
|
|
const s = String(text == null ? '' : text).trim();
|
|
if (!s) return '';
|
|
if (font.widthOfTextAtSize(s, size) <= maxWidth) return s;
|
|
let lo = 0, hi = s.length;
|
|
while (lo < hi) {
|
|
const mid = Math.ceil((lo + hi) / 2);
|
|
if (font.widthOfTextAtSize(s.slice(0, mid), size) <= maxWidth) lo = mid;
|
|
else hi = mid - 1;
|
|
}
|
|
return s.slice(0, lo);
|
|
}
|
|
|
|
// Compact a degree name for display:
|
|
// "BACHELOR OF SCIENCE IN INFORMATION TECHNOLOGY" -> "BS IT".
|
|
// Multi-word fields become initials; single-word fields stay title-cased.
|
|
function compactProgram(program) {
|
|
const s = String(program || '').trim().toUpperCase();
|
|
let m = /^BACHELOR OF SCIENCE IN (.+)$/.exec(s);
|
|
let prefix = 'BS';
|
|
if (!m) {
|
|
m = /^BACHELOR OF ARTS IN (.+)$/.exec(s);
|
|
if (m) prefix = 'AB';
|
|
}
|
|
if (!m) return String(program || '').trim();
|
|
const field = m[1];
|
|
const words = field.split(/\s+/).filter((w) => !/^(AND|OF|THE|IN)$/.test(w));
|
|
if (words.length <= 1) {
|
|
const single = words[0] || field;
|
|
return prefix + ' ' + single.charAt(0).toUpperCase() + single.slice(1).toLowerCase();
|
|
}
|
|
return prefix + ' ' + words.map((w) => w[0]).join('');
|
|
}
|
|
|
|
// Map a semester to the official date range label.
|
|
function deriveDateRange(semester) {
|
|
const s = String(semester || '').toUpperCase();
|
|
if (/1ST|FIRST/.test(s)) return 'AUGUST - JANUARY';
|
|
if (/2ND|SECOND/.test(s)) return 'JANUARY - MAY';
|
|
if (/SUMMER/.test(s)) return 'JUNE - JULY';
|
|
return '';
|
|
}
|
|
|
|
// Fetch a bundled asset in the extension background page. Returns null in
|
|
// Node (tests) or if the asset is unavailable.
|
|
async function loadAssetBytes(asset) {
|
|
const ext = (typeof browser !== 'undefined' && browser.runtime && browser.runtime.getURL);
|
|
try {
|
|
const url = ext ? browser.runtime.getURL(asset) : null;
|
|
if (!url) return null;
|
|
const resp = await fetch(url);
|
|
if (!resp.ok) return null;
|
|
return new Uint8Array(await resp.arrayBuffer());
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// Embed the bundled Segoe UI fonts (regular/bold/italic). Fontkit is
|
|
// required by pdf-lib to embed custom TTF fonts. Falls back to Helvetica
|
|
// (standard fonts) when the assets are unavailable (e.g. Node tests).
|
|
async function loadFonts(doc, PDFLib) {
|
|
const { StandardFonts } = PDFLib;
|
|
const fontkit = (typeof self !== 'undefined' && self.fontkit) ||
|
|
(typeof globalThis !== 'undefined' && globalThis.fontkit) ||
|
|
null;
|
|
const segoe = {
|
|
regular: 'assets/fonts/Segoe-UI.ttf',
|
|
bold: 'assets/fonts/Segoe-UI-Bold.ttf',
|
|
italic: 'assets/fonts/Segoe-UI-Italic.ttf'
|
|
};
|
|
try {
|
|
if (fontkit) {
|
|
doc.registerFontkit(fontkit);
|
|
const regular = await loadAssetBytes(segoe.regular);
|
|
const bold = await loadAssetBytes(segoe.bold);
|
|
const italic = await loadAssetBytes(segoe.italic);
|
|
if (regular && bold && italic) {
|
|
return {
|
|
font: await doc.embedFont(regular),
|
|
bold: await doc.embedFont(bold),
|
|
italic: await doc.embedFont(italic),
|
|
isCustom: true
|
|
};
|
|
}
|
|
}
|
|
} catch (e) { /* fall through to Helvetica */ }
|
|
return {
|
|
font: doc.embedStandardFont(StandardFonts.Helvetica),
|
|
bold: doc.embedStandardFont(StandardFonts.HelveticaBold),
|
|
italic: doc.embedStandardFont(StandardFonts.HelveticaOblique),
|
|
isCustom: false
|
|
};
|
|
}
|
|
|
|
// Load the bundled header logo. Prefer the transparent PNG (matches the
|
|
// official PDF, which masks the JPEG's baked-in background) for a clean
|
|
// look on white; fall back to the JPEG in Node (tests) or if unavailable.
|
|
async function loadLogo() {
|
|
const ext = (typeof browser !== 'undefined' && browser.runtime && browser.runtime.getURL);
|
|
const candidates = ['assets/logo.png', 'assets/logo.jpeg'];
|
|
for (const asset of candidates) {
|
|
try {
|
|
const url = ext ? browser.runtime.getURL(asset) : null;
|
|
if (!url) return null;
|
|
const resp = await fetch(url);
|
|
if (!resp.ok) continue;
|
|
return { bytes: new Uint8Array(await resp.arrayBuffer()), transparent: /logo\.png$/.test(asset) };
|
|
} catch (e) {
|
|
continue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// Builds a Letter-size PDF replicating the official ISMIS Study Load layout:
|
|
// header logo, title, semester + date range, date enrolled, a student info
|
|
// row (ID, name, program, Year Level), the course table (GROUP, COURSE,
|
|
// COURSE DESCRIPTION, TEACHER, UNITS, NOTE), and a footer (total under the
|
|
// UNITS column, printed-by). NOTE is the status; schedule is stacked under
|
|
// the course description.
|
|
async function buildStudyLoadPdf(data) {
|
|
const PDFLib = getPDFLib();
|
|
const { PDFDocument, StandardFonts, rgb } = PDFLib;
|
|
const header = data.header || {};
|
|
const courses = data.courses || [];
|
|
// Truncate long course descriptions to a single line matching the official
|
|
// PDF (default ON). Disabling allows descriptions to wrap.
|
|
const truncateDescription = data.truncateDescription !== false;
|
|
|
|
const doc = await PDFDocument.create();
|
|
let page = doc.addPage([612, 792]); // Letter
|
|
const fonts = await loadFonts(doc, PDFLib);
|
|
const { font, bold, italic } = fonts;
|
|
const margin = 36;
|
|
const contentWidth = 539.3; // matches reference right edge 575.3
|
|
let y = 792 - 10; // near the very top, matching the reference logo position
|
|
|
|
const black = rgb(0, 0, 0);
|
|
const gray = rgb(0.3, 0.3, 0.3);
|
|
|
|
const logo = await loadLogo();
|
|
let logoImg = null;
|
|
if (logo) {
|
|
try {
|
|
// Transparent PNG embeds with an alpha mask (matches official PDF);
|
|
// the JPEG is embedded as-is (no mask).
|
|
logoImg = logo.transparent
|
|
? await doc.embedPng(logo.bytes)
|
|
: await doc.embedJpg(logo.bytes);
|
|
} catch (e) { logoImg = null; }
|
|
}
|
|
|
|
function center(text, size, f, dy) {
|
|
const w = f.widthOfTextAtSize(text, size);
|
|
page.drawText(text, { x: (612 - w) / 2, y, size, font: f, color: black });
|
|
y -= dy;
|
|
}
|
|
function left(text, size, f, x, dy) {
|
|
page.drawText(text, { x, y, size, font: f, color: black });
|
|
y -= dy;
|
|
}
|
|
function hline(x1, x2, atY) {
|
|
page.drawRectangle({ x: x1, y: atY, width: x2 - x1, height: 0.75, color: black });
|
|
}
|
|
|
|
// ---- Header ----
|
|
if (logoImg) {
|
|
const logoW = 292.5;
|
|
const logoH = logoW * (logoImg.height / logoImg.width);
|
|
page.drawImage(logoImg, { x: (612 - logoW) / 2, y: y - logoH, width: logoW, height: logoH });
|
|
y -= logoH + 8.79;
|
|
}
|
|
// Baseline advances match the reference (Segoe UI) header layout.
|
|
center("STUDENT'S STUDY LOAD", 9.5, bold, 13.84);
|
|
if (header.semester) center(String(header.semester).toUpperCase(), 9, font, 13.76);
|
|
const dateRange = header.dateRange || deriveDateRange(header.semester);
|
|
if (dateRange) center(dateRange, 9, font, 11.75);
|
|
// Always reserve the Date Enrolled line's vertical space (so the layout
|
|
// stays aligned with the reference) even though we never have the value.
|
|
if (header.dateEnrolled) {
|
|
left('Date Enrolled: ' + header.dateEnrolled, 8, italic, margin, 14.53);
|
|
} else {
|
|
y -= 14.53; // keep the same gap, drawing nothing
|
|
}
|
|
|
|
// Student info row, laid out in fixed zones across the page (matching the
|
|
// reference): ID (bold) left, name at ~100, program at ~338, and
|
|
// "Year Level: N" right-aligned to the right content edge (575.3).
|
|
// Year Level is shown by default; the extension can hide it or override the
|
|
// value via settings (header.showYearLevel / header.yearLevel).
|
|
const yearLevelText = (header.showYearLevel !== false && header.yearLevel)
|
|
? 'Year Level: ' + header.yearLevel
|
|
: '';
|
|
if (header.studentId) page.drawText(header.studentId, { x: margin, y, size: 9, font: bold, color: black });
|
|
if (header.fullName) page.drawText(formatFullName(header.fullName), { x: 100, y, size: 9, font, color: black });
|
|
if (header.program) page.drawText(compactProgram(header.program), { x: 338, y, size: 9, font, color: black });
|
|
if (yearLevelText) {
|
|
const w = font.widthOfTextAtSize(yearLevelText, 9);
|
|
// Right-aligned to the content edge, nudged left ~6pt (half of 1rem).
|
|
page.drawText(yearLevelText, { x: margin + contentWidth - w - 6, y, size: 9, font, color: black });
|
|
}
|
|
if (header.studentId || header.fullName || header.program || yearLevelText) y -= 13.59;
|
|
|
|
// ---- Table: GROUP, COURSE, COURSE DESCRIPTION, TEACHER, UNITS, NOTE ----
|
|
// Column boundaries tuned to the reference PDF (left edge 36, right edge 575.3).
|
|
const cols = [
|
|
{ key: 'group', label: 'GROUP', x: 36.0, w: 28.8, align: 'left' },
|
|
{ key: 'courseCode', label: 'COURSE', x: 64.8, w: 47.6, align: 'left' },
|
|
{ key: 'description', label: 'COURSE DESCRIPTION', x: 112.4, w: 201.4, align: 'left' },
|
|
{ key: 'teacher', label: 'TEACHER', x: 313.8, w: 127.6, align: 'left' },
|
|
{ key: 'units', label: 'UNITS', x: 441.4, w: 29.5, align: 'right' },
|
|
{ key: 'status', label: 'NOTE', x: 470.9, w: 104.4, align: 'right' }
|
|
];
|
|
const cellSize = 8;
|
|
const headerSize = 8;
|
|
const lineH = 12;
|
|
|
|
// Header label positions tuned for Segoe UI (matches the reference):
|
|
// left/center aligned within each column so labels never overlap.
|
|
function headerLabelXFor() {
|
|
const widths = {};
|
|
for (const c of cols) {
|
|
const key = c.label.toUpperCase().replace(/\s+/g, '_');
|
|
widths[key] = font.widthOfTextAtSize(c.label, headerSize);
|
|
}
|
|
return {
|
|
GROUP: cols[0].x + 1.3,
|
|
COURSE: cols[1].x + 9,
|
|
COURSE_DESCRIPTION: cols[2].x + (cols[2].w - widths.COURSE_DESCRIPTION) / 2,
|
|
TEACHER: cols[3].x + (cols[3].w - widths.TEACHER) / 2,
|
|
UNITS: cols[4].x + (cols[4].w - widths.UNITS) / 2,
|
|
NOTE: cols[5].x + (cols[5].w - widths.NOTE) / 2
|
|
};
|
|
}
|
|
|
|
function rowLines(cells) {
|
|
return cols.map((c) => {
|
|
let lines;
|
|
if (c.key === 'description') {
|
|
if (truncateDescription) {
|
|
// Single line, hard-truncated to fit the column (official PDF style).
|
|
lines = [truncateToWidth(cells.description, font, cellSize, c.w - 3)];
|
|
} else {
|
|
lines = wrapLines(cells.description, font, cellSize, c.w - 6);
|
|
}
|
|
const sched = String(cells.schedule || '');
|
|
if (sched) lines.push(...wrapLines(sched, font, cellSize, c.w - 6));
|
|
} else {
|
|
lines = wrapLines(cells[c.key], font, cellSize, c.w - 6);
|
|
}
|
|
return lines;
|
|
});
|
|
}
|
|
|
|
function drawRow(cells, isHeader) {
|
|
// Header labels and data all use the body font (header is not bold).
|
|
const f = font;
|
|
const size = isHeader ? headerSize : cellSize;
|
|
const linesPerCol = rowLines(cells);
|
|
|
|
if (isHeader) {
|
|
// Reference header row: only a top and bottom horizontal rule; no
|
|
// vertical dividers. Text baseline at y; top rule 1.8pt above the
|
|
// text bbox top; bottom rule 11.5pt below the text bbox top. For
|
|
// 8pt Helvetica the text bbox top sits ~8.6pt above the baseline,
|
|
// so the lines are offset by +9.6 (top) and -3.7 (bottom) relative
|
|
// to y. Data rows start 13pt below the header text bbox top.
|
|
const topY = y + 9.6;
|
|
const botY = y - 3.7;
|
|
if (botY < 50) {
|
|
page = doc.addPage([612, 792]);
|
|
y = 792 - 10;
|
|
return drawHeaderRow();
|
|
}
|
|
|
|
hline(margin, margin + contentWidth, topY);
|
|
|
|
const labelXs = headerLabelXFor();
|
|
for (let i = 0; i < cols.length; i++) {
|
|
const c = cols[i];
|
|
const labelKey = c.label.toUpperCase().replace(/\s+/g, '_');
|
|
const lx = labelXs[labelKey];
|
|
const lines = linesPerCol[i];
|
|
page.drawText(lines[0], { x: lx, y, size, font: f, color: black });
|
|
}
|
|
|
|
hline(margin, margin + contentWidth, botY);
|
|
y -= 13.0;
|
|
return true;
|
|
}
|
|
|
|
// Data rows: fixed 24.5pt baseline-to-baseline spacing. Description +
|
|
// schedule stack with 12pt line spacing. Expand the row height when
|
|
// the schedule or wrapped description needs more lines.
|
|
const maxLines = Math.max(...linesPerCol.map((l) => l.length));
|
|
const rowHeight = Math.max(24.5, maxLines * lineH + 0.5);
|
|
if (y - rowHeight < 50) {
|
|
page = doc.addPage([612, 792]);
|
|
y = 792 - 10;
|
|
drawHeaderRow();
|
|
}
|
|
|
|
for (let i = 0; i < cols.length; i++) {
|
|
const c = cols[i];
|
|
const lines = linesPerCol[i];
|
|
let ty = y;
|
|
for (const line of lines) {
|
|
if (c.key === 'units') {
|
|
// Center unit values under the UNITS header, matching the reference.
|
|
const w = f.widthOfTextAtSize(line, size);
|
|
page.drawText(line, { x: c.x + (c.w - w) / 2, y: ty, size, font: f, color: black });
|
|
} else if (c.key === 'status') {
|
|
page.drawText(line, { x: c.x + 35, y: ty, size, font: f, color: black });
|
|
} else {
|
|
let dx = 3;
|
|
if (c.key === 'group') dx = 12;
|
|
else if (c.key === 'courseCode') dx = 8;
|
|
else if (c.key === 'teacher') dx = 3.5;
|
|
else if (c.key === 'description') dx = 3.5;
|
|
page.drawText(line, { x: c.x + dx, y: ty, size, font: f, color: black });
|
|
}
|
|
ty -= lineH;
|
|
}
|
|
}
|
|
|
|
y -= rowHeight;
|
|
return true;
|
|
}
|
|
|
|
function drawHeaderRow() {
|
|
const cells = {};
|
|
cols.forEach((c) => { cells[c.key] = c.label; });
|
|
drawRow(cells, true);
|
|
}
|
|
|
|
drawHeaderRow();
|
|
|
|
for (const course of courses) {
|
|
const cells = {
|
|
group: course.group,
|
|
courseCode: course.courseCode,
|
|
description: course.description,
|
|
schedule: formatSchedule(course.schedule),
|
|
teacher: formatTeacher(course.teacher || course.faculty),
|
|
units: course.units,
|
|
status: course.status
|
|
};
|
|
drawRow(cells, false);
|
|
}
|
|
|
|
// ---- Footer ----
|
|
if (y < 90) {
|
|
page = doc.addPage([612, 792]);
|
|
y = 792 - 10;
|
|
}
|
|
if (data.totalUnits) {
|
|
// Total sits one standard row height below the last course row (matching
|
|
// the reference, which has a ~24.5pt gap), centered within the UNITS col.
|
|
const unitsCol = cols[4];
|
|
const w = font.widthOfTextAtSize(data.totalUnits, 8);
|
|
// Short underline above the total, spanning the UNITS column.
|
|
hline(unitsCol.x, unitsCol.x + unitsCol.w, y + 9);
|
|
page.drawText(data.totalUnits, { x: unitsCol.x + (unitsCol.w - w) / 2, y, size: 8, font, color: black });
|
|
y -= 12;
|
|
}
|
|
hline(margin, margin + contentWidth, y);
|
|
y -= 10.1;
|
|
const printedBy = 'Printed by: ' + (header.studentId || '') + ' on ' + new Date().toLocaleDateString();
|
|
const pw = font.widthOfTextAtSize(printedBy, 8);
|
|
page.drawText(printedBy, { x: margin + contentWidth - pw, y, size: 8, font, color: black });
|
|
|
|
return doc.save(); // returns Promise<Uint8Array>
|
|
}
|
|
|
|
return { buildStudyLoadPdf, compactProgram, deriveDateRange, formatSchedule, formatFullName, formatTeacher, truncateToWidth };
|
|
});
|