@tonzxz/government-forms 0.1.0

package/dist/gam/utils/export-preview-pdf.js

@@ -0,0 +1,270 @@
+"use client";
+import html2canvas from "html2canvas";
+import jsPDF from "jspdf";
+import { createRoot } from "react-dom/client";
+const PDF_PAGE_SELECTOR = [
+    '[data-pdf-page="true"]',
+    ".iar-a4-page",
+    ".itr-a4-page",
+    ".regspi-a4-page",
+    ".splc-a4-page",
+    ".spc-a4-page",
+].join(", ");
+const UNSUPPORTED_COLOR_FUNCTION_RE = /(oklch|lab|lch)\s*\(/i;
+const UNSUPPORTED_COLOR_VALUE_RE = /(oklch|lab|lch)\s*\([^)]+\)/gi;
+const COLOR_STYLE_PROPERTIES = [
+    "color",
+    "background-color",
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color",
+    "outline-color",
+    "text-decoration-color",
+    "column-rule-color",
+    "caret-color",
+    "fill",
+    "stroke",
+    "stop-color",
+    "flood-color",
+    "lighting-color",
+    "box-shadow",
+    "text-shadow",
+];
+function resolvePdfPage(root) {
+    if (root.matches(PDF_PAGE_SELECTOR))
+        return root;
+    return root.querySelector(PDF_PAGE_SELECTOR) ?? root;
+}
+export function resolvePdfOrientation(configured, width, height) {
+    if (configured === "portrait" || configured === "landscape")
+        return configured;
+    return width > height ? "landscape" : "portrait";
+}
+function resolveOrientation(page) {
+    const rect = page.getBoundingClientRect();
+    return resolvePdfOrientation(page.dataset.pdfOrientation, rect.width, rect.height);
+}
+function waitForPaint() {
+    return new Promise(resolve => {
+        requestAnimationFrame(() => {
+            requestAnimationFrame(() => resolve());
+        });
+    });
+}
+function createUnsupportedColorNormalizer() {
+    const resolveCanvas = document.createElement("canvas");
+    resolveCanvas.width = resolveCanvas.height = 1;
+    const ctx = resolveCanvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx)
+        return null;
+    return (value) => {
+        if (!UNSUPPORTED_COLOR_FUNCTION_RE.test(value))
+            return value;
+        return value.replace(UNSUPPORTED_COLOR_VALUE_RE, match => {
+            try {
+                ctx.clearRect(0, 0, 1, 1);
+                ctx.fillStyle = match;
+                ctx.fillRect(0, 0, 1, 1);
+                const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
+                return `rgb(${r},${g},${b})`;
+            }
+            catch {
+                return match;
+            }
+        });
+    };
+}
+function sanitizeUnsupportedColorFunctions(clonedDocument, normalizeColorValue) {
+    if (!normalizeColorValue)
+        return;
+    const styleEls = clonedDocument.querySelectorAll("style");
+    for (const el of styleEls) {
+        const text = el.textContent;
+        if (!text || !UNSUPPORTED_COLOR_FUNCTION_RE.test(text))
+            continue;
+        el.textContent = normalizeColorValue(text);
+    }
+    const view = clonedDocument.defaultView;
+    if (!view)
+        return;
+    const root = clonedDocument.querySelector(PDF_PAGE_SELECTOR) ?? clonedDocument.body;
+    const elements = [root, ...Array.from(root.querySelectorAll("*"))];
+    for (const element of elements) {
+        const computedStyle = view.getComputedStyle(element);
+        for (const property of COLOR_STYLE_PROPERTIES) {
+            const value = computedStyle.getPropertyValue(property);
+            if (!value || !UNSUPPORTED_COLOR_FUNCTION_RE.test(value))
+                continue;
+            element.style.setProperty(property, normalizeColorValue(value), "important");
+        }
+    }
+}
+export function createDownloadablePdfBlob(pdf) {
+    const blob = pdf.output("blob");
+    if (blob.type === "application/pdf")
+        return blob;
+    return new Blob([blob], { type: "application/pdf" });
+}
+function downloadPdfBlob(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = filename;
+    anchor.rel = "noopener";
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    window.setTimeout(() => URL.revokeObjectURL(url), 60_000);
+}
+export async function renderPreviewToCanvas(root) {
+    // Use final font metrics for both the modal and detached React export paths.
+    await document.fonts?.ready;
+    const page = resolvePdfPage(root);
+    const orientation = resolveOrientation(page);
+    const fitOnePage = page.dataset.pdfFitOnePage === "true";
+    const pageRect = page.getBoundingClientRect();
+    // Capture against the document's own page size, rather than the application
+    // viewport.  A wider viewport changes the layout of fixed-table documents in
+    // html2canvas's cloned iframe and can crop wrapped table text.
+    const pageWidth = Math.ceil(Math.max(pageRect.width, page.scrollWidth));
+    const pageHeight = Math.ceil(Math.max(pageRect.height, page.scrollHeight));
+    const canvas = await html2canvas(page, {
+        backgroundColor: "#fff",
+        scale: Math.min(Math.max(window.devicePixelRatio || 2, 2), 3),
+        useCORS: true,
+        scrollX: 0,
+        scrollY: -window.scrollY,
+        width: pageWidth,
+        height: pageHeight,
+        windowWidth: pageWidth,
+        windowHeight: pageHeight,
+        onclone: (clonedDocument, clonedPage) => {
+            // Preview ancestors carry screen-only scaling and clipping. Remove those
+            // from the capture so text and borders use the same natural coordinates.
+            let ancestor = clonedPage;
+            while (ancestor) {
+                ancestor.style.setProperty("transform", "none", "important");
+                ancestor.style.setProperty("zoom", "1", "important");
+                ancestor.style.setProperty("overflow", "visible", "important");
+                ancestor = ancestor.parentElement;
+            }
+            // html2canvas 1.4.1 can't parse lab()/oklch()/lch() — Tailwind v4 uses them
+            // inside generated stylesheets. Resolve them to rgb() in the clone before
+            // html2canvas reads computed styles.
+            sanitizeUnsupportedColorFunctions(clonedDocument, createUnsupportedColorNormalizer());
+            // ICS uses the page itself as its white paper background. Clear every
+            // structural table fill in the capture clone so html2canvas cannot paint
+            // an opaque header or cell layer over labels and values. Both PDF export
+            // and printing use this capture path.
+            const clonedIcsPage = clonedPage.matches('[data-ics-preview="true"]')
+                ? clonedPage
+                : clonedPage.querySelector('[data-ics-preview="true"]');
+            if (clonedIcsPage) {
+                const tableLayers = clonedIcsPage.querySelectorAll("table, thead, tbody, tr, th, td");
+                for (const layer of tableLayers) {
+                    layer.style.setProperty("background", "transparent", "important");
+                    layer.style.setProperty("background-color", "transparent", "important");
+                }
+            }
+            const style = clonedDocument.createElement("style");
+            style.textContent = `
+				html, body {
+					background: #fff !important;
+				}
+
+				.no-print {
+					display: none !important;
+				}
+
+				${PDF_PAGE_SELECTOR} {
+					box-shadow: none !important;
+					margin: 0 !important;
+					transform: none !important;
+				}
+			`;
+            clonedDocument.head.appendChild(style);
+        },
+    });
+    return { canvas, orientation, fitOnePage };
+}
+export async function exportPreviewElementToPdf(root, filename) {
+    const pages = Array.from(root.querySelectorAll(PDF_PAGE_SELECTOR));
+    if (pages.length > 1) {
+        const pdf = new jsPDF({
+            orientation: resolveOrientation(pages[0]),
+            unit: "mm",
+            format: "a4",
+            compress: true,
+        });
+        for (const [index, page] of pages.entries()) {
+            const { canvas, orientation } = await renderPreviewToCanvas(page);
+            if (index > 0)
+                pdf.addPage("a4", orientation);
+            const pageWidth = pdf.internal.pageSize.getWidth();
+            const pageHeight = pdf.internal.pageSize.getHeight();
+            const scale = Math.min(pageWidth / canvas.width, pageHeight / canvas.height);
+            pdf.addImage(canvas.toDataURL("image/png"), "PNG", 0, 0, canvas.width * scale, canvas.height * scale);
+        }
+        downloadPdfBlob(createDownloadablePdfBlob(pdf), filename);
+        return;
+    }
+    const { canvas, orientation, fitOnePage } = await renderPreviewToCanvas(root);
+    const pdf = new jsPDF({ orientation, unit: "mm", format: "a4", compress: true });
+    const pageWidth = pdf.internal.pageSize.getWidth();
+    const pageHeight = pdf.internal.pageSize.getHeight();
+    if (fitOnePage) {
+        const scale = Math.min(pageWidth / canvas.width, pageHeight / canvas.height);
+        const imageWidth = canvas.width * scale;
+        const imageHeight = canvas.height * scale;
+        const offsetX = (pageWidth - imageWidth) / 2;
+        const offsetY = (pageHeight - imageHeight) / 2;
+        pdf.addImage(canvas.toDataURL("image/png"), "PNG", offsetX, offsetY, imageWidth, imageHeight);
+        downloadPdfBlob(createDownloadablePdfBlob(pdf), filename);
+        return;
+    }
+    // Scale the preview by its width, then slice it at A4-height intervals.
+    // Fitting the entire canvas into one sheet changed the scale of long forms
+    // (such as Purchase Orders) and produced different spacing and page breaks
+    // from the on-screen preview.
+    const sourcePageHeight = (canvas.width * pageHeight) / pageWidth;
+    const pageCount = Math.ceil(canvas.height / sourcePageHeight);
+    for (let pageIndex = 0; pageIndex < pageCount; pageIndex += 1) {
+        const sourceY = pageIndex * sourcePageHeight;
+        const sourceHeight = Math.min(sourcePageHeight, canvas.height - sourceY);
+        const pageCanvas = document.createElement("canvas");
+        pageCanvas.width = canvas.width;
+        pageCanvas.height = Math.ceil(sourceHeight);
+        const context = pageCanvas.getContext("2d");
+        if (!context)
+            throw new Error("Unable to create the PDF page canvas.");
+        context.fillStyle = "#fff";
+        context.fillRect(0, 0, pageCanvas.width, pageCanvas.height);
+        context.drawImage(canvas, 0, sourceY, canvas.width, sourceHeight, 0, 0, pageCanvas.width, sourceHeight);
+        if (pageIndex > 0)
+            pdf.addPage();
+        const imageHeight = (sourceHeight * pageWidth) / canvas.width;
+        pdf.addImage(pageCanvas.toDataURL("image/png"), "PNG", 0, 0, pageWidth, imageHeight);
+    }
+    downloadPdfBlob(createDownloadablePdfBlob(pdf), filename);
+}
+export async function exportPreviewReactToPdf(content, filename) {
+    const container = document.createElement("div");
+    container.style.position = "fixed";
+    container.style.left = "-10000px";
+    container.style.top = "0";
+    container.style.width = "max-content";
+    container.style.background = "#fff";
+    container.style.zIndex = "-1";
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    try {
+        root.render(content);
+        await waitForPaint();
+        await exportPreviewElementToPdf(container, filename);
+    }
+    finally {
+        root.unmount();
+        container.remove();
+    }
+}

