@modusoperandi/licit-import-utils 0.1.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@modusoperandi/licit-import-utils",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "subversion": "1",
+  "description": "A utility package for importing files like json or docx into Licit compatible documents",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MO-Movia/licit-import-utils.git"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest",
+    "test:coverage": "jest --env=jsdom --coverage",
+    "build:clean": "rm -rf dist/ && rm -f modusoperandi-*.*.*.tgz",
+    "lint": "eslint src",
+    "ci:build": "tsc -b tsconfig.prod.json --clean && tsc -b tsconfig.prod.json && npx copyfiles@2.4.1 package.json LICENSE dist",
+    "ci:bom": "npx @cyclonedx/cyclonedx-npm --ignore-npm-errors --short-PURLs --output-format XML --output-file dist/bom.xml",
+    "verify": "npm run lint -- --fix && npm run ci:build && npm run test:coverage && echo 'All Tests Passed!'"
+  },
+  "peerDependencies": {
+    "@modusoperandi/mammoth": "^1.7.0-6",
+    "jszip": "^3.10.1"
+  },
+  "peerDependenciesMeta": {
+    "@modusoperandi/mammoth": {
+      "optional": true
+    },
+    "jszip": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@modusoperandi/mammoth": "^1.7.0-6",
+    "@modusoperandi/eslint-config": "^3.0.3",
+    "@types/jest": "^30.0.0",
+    "jszip": "^3.10.1",
+    "eslint": "^9.39.2",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-junit": "^16.0.0",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/transform.docx.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+import type { MessageSink } from './types';
+export declare class DocxTransformer {
+    private readonly docType;
+    readonly messagesSink?: MessageSink;
+    constructor(docType: string, messagesSink?: MessageSink);
+    transform(arrayBuffer: ArrayBuffer): Promise<Document>;
+    private transformElement;
+    private transformBullets;
+    private transformNonAFDPBullets;
+    private transSubBullets;
+    private getElement;
+}

package/transform.docx.js

@@ -0,0 +1,154 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+const SpecialCharacters = /[\u{1f300}-\u{1f5ff}\u{1f900}-\u{1f9ff}\u{1f600}-\u{1f64f}\u{1f680}-\u{1f6ff}\u{2600}-\u{26ff}\u{2700}-\u{27bf}\u{1f191}-\u{1f251}\u{1f004}\u{1f0cf}\u{1f170}-\u{1f171}\u{1f17e}-\u{1f17f}\u{1f18e}\u{3030}\u{2b50}\u{2b55}\u{2934}-\u{2935}\u{2b05}-\u{2b07}\u{2b1b}-\u{2b1c}\u{3297}\u{3299}\u{303d}\u{00a9}\u{00ae}\u{2122}\u{23f3}\u{24c2}\u{23e9}-\u{23ef}\u{25b6}\u{23f8}-\u{23fa}]/gu;
+export class DocxTransformer {
+    docType;
+    messagesSink;
+    constructor(docType, messagesSink) {
+        this.docType = docType;
+        this.messagesSink = messagesSink;
+    }
+    async transform(arrayBuffer) {
+        const styleMapArray = [
+            'u => u',
+            "p[style-name='toc 1'] => !",
+            "p[style-name='toc 2'] => !",
+            "p[style-name='TOC 1'] => !",
+            "p[style-name='TOC 2'] => !",
+            "p[style-name='TOC 3'] => !",
+            "p[style-name='TOC Heading'] => !",
+            "p[style-name='Default'] => p.Normal:fresh",
+            "p[style-name='List Paragraph'] => p.List-style:fresh",
+        ];
+        if ('Non Specific' !== this.docType) {
+            styleMapArray.push("p[style-name='List Paragraph'] => p.List-style:fresh");
+        }
+        const options = {
+            styleMap: styleMapArray,
+            transformDocument: this.transformElement.bind(this),
+            ignoreEmptyParagraphs: true,
+        };
+        // Mamoth is big, so we load it only when needed
+        const mammoth = await import('@modusoperandi/mammoth/mammoth.browser');
+        const result = (await mammoth.default.convertToHtml({ arrayBuffer }, options));
+        result.messages?.forEach((m) => {
+            this.messagesSink?.(m.type, m.message);
+        });
+        return new DOMParser().parseFromString(result.value, 'text/html');
+    }
+    transformElement(element) {
+        if (element.numbering &&
+            'isOrdered' in element.numbering &&
+            !element.numbering.isOrdered) {
+            if ('Non Specific' === this.docType) {
+                element = this.transformNonAFDPBullets(element);
+            }
+            else {
+                element = this.transformBullets(element);
+            }
+        }
+        if (element.type === 'paragraph') {
+            if ('Non Specific' !== this.docType) {
+                element = this.transSubBullets(element);
+            }
+        }
+        if (element?.children?.length > 0) {
+            const docElements = element.children.filter((c) => 'type' in c);
+            if (docElements.length > 0) {
+                const children = docElements.map((c) => this.transformElement(c));
+                element = { ...element, children: children };
+            }
+        }
+        return element;
+    }
+    /* Method to transform bullets */
+    transformBullets(element) {
+        const undefinedCharacter = '?';
+        element = {
+            ...element,
+            indent: null,
+            numbering: null,
+            styleId: 'AFDP Bullet',
+            styleName: 'AFDP Bullet',
+        };
+        if (element.children?.length > 0 &&
+            'type' in element.children[0] &&
+            element.children[0].children?.length > 0) {
+            const childCharcter = element.children[0].children[0];
+            if ('value' in childCharcter &&
+                childCharcter.value &&
+                (SpecialCharacters.test(childCharcter.value) ||
+                    undefinedCharacter === childCharcter.value.trim())) {
+                element.children.splice(0, 1);
+                element = {
+                    ...element,
+                    indent: null,
+                    numbering: null,
+                    styleId: 'AFDP Sub-bullet',
+                    styleName: 'AFDP Sub-bullet',
+                };
+            }
+        }
+        return element;
+    }
+    /* Method to transform Non AFDP bullets */
+    transformNonAFDPBullets(element) {
+        const undefinedCharacter = '?';
+        element = {
+            ...element,
+            numbering: { ...element.numbering, symbol: '' },
+        };
+        if (element?.children?.[0]?.children?.[0]) {
+            const childCharcter = element.children[0].children[0];
+            if (childCharcter?.value &&
+                (SpecialCharacters.test(childCharcter.value) ||
+                    undefinedCharacter === childCharcter.value.trim())) {
+                element.children.splice(0, 1);
+                element = {
+                    ...element,
+                    numbering: { ...element.numbering, symbol: '' },
+                };
+            }
+        }
+        return element;
+    }
+    /* Method to transform Sub bullets */
+    transSubBullets(element) {
+        element.children ??= [];
+        for (const child of element.children) {
+            if ('type' in child && child.type === 'run') {
+                child.children ??= [];
+                for (const textChild of child.children) {
+                    if ('value' in textChild) {
+                        // Ensure it's a TextElement
+                        this.getElement(element, textChild);
+                    }
+                }
+            }
+        }
+        return element;
+    }
+    getElement(element, textChild) {
+        const undefinedCharacters = ['✪', '', '', '✪✪'];
+        const bulletLimit = element.numbering ? 1 : 2;
+        let bulletsCount = 0;
+        const trimmedValue = textChild.value.trim();
+        if (undefinedCharacters.includes(trimmedValue)) {
+            bulletsCount += trimmedValue.length;
+            element.styleId =
+                element.styleId === 'AFDP Bullet' ||
+                    element.styleId === 'AFDP Sub-bullet' ||
+                    trimmedValue.length === 2
+                    ? 'AFDP Sub-bullet'
+                    : 'AFDP Bullet';
+            element.styleName = element.styleId;
+            textChild.value = '';
+            if (bulletsCount > bulletLimit) {
+                element.styleId = 'Normal';
+                this.messagesSink?.('Warning', 'More than 2 bullet format detected.');
+            }
+        }
+    }
+}

package/transform.utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+import type { LicitDocumentJSON, LicitElementJSON, LicitImageAttrsJSON, LicitTableJSON } from './licit-elements';
+export declare function base64ToFile(imgUrl64: string, fileName: string | number): File;
+export declare function getImageSizeFromBase64(this: void, base64: string, timeout?: number): Promise<{
+    width: number;
+    height: number;
+}>;
+export declare function applyImageSizes(this: void, dom: Document | Element): Promise<void>;
+export declare function applyImageSize(this: void, img: HTMLImageElement): Promise<void>;
+export declare function removeEmptyParagraphFromJSON(this: void, json: LicitDocumentJSON): LicitDocumentJSON;
+export declare function processAllTableWidths(this: void, node?: LicitDocumentJSON | LicitElementJSON | LicitImageAttrsJSON | LicitTableJSON): void;
+export declare function processTableWidths(this: void, node: LicitDocumentJSON | LicitElementJSON | LicitImageAttrsJSON | LicitTableJSON): void;
+export declare function updateImageSrc(file: File, img: HTMLImageElement, updateSrc: (src: File) => Promise<string>, fallback: string | Promise<string>): Promise<void>;
+export declare function updateSource(this: void, img: HTMLImageElement, name: string | number, updateSrc: (src: File) => Promise<string>): Promise<void>;

package/transform.utils.js

@@ -0,0 +1,155 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+//Base 64  Images converted to png for Upload to GUI
+export function base64ToFile(imgUrl64, fileName) {
+    const base64 = imgUrl64.split(',')[1];
+    const byteCharacters = atob(base64);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+        byteNumbers[i] = byteCharacters.codePointAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const type = imgUrl64.substring(imgUrl64.indexOf(':') + 1, imgUrl64.indexOf(';'));
+    const blob = new Blob([byteArray], { type });
+    const name = fileName + '.' + type.substring(type.indexOf('/') + 1);
+    const file = new File([blob], name, {
+        type,
+    });
+    return file;
+}
+export function getImageSizeFromBase64(base64, timeout = 5000) {
+    return new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => resolve({ width: img.width, height: img.height });
+        img.onerror = reject;
+        img.src = base64;
+        setInterval(() => reject(new Error('Image load timeout')), timeout);
+    });
+}
+export async function applyImageSizes(dom) {
+    const imgTags = dom.querySelectorAll('img');
+    await Promise.all(Array.from(imgTags).map(applyImageSize));
+}
+export async function applyImageSize(img) {
+    const imgUrl64 = img?.getAttribute('src');
+    if (!imgUrl64) {
+        return;
+    }
+    const { width, height } = await getImageSizeFromBase64(imgUrl64);
+    const maxWidth = 624;
+    let finalWidth = width;
+    let finalHeight = height;
+    if (finalWidth > maxWidth) {
+        const scale = maxWidth / finalWidth;
+        finalWidth = maxWidth;
+        finalHeight = Math.round(finalHeight * scale);
+    }
+    img.setAttribute('width', finalWidth.toString());
+    img.setAttribute('height', finalHeight.toString());
+}
+export function removeEmptyParagraphFromJSON(json) {
+    removeEmptyNodes(json);
+    return json;
+}
+function removeEmptyNodes(json) {
+    if (Array.isArray(json?.content)) {
+        json.content = json.content
+            .map((item) => removeEmptyNodes(item))
+            .filter((x) => x !== false);
+    }
+    if (json?.type === 'text' && json?.text === '') {
+        return false;
+    }
+    if (json?.type === 'paragraph') {
+        const attrs = json.attrs;
+        if (attrs?.id === 'chspace') {
+            return json;
+        }
+        const titleRegex = /(TableTitle|FigureTitle)$/;
+        if (attrs?.styleName && titleRegex.exec(attrs.styleName)) {
+            return json;
+        }
+        if (!json.content || json.content.length === 0) {
+            return false;
+        }
+        if (json.content.every((item) => item.type === 'text' && item?.text?.trim?.() === '')) {
+            return false;
+        }
+    }
+    return json;
+}
+export function processAllTableWidths(node) {
+    if (node?.type === 'table') {
+        processTableWidths(node);
+    }
+    if (Array.isArray(node?.content)) {
+        node.content.forEach(processAllTableWidths);
+    }
+}
+export function processTableWidths(node) {
+    const tableWidths = [];
+    const firstRow = node.content?.[0];
+    if (firstRow?.content) {
+        for (const cell of firstRow.content) {
+            if (Array.isArray(cell.attrs?.colwidth)) {
+                tableWidths.push(...cell.attrs.colwidth.map(Number));
+            }
+        }
+        const scaledWidths = scaleWidthArray(tableWidths, 619);
+        for (const row of node.content) {
+            for (let i = 0; i < row?.content?.length; i++) {
+                const cell = row.content[i];
+                if (scaledWidths[i] != null) {
+                    cell.attrs.colwidth = [scaledWidths[i]];
+                }
+            }
+        }
+    }
+}
+function scaleWidthArray(rawWidths, target) {
+    const total = rawWidths.reduce((sum, w) => sum + w, 0);
+    const scaled = rawWidths.map((w) => Math.floor((w / total) * target));
+    let diff = target - scaled.reduce((sum, w) => sum + w, 0);
+    // Distribute remaining pixels starting from the largest original width
+    const indices = rawWidths
+        .map((value, index) => ({ value, index }))
+        .sort((a, b) => b.value - a.value)
+        .map((item) => item.index);
+    let i = 0;
+    while (diff > 0) {
+        scaled[indices[i % indices.length]]++;
+        diff--;
+        i++;
+    }
+    return scaled;
+}
+export async function updateImageSrc(file, img, updateSrc, fallback) {
+    const readerPromise = updateSrc(file)
+        .catch((error) => {
+        console.error('Error uploading image:', error);
+        return fallback;
+    })
+        .then((src) => {
+        // Update the image node's src property with the new source
+        // (New source will be URL from GUI)
+        img.src = src;
+        img.setAttribute('srcRelative', src); // This is needed for the image inside table to work
+    });
+    return readerPromise;
+}
+export async function updateSource(img, name, updateSrc) {
+    try {
+        await applyImageSize(img);
+    }
+    catch (err) {
+        console.warn('Could not extract image size', err);
+    }
+    const imgUrl64 = img?.getAttribute('src');
+    if (imgUrl64) {
+        // Convert to File and upload/update src
+        const file = base64ToFile(imgUrl64, name);
+        await updateImageSrc(file, img, (f) => updateSrc(f), imgUrl64);
+    }
+}

package/transform.zip.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+export declare function parseFrameMakerHTM5Zip(this: void, file: File, updateSrc: (src: File) => Promise<string>): Promise<Element[]>;