docxmlater 10.4.1 → 11.0.4

package/dist/esm/formatting/NumberingLevel.js

@@ -0,0 +1,608 @@
+import { parseOnOffAttribute } from '../utils/parsingHelpers.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+export const WORD_NATIVE_BULLETS = {
+    FILLED_BULLET: { char: '\uF0B7', font: 'Symbol' },
+    OPEN_CIRCLE: { char: '\u006F', font: 'Courier New' },
+    FILLED_SQUARE: { char: '\uF0A7', font: 'Wingdings' },
+};
+export class NumberingLevel {
+    properties;
+    constructor(properties) {
+        this.properties = {
+            level: properties.level,
+            format: properties.format,
+            text: properties.text,
+            alignment: properties.alignment || 'left',
+            start: properties.start !== undefined ? properties.start : 1,
+            leftIndent: properties.leftIndent !== undefined ? properties.leftIndent : 720 + properties.level * 360,
+            hangingIndent: properties.hangingIndent !== undefined ? properties.hangingIndent : 360,
+            font: properties.font || 'Calibri',
+            fontSize: properties.fontSize || 22,
+            isLegalNumberingStyle: properties.isLegalNumberingStyle !== undefined ? properties.isLegalNumberingStyle : false,
+            suffix: properties.suffix || 'tab',
+            color: properties.color || '000000',
+            bold: properties.bold !== undefined ? properties.bold : false,
+            italic: properties.italic !== undefined ? properties.italic : false,
+            underline: properties.underline,
+            lvlRestart: properties.lvlRestart,
+            pStyle: properties.pStyle,
+            tentative: properties.tentative,
+            tplc: properties.tplc,
+            lvlPicBulletId: properties.lvlPicBulletId,
+            legacy: properties.legacy,
+        };
+        this.validate();
+    }
+    validate() {
+        if (this.properties.level < 0 || this.properties.level > 8) {
+            throw new Error(`Level must be between 0 and 8, got ${this.properties.level}`);
+        }
+        if (this.properties.hangingIndent < 0) {
+            throw new Error('Hanging indent must be non-negative');
+        }
+        if (this.properties.start < 0) {
+            throw new Error('Start value must be non-negative');
+        }
+    }
+    static calculateSafeIndentation(level, pageWidthTwips = 12240, leftMarginTwips = 1440, rightMarginTwips = 1440, minContentWidth = 2880) {
+        if (level < 0 || level > 8) {
+            throw new Error(`Invalid level ${level}. Level must be between 0 and 8.`);
+        }
+        const availableWidth = pageWidthTwips - leftMarginTwips - rightMarginTwips;
+        const maxSafeIndent = Math.max(0, availableWidth - minContentWidth);
+        const standardLeftIndent = 720 + level * 360;
+        const hangingIndent = 360;
+        const safeLeftIndent = Math.min(standardLeftIndent, maxSafeIndent);
+        return {
+            leftIndent: safeLeftIndent,
+            hangingIndent,
+        };
+    }
+    getLevel() {
+        return this.properties.level;
+    }
+    getFormat() {
+        return this.properties.format;
+    }
+    getProperties() {
+        return { ...this.properties };
+    }
+    setLeftIndent(twips) {
+        this.properties.leftIndent = twips;
+        return this;
+    }
+    setHangingIndent(twips) {
+        if (twips < 0) {
+            throw new Error('Hanging indent must be non-negative');
+        }
+        this.properties.hangingIndent = twips;
+        return this;
+    }
+    setFont(font) {
+        this.properties.font = font;
+        return this;
+    }
+    setAlignment(alignment) {
+        this.properties.alignment = alignment;
+        return this;
+    }
+    setFontSize(halfPoints) {
+        this.properties.fontSize = halfPoints;
+        return this;
+    }
+    setText(text) {
+        this.properties.text = text;
+        return this;
+    }
+    setColor(color) {
+        this.properties.color = color;
+        return this;
+    }
+    setBold(bold) {
+        this.properties.bold = bold;
+        return this;
+    }
+    setItalic(italic) {
+        this.properties.italic = italic;
+        return this;
+    }
+    getItalic() {
+        return this.properties.italic ?? false;
+    }
+    setUnderline(style) {
+        this.properties.underline = style;
+        return this;
+    }
+    getUnderline() {
+        return this.properties.underline;
+    }
+    clearUnderline() {
+        this.properties.underline = undefined;
+        return this;
+    }
+    setLvlRestart(level) {
+        if (level !== undefined && (level < 0 || level > 8)) {
+            throw new Error(`lvlRestart must be between 0 and 8, got ${level}`);
+        }
+        this.properties.lvlRestart = level;
+        return this;
+    }
+    getLvlRestart() {
+        return this.properties.lvlRestart;
+    }
+    setParagraphStyle(styleId) {
+        this.properties.pStyle = styleId;
+        return this;
+    }
+    getParagraphStyle() {
+        return this.properties.pStyle;
+    }
+    setFormat(format) {
+        this.properties.format = NumberingLevel.normalizeFormat(format);
+        return this;
+    }
+    static normalizeFormat(format) {
+        const corrections = {
+            'a.': 'lowerLetter',
+            'A.': 'upperLetter',
+            'i.': 'lowerRoman',
+            'I.': 'upperRoman',
+            '1.': 'decimal',
+        };
+        return (corrections[format] ?? format);
+    }
+    toXML() {
+        const children = [];
+        children.push(XMLBuilder.wSelf('start', { 'w:val': this.properties.start.toString() }));
+        children.push(XMLBuilder.wSelf('numFmt', { 'w:val': this.properties.format }));
+        if (this.properties.lvlRestart !== undefined) {
+            children.push(XMLBuilder.wSelf('lvlRestart', { 'w:val': this.properties.lvlRestart.toString() }));
+        }
+        if (this.properties.pStyle) {
+            children.push(XMLBuilder.wSelf('pStyle', { 'w:val': this.properties.pStyle }));
+        }
+        if (this.properties.isLegalNumberingStyle) {
+            children.push(XMLBuilder.wSelf('isLgl'));
+        }
+        if (this.properties.suffix) {
+            children.push(XMLBuilder.wSelf('suff', { 'w:val': this.properties.suffix }));
+        }
+        children.push(XMLBuilder.wSelf('lvlText', { 'w:val': this.properties.text }));
+        if (this.properties.lvlPicBulletId !== undefined) {
+            children.push(XMLBuilder.wSelf('lvlPicBulletId', {
+                'w:val': this.properties.lvlPicBulletId.toString(),
+            }));
+        }
+        if (this.properties.legacy) {
+            const legacyAttrs = {};
+            if (this.properties.legacy.legacy !== undefined) {
+                legacyAttrs['w:legacy'] = this.properties.legacy.legacy ? '1' : '0';
+            }
+            if (this.properties.legacy.legacySpace !== undefined) {
+                legacyAttrs['w:legacySpace'] = this.properties.legacy.legacySpace.toString();
+            }
+            if (this.properties.legacy.legacyIndent !== undefined) {
+                legacyAttrs['w:legacyIndent'] = this.properties.legacy.legacyIndent.toString();
+            }
+            children.push(XMLBuilder.wSelf('legacy', legacyAttrs));
+        }
+        children.push(XMLBuilder.wSelf('lvlJc', { 'w:val': this.properties.alignment }));
+        const ind = XMLBuilder.wSelf('ind', {
+            'w:left': this.properties.leftIndent.toString(),
+            'w:hanging': this.properties.hangingIndent.toString(),
+        });
+        const pPr = XMLBuilder.w('pPr', undefined, [ind]);
+        children.push(pPr);
+        const rPrChildren = [];
+        rPrChildren.push(XMLBuilder.wSelf('rFonts', {
+            'w:ascii': this.properties.font,
+            'w:hAnsi': this.properties.font,
+            'w:cs': this.properties.font,
+            'w:hint': 'default',
+        }));
+        if (this.properties.bold) {
+            rPrChildren.push(XMLBuilder.wSelf('b'));
+            rPrChildren.push(XMLBuilder.wSelf('bCs'));
+        }
+        if (this.properties.italic) {
+            rPrChildren.push(XMLBuilder.wSelf('i'));
+            rPrChildren.push(XMLBuilder.wSelf('iCs'));
+        }
+        if (this.properties.color) {
+            rPrChildren.push(XMLBuilder.wSelf('color', { 'w:val': this.properties.color }));
+        }
+        rPrChildren.push(XMLBuilder.wSelf('sz', { 'w:val': this.properties.fontSize.toString() }));
+        rPrChildren.push(XMLBuilder.wSelf('szCs', { 'w:val': this.properties.fontSize.toString() }));
+        if (this.properties.underline) {
+            rPrChildren.push(XMLBuilder.wSelf('u', { 'w:val': this.properties.underline }));
+        }
+        const rPr = XMLBuilder.w('rPr', undefined, rPrChildren);
+        children.push(rPr);
+        const lvlAttrs = { 'w:ilvl': this.properties.level.toString() };
+        if (this.properties.tplc) {
+            lvlAttrs['w:tplc'] = this.properties.tplc;
+        }
+        if (this.properties.tentative) {
+            lvlAttrs['w:tentative'] = '1';
+        }
+        return XMLBuilder.w('lvl', lvlAttrs, children);
+    }
+    static getBulletSymbolWithFont(level, style = 'standard') {
+        const bulletSets = {
+            standard: [
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+            ],
+            circle: [
+                { symbol: '●', font: 'Calibri' },
+                { symbol: '○', font: 'Calibri' },
+                { symbol: '◉', font: 'Calibri' },
+                { symbol: '◯', font: 'Calibri' },
+                { symbol: '⦿', font: 'Calibri' },
+                { symbol: '○', font: 'Calibri' },
+                { symbol: '●', font: 'Calibri' },
+                { symbol: '○', font: 'Calibri' },
+                { symbol: '◉', font: 'Calibri' },
+            ],
+            square: [
+                { symbol: '■', font: 'Calibri' },
+                { symbol: '□', font: 'Calibri' },
+                { symbol: '▪', font: 'Calibri' },
+                { symbol: '▫', font: 'Calibri' },
+                { symbol: '◼', font: 'Calibri' },
+                { symbol: '◻', font: 'Calibri' },
+                { symbol: '■', font: 'Calibri' },
+                { symbol: '□', font: 'Calibri' },
+                { symbol: '▪', font: 'Calibri' },
+            ],
+            arrow: [
+                { symbol: '➢', font: 'Calibri' },
+                { symbol: '➣', font: 'Calibri' },
+                { symbol: '➤', font: 'Calibri' },
+                { symbol: '➔', font: 'Calibri' },
+                { symbol: '➜', font: 'Calibri' },
+                { symbol: '➢', font: 'Calibri' },
+                { symbol: '➣', font: 'Calibri' },
+                { symbol: '➤', font: 'Calibri' },
+                { symbol: '➔', font: 'Calibri' },
+            ],
+            check: [
+                { symbol: '✓', font: 'Calibri' },
+                { symbol: '✔', font: 'Calibri' },
+                { symbol: '☑', font: 'Calibri' },
+                { symbol: '✓', font: 'Calibri' },
+                { symbol: '✔', font: 'Calibri' },
+                { symbol: '☑', font: 'Calibri' },
+                { symbol: '✓', font: 'Calibri' },
+                { symbol: '✔', font: 'Calibri' },
+                { symbol: '☑', font: 'Calibri' },
+            ],
+            'word-native': [
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_BULLET.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_BULLET.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.OPEN_CIRCLE.char,
+                    font: WORD_NATIVE_BULLETS.OPEN_CIRCLE.font,
+                },
+                {
+                    symbol: WORD_NATIVE_BULLETS.FILLED_SQUARE.char,
+                    font: WORD_NATIVE_BULLETS.FILLED_SQUARE.font,
+                },
+            ],
+        };
+        const selectedSet = bulletSets[style];
+        const levelIndex = level % selectedSet.length;
+        const result = selectedSet[levelIndex];
+        return result || { symbol: '•', font: 'Calibri' };
+    }
+    static calculateStandardIndentation(level) {
+        if (level < 0 || level > 8) {
+            throw new Error(`Invalid level ${level}. Level must be between 0 and 8.`);
+        }
+        return {
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        };
+    }
+    static getStandardNumberFormat(level) {
+        if (level < 0 || level > 8) {
+            throw new Error(`Invalid level ${level}. Level must be between 0 and 8.`);
+        }
+        const formats = [
+            'decimal',
+            'lowerLetter',
+            'lowerRoman',
+            'upperLetter',
+            'upperRoman',
+        ];
+        const result = formats[level % formats.length];
+        return result || 'decimal';
+    }
+    static createBulletLevel(level, bullet, font) {
+        const defaults = NumberingLevel.getBulletSymbolWithFont(level, 'standard');
+        const actualBullet = bullet ?? defaults.symbol;
+        const actualFont = font ?? defaults.font;
+        return new NumberingLevel({
+            level,
+            format: 'bullet',
+            text: actualBullet,
+            alignment: 'left',
+            font: actualFont,
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static createDecimalLevel(level, template = `%${level + 1}.`) {
+        return new NumberingLevel({
+            level,
+            format: 'decimal',
+            text: template,
+            alignment: 'left',
+            font: 'Verdana',
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static createLowerRomanLevel(level, template = `%${level + 1}.`) {
+        return new NumberingLevel({
+            level,
+            format: 'lowerRoman',
+            text: template,
+            alignment: 'left',
+            font: 'Verdana',
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static createUpperRomanLevel(level, template = `%${level + 1}.`) {
+        return new NumberingLevel({
+            level,
+            format: 'upperRoman',
+            text: template,
+            alignment: 'left',
+            font: 'Verdana',
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static createLowerLetterLevel(level, template = `%${level + 1}.`) {
+        return new NumberingLevel({
+            level,
+            format: 'lowerLetter',
+            text: template,
+            alignment: 'left',
+            font: 'Verdana',
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static createUpperLetterLevel(level, template = `%${level + 1}.`) {
+        return new NumberingLevel({
+            level,
+            format: 'upperLetter',
+            text: template,
+            alignment: 'left',
+            font: 'Verdana',
+            fontSize: 24,
+            bold: false,
+            color: '000000',
+            leftIndent: 720 + level * 360,
+            hangingIndent: 360,
+        });
+    }
+    static create(properties) {
+        return new NumberingLevel(properties);
+    }
+    static fromXML(xml) {
+        const ilvlMatch = /<w:lvl[^>]*w:ilvl="([^"]+)"/.exec(xml);
+        if (!ilvlMatch?.[1]) {
+            throw new Error('Missing required w:ilvl attribute');
+        }
+        const level = parseInt(ilvlMatch[1], 10);
+        let tentative;
+        let tplc;
+        const lvlOpenEnd = xml.indexOf('>');
+        if (lvlOpenEnd !== -1) {
+            const lvlOpenTag = xml.substring(0, lvlOpenEnd);
+            const tentativeMatch = /w:tentative\s*=\s*"([^"]*)"/.exec(lvlOpenTag);
+            if (tentativeMatch?.[1] !== undefined) {
+                tentative = parseOnOffAttribute(tentativeMatch[1]);
+            }
+            const tplcMatch = /w:tplc\s*=\s*"([^"]*)"/.exec(lvlOpenTag);
+            if (tplcMatch?.[1]) {
+                tplc = tplcMatch[1];
+            }
+        }
+        let lvlPicBulletId;
+        const picBulletMatch = /<w:lvlPicBulletId\s[^>]*w:val="([^"]+)"/.exec(xml);
+        if (picBulletMatch?.[1] !== undefined) {
+            const parsed = parseInt(picBulletMatch[1], 10);
+            if (!isNaN(parsed)) {
+                lvlPicBulletId = parsed;
+            }
+        }
+        let legacy;
+        const legacyMatch = /<w:legacy\b([^>]*)\/?>/.exec(xml);
+        if (legacyMatch) {
+            const attrs = legacyMatch[1] ?? '';
+            legacy = {};
+            const legacyValMatch = /\bw:legacy\s*=\s*"([^"]*)"/.exec(attrs);
+            if (legacyValMatch?.[1] !== undefined) {
+                legacy.legacy = parseOnOffAttribute(legacyValMatch[1]);
+            }
+            const spaceMatch = /\bw:legacySpace\s*=\s*"([^"]*)"/.exec(attrs);
+            if (spaceMatch?.[1] !== undefined) {
+                const parsed = parseInt(spaceMatch[1], 10);
+                if (!isNaN(parsed))
+                    legacy.legacySpace = parsed;
+            }
+            const indentMatch = /\bw:legacyIndent\s*=\s*"([^"]*)"/.exec(attrs);
+            if (indentMatch?.[1] !== undefined) {
+                const parsed = parseInt(indentMatch[1], 10);
+                if (!isNaN(parsed))
+                    legacy.legacyIndent = parsed;
+            }
+        }
+        const numFmtMatch = /<w:numFmt[^>]*w:val="([^"]+)"/.exec(xml);
+        if (!numFmtMatch?.[1]) {
+            throw new Error('Missing required w:numFmt element');
+        }
+        const format = NumberingLevel.normalizeFormat(numFmtMatch[1]);
+        const lvlTextMatch = /<w:lvlText[^>]*w:val="([^"]*)"/.exec(xml);
+        const text = lvlTextMatch?.[1] !== undefined ? lvlTextMatch[1] : '';
+        const lvlJcMatch = /<w:lvlJc[^>]*w:val="([^"]+)"/.exec(xml);
+        const alignment = (lvlJcMatch?.[1] ? lvlJcMatch[1] : 'left');
+        const startMatch = /<w:start[^>]*w:val="([^"]+)"/.exec(xml);
+        const start = startMatch?.[1] ? parseInt(startMatch[1], 10) : 1;
+        const suffixMatch = /<w:suff[^>]*w:val="([^"]+)"/.exec(xml);
+        const suffix = suffixMatch?.[1] ? suffixMatch[1] : 'tab';
+        let lvlRestart;
+        const lvlRestartMatch = /<w:lvlRestart[^>]*w:val="([^"]+)"/.exec(xml);
+        if (lvlRestartMatch?.[1]) {
+            lvlRestart = parseInt(lvlRestartMatch[1], 10);
+        }
+        let pStyle;
+        const pStyleMatch = /<w:pStyle[^>]*w:val="([^"]+)"/.exec(xml);
+        if (pStyleMatch?.[1]) {
+            pStyle = pStyleMatch[1];
+        }
+        let isLegalNumberingStyle;
+        const isLglMatch = /<w:isLgl\b([^>]*)\/?>/.exec(xml);
+        if (isLglMatch) {
+            const attrs = isLglMatch[1] ?? '';
+            const valMatch = /w:val\s*=\s*"([^"]*)"/.exec(attrs);
+            isLegalNumberingStyle = valMatch?.[1] !== undefined ? parseOnOffAttribute(valMatch[1]) : true;
+        }
+        let leftIndent = 720 + level * 360;
+        let hangingIndent = 360;
+        const indMatch = /<w:ind\b[^>]*>/.exec(xml);
+        if (indMatch) {
+            const indElement = indMatch[0];
+            const leftMatch = /\bw:start\s*=\s*"([^"]+)"/.exec(indElement) || /\bw:left\s*=\s*"([^"]+)"/.exec(indElement);
+            const hangingMatch = /\bw:hanging\s*=\s*"([^"]+)"/.exec(indElement);
+            if (leftMatch?.[1])
+                leftIndent = parseInt(leftMatch[1], 10);
+            if (hangingMatch?.[1])
+                hangingIndent = parseInt(hangingMatch[1], 10);
+        }
+        let font = 'Calibri';
+        let fontSize = 22;
+        const rFontsMatch = /<w:rFonts[^>]*\/>/.exec(xml);
+        if (rFontsMatch) {
+            const rFontsElement = rFontsMatch[0];
+            const asciiMatch = /w:ascii="([^"]+)"/.exec(rFontsElement);
+            if (asciiMatch?.[1])
+                font = asciiMatch[1];
+        }
+        const szMatch = /<w:sz[^>]*w:val="([^"]+)"/.exec(xml);
+        if (szMatch?.[1])
+            fontSize = parseInt(szMatch[1], 10);
+        const bold = false;
+        const italic = false;
+        const underline = undefined;
+        let color;
+        const colorMatch = /<w:color[^>]*w:val="([^"]+)"/.exec(xml);
+        if (colorMatch?.[1]) {
+            color = colorMatch[1];
+        }
+        return new NumberingLevel({
+            level,
+            format,
+            text,
+            alignment,
+            start,
+            leftIndent,
+            hangingIndent,
+            font,
+            fontSize,
+            suffix,
+            bold,
+            italic,
+            underline,
+            color,
+            lvlRestart,
+            pStyle,
+            isLegalNumberingStyle,
+            tentative,
+            tplc,
+            lvlPicBulletId,
+            legacy,
+        });
+    }
+}
+//# sourceMappingURL=NumberingLevel.js.map