@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/numbering/list-string.js

@@ -0,0 +1,423 @@
+/**
+ * Pure list label computation for {@link Paragraph.listString}.
+ *
+ * @private
+ */
+import { visitParagraphsInDocumentOrder } from '../../core/registry/index';
+import { Paragraph } from '../document/paragraph';
+import { numberingFor } from './index';
+function numberingCatalog(document) {
+    return numberingFor(document);
+}
+/**
+ * Compute the display string for a paragraph's list label without mutating state.
+ *
+ * @private
+ */
+export function computeListString(paragraph) {
+    var listId = paragraph.numId;
+    if (listId === undefined) {
+        return '';
+    }
+    var doc;
+    try {
+        doc = paragraph.owningDocument();
+    }
+    catch (_a) {
+        return '';
+    }
+    var numbering;
+    try {
+        numbering = numberingCatalog(doc);
+    }
+    catch (_b) {
+        return '';
+    }
+    var instance = numbering.getNumbering(listId);
+    if (instance === undefined) {
+        return '';
+    }
+    var abstract = numbering.getAbstractNumbering(instance.abstractNumId);
+    if (abstract === undefined) {
+        return '';
+    }
+    var targetLevel = paragraph.listLevel !== undefined ? paragraph.listLevel : 0;
+    var counters = new Map();
+    var result = '';
+    visitParagraphsInDocumentOrder(doc, function (p) {
+        if (p.numId === undefined) {
+            return;
+        }
+        var numId = p.numId;
+        var inst = numbering.getNumbering(numId);
+        if (inst === undefined) {
+            return;
+        }
+        var abs = numbering.getAbstractNumbering(inst.abstractNumId);
+        if (abs === undefined) {
+            return;
+        }
+        var ilvl = p.listLevel !== undefined ? p.listLevel : 0;
+        var key = String(numId);
+        var state = counters.get(key);
+        if (state === undefined) {
+            state = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+            // Initialize from start values
+            for (var i = 0; i < 9; i += 1) {
+                state[i] = resolveStart(inst, abs.levels, i) - 1;
+            }
+            counters.set(key, state);
+        }
+        // Restart deeper levels when a shallower level advances
+        for (var i = ilvl + 1; i < 9; i += 1) {
+            var restart = resolveRestartLevel(abs.levels, i);
+            if (restart <= ilvl) {
+                state[i] = resolveStart(inst, abs.levels, i) - 1;
+            }
+        }
+        state[ilvl] = (state[ilvl] !== undefined ? state[ilvl] : 0) + 1;
+        if (p === paragraph) {
+            result = renderLabel(abs.levels, inst, ilvl, state);
+        }
+    });
+    return result;
+}
+Object.defineProperty(Paragraph.prototype, 'listString', {
+    get: function () {
+        return computeListString(this);
+    },
+    configurable: true,
+});
+function resolveStart(instance, levels, ilvl) {
+    var override = instance.levelOverrides.find(function (entry) { return entry.ilvl === ilvl; });
+    if (override !== undefined && override.startOverride !== undefined) {
+        return override.startOverride;
+    }
+    var level = resolveLevel(instance, levels, ilvl);
+    if (level !== undefined && level.start !== undefined) {
+        return level.start;
+    }
+    return 1;
+}
+function resolveRestartLevel(levels, ilvl) {
+    var level = levels.find(function (entry) { return entry.ilvl === ilvl; });
+    if (level === undefined) {
+        return ilvl;
+    }
+    var extras = level.getExtras();
+    for (var i = 0; i < extras.length; i += 1) {
+        var extra = extras[i];
+        if (extra.localName === 'lvlRestart') {
+            for (var a = 0; a < extra.attributes.length; a += 1) {
+                var attr = extra.attributes[a];
+                if (attr.localName === 'val' && /^\d+$/.test(attr.value)) {
+                    return parseInt(attr.value, 10);
+                }
+            }
+        }
+    }
+    return ilvl;
+}
+function resolveLevel(instance, levels, ilvl) {
+    var override = instance.levelOverrides.find(function (entry) { return entry.ilvl === ilvl; });
+    if (override !== undefined && override.level !== undefined) {
+        return override.level;
+    }
+    var found = levels.find(function (entry) { return entry.ilvl === ilvl; });
+    if (found !== undefined) {
+        return found;
+    }
+    return levels.length > 0 ? levels[0] : undefined;
+}
+function renderLabel(levels, instance, ilvl, counters) {
+    var level = resolveLevel(instance, levels, ilvl);
+    if (level === undefined) {
+        return '';
+    }
+    var numFmt = level.numFmt !== undefined ? level.numFmt : 'decimal';
+    if (numFmt === 'bullet') {
+        return level.lvlText !== undefined ? level.lvlText : '';
+    }
+    if (numFmt === 'none') {
+        return '';
+    }
+    var pattern = level.lvlText !== undefined ? level.lvlText : '%' + String(ilvl + 1);
+    var isLegal = level.isLgl === true;
+    // Expand %1..%9
+    var out = '';
+    for (var i = 0; i < pattern.length; i += 1) {
+        var ch = pattern.charAt(i);
+        if (ch === '%' && i + 1 < pattern.length) {
+            var digit = pattern.charAt(i + 1);
+            if (digit >= '1' && digit <= '9') {
+                var idx = parseInt(digit, 10) - 1;
+                var n = counters[idx] !== undefined ? counters[idx] : 0;
+                var fmt = numFmt;
+                if (idx !== ilvl) {
+                    var other = resolveLevel(instance, levels, idx);
+                    fmt = other !== undefined && other.numFmt !== undefined ? other.numFmt : 'decimal';
+                }
+                if (isLegal) {
+                    fmt = 'decimal';
+                }
+                out += formatNumber(n, fmt);
+                i += 1;
+                continue;
+            }
+        }
+        out += ch;
+    }
+    return out;
+}
+function formatNumber(n, numFmt) {
+    if (n < 0) {
+        n = 0;
+    }
+    switch (numFmt) {
+        case 'decimal':
+            return String(n);
+        case 'decimalZero':
+            return n < 10 ? '0' + String(n) : String(n);
+        case 'upperRoman':
+            return toRoman(n).toUpperCase();
+        case 'lowerRoman':
+            return toRoman(n).toLowerCase();
+        case 'upperLetter':
+            return toLetters(n).toUpperCase();
+        case 'lowerLetter':
+            return toLetters(n).toLowerCase();
+        case 'ordinal':
+            return toOrdinal(n);
+        case 'ordinalText':
+            return toOrdinalText(n);
+        case 'cardinalText':
+            return toCardinalText(n);
+        case 'bullet':
+            return '';
+        case 'none':
+            return '';
+        case 'decimalEnclosedParen':
+            return '(' + String(n) + ')';
+        case 'decimalEnclosedFullstop':
+            return String(n) + '.';
+        case 'decimalEnclosedCircle':
+        case 'decimalEnclosedCircleChinese':
+            return enclosedCircle(n);
+        case 'decimalFullWidth':
+            return toFullWidthDecimal(n);
+        case 'decimalHalfWidth':
+            return String(n);
+        case 'hebrew1':
+        case 'hebrew2':
+            return toHebrew(n);
+        case 'hindiNumbers':
+            return toHindiDigits(n);
+        case 'hindiCounting':
+            return toCardinalText(n);
+        case 'hindiVowels':
+        case 'hindiConsonants':
+            return toLetters(n).toLowerCase();
+        case 'chineseCounting':
+        case 'chineseCountingThousand':
+        case 'chineseLegalSimplified':
+        case 'japaneseCounting':
+        case 'japaneseDigitalTenThousand':
+        case 'japaneseLegal':
+        case 'koreanCounting':
+        case 'koreanDigital':
+        case 'koreanDigital2':
+        case 'koreanLegal':
+        case 'taiwaneseCounting':
+        case 'taiwaneseCountingThousand':
+        case 'taiwaneseDigital':
+        case 'ideographTraditional':
+        case 'ideographZodiac':
+        case 'ideographZodiacTraditional':
+        case 'ideographEnclosedCircle':
+            return String(n);
+        case 'aiueo':
+        case 'aiueoFullWidth':
+            return toAiueo(n);
+        case 'iroha':
+        case 'irohaFullWidth':
+            return toIroha(n);
+        case 'ganada':
+        case 'chosung':
+            return toLetters(n).toLowerCase();
+        default:
+            return String(n);
+    }
+}
+function toRoman(num) {
+    if (num <= 0) {
+        return String(num);
+    }
+    var vals = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+    var syms = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
+    var n = num;
+    var out = '';
+    for (var i = 0; i < vals.length; i += 1) {
+        while (n >= vals[i]) {
+            out += syms[i];
+            n -= vals[i];
+        }
+    }
+    return out;
+}
+function toLetters(num) {
+    if (num <= 0) {
+        return String(num);
+    }
+    var n = num;
+    var out = '';
+    while (n > 0) {
+        n -= 1;
+        out = String.fromCharCode(97 + (n % 26)) + out;
+        n = Math.floor(n / 26);
+    }
+    return out;
+}
+function toOrdinal(n) {
+    var mod100 = n % 100;
+    if (mod100 >= 11 && mod100 <= 13) {
+        return String(n) + 'th';
+    }
+    switch (n % 10) {
+        case 1:
+            return String(n) + 'st';
+        case 2:
+            return String(n) + 'nd';
+        case 3:
+            return String(n) + 'rd';
+        default:
+            return String(n) + 'th';
+    }
+}
+var ONES = [
+    'zero',
+    'one',
+    'two',
+    'three',
+    'four',
+    'five',
+    'six',
+    'seven',
+    'eight',
+    'nine',
+    'ten',
+    'eleven',
+    'twelve',
+    'thirteen',
+    'fourteen',
+    'fifteen',
+    'sixteen',
+    'seventeen',
+    'eighteen',
+    'nineteen',
+];
+var TENS = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
+function toCardinalText(n) {
+    if (n < 0) {
+        return String(n);
+    }
+    if (n < 20) {
+        return ONES[n];
+    }
+    if (n < 100) {
+        var t = Math.floor(n / 10);
+        var o = n % 10;
+        return o === 0 ? TENS[t] : TENS[t] + '-' + ONES[o];
+    }
+    if (n < 1000) {
+        var h = Math.floor(n / 100);
+        var rest = n % 100;
+        return rest === 0 ? ONES[h] + ' hundred' : ONES[h] + ' hundred ' + toCardinalText(rest);
+    }
+    return String(n);
+}
+function toOrdinalText(n) {
+    var card = toCardinalText(n);
+    if (card === 'one') {
+        return 'first';
+    }
+    if (card === 'two') {
+        return 'second';
+    }
+    if (card === 'three') {
+        return 'third';
+    }
+    if (card === 'five') {
+        return 'fifth';
+    }
+    if (card === 'eight') {
+        return 'eighth';
+    }
+    if (card === 'nine') {
+        return 'ninth';
+    }
+    if (card === 'twelve') {
+        return 'twelfth';
+    }
+    if (card.charAt(card.length - 1) === 'y') {
+        return card.substring(0, card.length - 1) + 'ieth';
+    }
+    return card + 'th';
+}
+function toHebrew(n) {
+    // Best-effort decimal fallback with Hebrew letter mapping for 1-10
+    var map = ['', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י'];
+    if (n >= 1 && n <= 10) {
+        return map[n];
+    }
+    return String(n);
+}
+function toHindiDigits(n) {
+    var digits = String(n);
+    var out = '';
+    for (var i = 0; i < digits.length; i += 1) {
+        var code = digits.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            out += String.fromCharCode(0x0966 + (code - 48));
+        }
+        else {
+            out += digits.charAt(i);
+        }
+    }
+    return out;
+}
+function toFullWidthDecimal(n) {
+    var digits = String(n);
+    var out = '';
+    for (var i = 0; i < digits.length; i += 1) {
+        var code = digits.charCodeAt(i);
+        if (code >= 48 && code <= 57) {
+            out += String.fromCharCode(0xff10 + (code - 48));
+        }
+        else {
+            out += digits.charAt(i);
+        }
+    }
+    return out;
+}
+function enclosedCircle(n) {
+    if (n >= 1 && n <= 20) {
+        return String.fromCharCode(0x2460 + n - 1);
+    }
+    return String(n);
+}
+var AIUEO = 'あいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわをん';
+function toAiueo(n) {
+    if (n <= 0) {
+        return String(n);
+    }
+    var idx = (n - 1) % AIUEO.length;
+    return AIUEO.charAt(idx);
+}
+var IROHA = 'いろはにほへとちりぬるをわかよたれそつねならむうゐのおくやまけふこえてあさきゆめみしゑひもせす';
+function toIroha(n) {
+    if (n <= 0) {
+        return String(n);
+    }
+    var idx = (n - 1) % IROHA.length;
+    return IROHA.charAt(idx);
+}