package/dist/gam/utils/export-report-xlsx.d.ts

@@ -0,0 +1,228 @@
+export type IarPreviewXlsxItem = {
+    stockNo?: string;
+    description?: string;
+    unit?: string;
+    quantity?: string;
+    unitCost?: string;
+    totalAmount?: string;
+};
+export type IarPreviewXlsxData = {
+    entityName?: string;
+    fundCluster?: string;
+    supplier?: string;
+    iarNo?: string;
+    iarDate?: string | null;
+    crsiNo?: string | null;
+    crsiDate?: string | null;
+    requestingOffice?: string;
+    responsibilityCenterCode?: string;
+    items: IarPreviewXlsxItem[];
+    dateInspected?: string | null;
+    dateReceived?: string | null;
+    isComplete?: boolean;
+    inspectionOfficer?: string;
+    supplyCustodian?: string;
+};
+export type ItrPreviewXlsxItem = {
+    dateAcquired?: string;
+    itemNo?: string;
+    propertyNo?: string;
+    description?: string;
+    amount?: string;
+    conditionOfInventory?: string;
+    conditionOfPPE?: string;
+};
+export type ItrPreviewXlsxData = {
+    entityName?: string;
+    fundCluster?: string;
+    fromAccountableOfficer?: string;
+    fromAccountablePerson?: string;
+    fromDivisionSection?: string;
+    toAccountableOfficer?: string;
+    toAccountablePerson?: string;
+    toDivisionSection?: string;
+    itrNo?: string;
+    transferDate?: string;
+    transferType?: "Donation" | "Reassignment" | "Relocate" | "Others" | string;
+    transferTypeOthers?: string;
+    reason?: string;
+    reasonForTransfer?: string;
+    approvedBy?: string;
+    releasedIssuedBy?: string;
+    receivedBy?: string;
+    items: ItrPreviewXlsxItem[];
+};
+export type IirupPreviewXlsxData = {
+    iirupNo?: string;
+    date?: string;
+    entityName?: string;
+    fundCluster?: string;
+    nameOfAccountableOfficer?: string;
+    designation?: string;
+    station?: string;
+    accountableOfficerSignatory?: string;
+    authorizedOfficialSignatory?: string;
+    inspectionOfficerSignatory?: string;
+    witnessSignatory?: string;
+    items: Array<{
+        dateAcquired?: string;
+        particularsArticles?: string;
+        propertyNo?: string;
+        qty?: string;
+        unitCost?: string;
+        totalCost?: string;
+        accumulatedDepreciation?: string;
+        accumulatedImpairmentLosses?: string;
+        carryingAmount?: string;
+        remarks?: string;
+        sale?: string;
+        transfer?: string;
+        destruction?: string;
+        othersSpecify?: string;
+        total?: string;
+        appraisedValue?: string;
+        orNo?: string;
+        amount?: string;
+    }>;
+};
+export type RegSpiPreviewXlsxEntry = {
+    entryDate?: string;
+    reference?: string;
+    iicRrspNo?: string;
+    semiExpendablePropertyNo?: string;
+    itemDescription?: string;
+    estimatedUsefulLife?: string;
+    issuedQty?: string;
+    issuedOfficeOfficer?: string;
+    returnedQty?: string;
+    returnedOfficeOfficer?: string;
+    reissuedQty?: string;
+    reissuedOfficeOfficer?: string;
+    disposedQty?: string;
+    balance?: string;
+    amount?: string;
+    remarks?: string;
+};
+export type RegSpiPreviewXlsxData = {
+    entityName?: string;
+    semiExpendableProperty?: string;
+    fundCluster?: string;
+    sheetNumber?: string;
+    regSpiNo?: string;
+    entries: RegSpiPreviewXlsxEntry[];
+};
+export type SplcPreviewXlsxEntry = {
+    entryDate?: string;
+    reference?: string;
+    receiptQty?: string;
+    unitCost?: string;
+    totalCost?: string;
+    issuesTransfersAdjustments?: string;
+    accumulatedImpairmentLosses?: string;
+    adjustedCost?: string;
+    natureOfRepair?: string;
+    amount?: string;
+};
+export type SplcPreviewXlsxData = {
+    entityName?: string;
+    fundCluster?: string;
+    semiExpendableProperty?: string;
+    semiExpendablePropertyNumber?: string;
+    description?: string;
+    uacsObjectCode?: string;
+    repairHistory?: string;
+    entries: SplcPreviewXlsxEntry[];
+};
+export type SpcPreviewXlsxEntry = {
+    entryDate?: string;
+    reference?: string;
+    receiptQty?: string;
+    receiptUnitCost?: string;
+    receiptTotalCost?: string;
+    itemNo?: string;
+    issueTransferDisposalQty?: string;
+    issueTransferDisposalOfficeOfficer?: string;
+    balanceQty?: string;
+    amount?: string;
+    remarks?: string;
+};
+export type SpcPreviewXlsxData = {
+    entityName?: string;
+    fundCluster?: string;
+    semiExpendableProperty?: string;
+    semiExpendablePropertyNumber?: string;
+    description?: string;
+    entries: SpcPreviewXlsxEntry[];
+};
+export type RlsddpPreviewXlsxData = {
+    rlsddpNo?: string;
+    entityName?: string;
+    fundCluster?: string;
+    departmentOffice?: string;
+    accountableOfficer?: string;
+    designation?: string;
+    policeNotified?: string;
+    policeStation?: string;
+    policeNotifiedDate?: string;
+    rlsddpDate?: string;
+    parNo?: string;
+    parDate?: string;
+    statusOfProperty?: string;
+    propertyNo?: string;
+    description?: string;
+    acquisitionCost?: string;
+    circumstance?: string;
+    accountableOfficerSignature?: string;
+    accountableOfficerDate?: string;
+    governmentIssuedId?: string;
+    idNo?: string;
+    dateIssued?: string;
+    immediateSupervisorSignature?: string;
+    immediateSupervisorDate?: string;
+    swornDate?: string;
+    docNo?: string;
+    pageNo?: string;
+    bookNo?: string;
+    seriesOf?: string;
+    notaryPublic?: string;
+};
+export type RlsddspPreviewXlsxData = {
+    rlsddspNo?: string;
+    entityName?: string;
+    fundCluster?: string;
+    departmentOffice?: string;
+    accountableOfficer?: string;
+    designation?: string;
+    policeNotified?: string;
+    policeStation?: string;
+    policeNotifiedDate?: string;
+    rlsddspDate?: string;
+    icsNo?: string;
+    icsDate?: string;
+    statusOfProperty?: string;
+    propertyNo?: string;
+    description?: string;
+    acquisitionCost?: string;
+    circumstances?: string;
+    accountableOfficerSignature?: string;
+    accountableOfficerDate?: string;
+    governmentIssuedId?: string;
+    idNo?: string;
+    idDateIssued?: string;
+    immediateSupervisorSignature?: string;
+    immediateSupervisorDate?: string;
+    swornDate?: string;
+    docNo?: string;
+    pageNo?: string;
+    bookNo?: string;
+    seriesOf?: string;
+    notaryPublic?: string;
+};
+export declare function exportIarPreviewXlsx(data: IarPreviewXlsxData, filename?: string): void;
+export declare function exportItrPreviewXlsx(data: ItrPreviewXlsxData, filename?: string): void;
+export declare function exportRegSpiPreviewXlsx(data: RegSpiPreviewXlsxData, filename?: string): void;
+export declare function exportSplcPreviewXlsx(data: SplcPreviewXlsxData, filename?: string): void;
+export declare function exportSpcPreviewXlsx(data: SpcPreviewXlsxData, filename?: string): void;
+export declare function exportRlsddpPreviewXlsx(data: RlsddpPreviewXlsxData, filename?: string): void;
+export declare function exportRlsddspPreviewXlsx(data: RlsddspPreviewXlsxData, filename?: string): void;
+export declare function exportIirupPreviewXlsx(data: IirupPreviewXlsxData, filename?: string): void;