package/src/features/numbering/list-style.d.ts

@@ -0,0 +1,204 @@
+import { WordDocument } from '../document/document';
+import { CharacterFormat, CharacterFormatHost } from '../document/character-format';
+import { ParagraphFormat, ParagraphFormatHost } from '../document/paragraph-format';
+import { NumberingLevel } from './numbering-level';
+/** Minimal numbering catalog surface used by list-style. */
+interface NumberingCatalog {
+    allocateAbstractNumId(): number;
+    registerAbstract(abstract: import('./abstract-numbering').AbstractNumbering): void;
+    markDirty(): void;
+    readonly abstractNumberings: ReadonlyArray<{
+        readonly abstractNumId: number;
+        readonly styleLink: string | undefined;
+        readonly name: string | undefined;
+        readonly numStyleLink: string | undefined;
+    }>;
+}
+/**
+ * High-level list category for {@link WordDocument.addListStyle}.
+ *
+ * @public
+ */
+export declare enum ListType {
+    Bulleted = "bulleted",
+    Numbered = "numbered"
+}
+/**
+ * Number / bullet pattern for a list level (`w:numFmt`).
+ *
+ * @public
+ */
+export declare enum ListPatternType {
+    Arabic = "arabic",
+    LeadingZero = "leadingZero",
+    Letter = "letter",
+    LetterLow = "letterLow",
+    Roman = "roman",
+    RomanLow = "romanLow",
+    Ordinal = "ordinal",
+    OrdinalText = "ordinalText",
+    CardinalText = "cardinalText",
+    Bullet = "bullet",
+    NoNumber = "noNumber",
+    FarEast = "farEast",
+    Special = "special",
+    Hebrew1 = "hebrew1",
+    Hebrew2 = "hebrew2",
+    HindiArabic = "hindiArabic",
+    HindiCardinalText = "hindiCardinalText",
+    HindiLetter1 = "hindiLetter1",
+    HindiLetter2 = "hindiLetter2",
+    ChineseCounting = "chineseCounting",
+    ChineseCountingThousand = "chineseCountingThousand",
+    ChineseLegalSimplified = "chineseLegalSimplified",
+    JapaneseCounting = "japaneseCounting",
+    JapaneseDigitalTenThousand = "japaneseDigitalTenThousand",
+    JapaneseLegal = "japaneseLegal",
+    KoreanCounting = "koreanCounting",
+    KoreanDigital = "koreanDigital",
+    KoreanDigital2 = "koreanDigital2",
+    KoreanLegal = "koreanLegal",
+    Aiueo = "aiueo",
+    AiueoFullWidth = "aiueoFullWidth",
+    Iroha = "iroha",
+    IrohaFullWidth = "irohaFullWidth",
+    Ganada = "ganada",
+    Chosung = "chosung",
+    DecimalEnclosedCircle = "decimalEnclosedCircle",
+    DecimalFullWidth = "decimalFullWidth",
+    DecimalHalfWidth = "decimalHalfWidth",
+    DecimalEnclosedFullstop = "decimalEnclosedFullstop",
+    DecimalEnclosedParen = "decimalEnclosedParen",
+    DecimalEnclosedCircleChinese = "decimalEnclosedCircleChinese",
+    IdeographEnclosedCircle = "ideographEnclosedCircle",
+    IdeographTraditional = "ideographTraditional",
+    IdeographZodiac = "ideographZodiac",
+    IdeographZodiacTraditional = "ideographZodiacTraditional",
+    TaiwaneseCounting = "taiwaneseCounting",
+    TaiwaneseCountingThousand = "taiwaneseCountingThousand",
+    TaiwaneseDigital = "taiwaneseDigital",
+    None = "none",
+    Custom = "custom"
+}
+/**
+ * Character inserted after the list label (`w:suff`).
+ *
+ * @public
+ */
+export declare enum FollowCharacterType {
+    Tab = "tab",
+    Space = "space",
+    Nothing = "nothing"
+}
+/**
+ * Horizontal alignment of the list number (`w:lvlJc`).
+ *
+ * @public
+ */
+export declare enum ListNumberAlignment {
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}
+/**
+ * Live list level facade over a {@link NumberingLevel}.
+ *
+ * @public
+ */
+export declare class ListLevel implements CharacterFormatHost, ParagraphFormatHost {
+    private readonly owner;
+    private readonly level;
+    private readonly characterFormatValue;
+    private readonly paragraphFormatValue;
+    private suppressDirty;
+    /**
+     * @private
+     */
+    constructor(owner: ListStyle, level: NumberingLevel);
+    /** Owning list style. */
+    readonly listStyle: ListStyle;
+    /** Zero-based level index. */
+    readonly levelNumber: number;
+    patternType: ListPatternType;
+    startAt: number;
+    levelText: string;
+    numberPrefix: string;
+    numberSuffix: string;
+    bulletCharacter: string;
+    followCharacter: FollowCharacterType;
+    numberAlignment: ListNumberAlignment;
+    tabSpaceAfter: number;
+    numberPosition: number;
+    textPosition: number;
+    restartLevel: number;
+    isLegalStyleNumbering: boolean;
+    linkedParagraphStyleName: string;
+    readonly characterFormat: CharacterFormat;
+    readonly paragraphFormat: ParagraphFormat;
+    /** @private */
+    notifyCharacterFormatMutation(): void;
+    /** @private */
+    notifyParagraphFormatMutation(): void;
+    private hydrateFormatsFromLevel;
+    private markDirty;
+}
+/**
+ * Nine-level collection for a {@link ListStyle}.
+ *
+ * @public
+ */
+export declare class ListLevelCollection {
+    private readonly items;
+    /**
+     * @private
+     */
+    constructor(items: ListLevel[]);
+    readonly count: number;
+    getItem(index: number): ListLevel;
+}
+/**
+ * Public custom list style facade.
+ *
+ * @public
+ */
+export declare class ListStyle {
+    private readonly document;
+    private readonly styleIdValue;
+    private readonly displayName;
+    private readonly listTypeValue;
+    private readonly abstractNumId;
+    private readonly levelsValue;
+    /**
+     * @private
+     */
+    constructor(init: {
+        document: WordDocument;
+        styleId: string;
+        displayName: string;
+        listType: ListType;
+        abstractNumId: number;
+        levels: ListLevel[];
+    });
+    readonly name: string;
+    readonly listType: ListType;
+    readonly levels: ListLevelCollection;
+    /** @private */
+    readonly styleId: string;
+    /** @private */
+    readonly abstractId: number;
+    /** @private */
+    markNumberingDirty(): void;
+}
+/**
+ * Create a custom list style on the document.
+ *
+ * @public
+ */
+export declare function addListStyle(document: WordDocument, listType: ListType, styleName: string): ListStyle;
+/**
+ * Resolve abstract num id for a numbering style (styleLink / name).
+ *
+ * @private
+ */
+export declare function findAbstractForListStyle(numbering: NumberingCatalog, styleId: string, displayName: string | undefined): number | undefined;
+export {};