@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/numbering/numbering-level.js

@@ -0,0 +1,501 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, } from '../document/wml';
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+/**
+ * One numbering level definition (`w:lvl` / `CT_Lvl`).
+ *
+ * MVP models `ilvl`, `start`, `numFmt`, `lvlText`, `isLgl`, `lvlJc`, and
+ * `lvlPicBulletId`. Remaining `CT_Lvl` children and unknown attributes are
+ * preserved opaquely for round-trip.
+ *
+ * @private
+ */
+var NumberingLevel = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NumberingLevel(init) {
+        this._ilvl = init.ilvl;
+        this._start = init.start;
+        this._numFmt = init.numFmt;
+        this._lvlText = init.lvlText;
+        this._isLgl = init.isLgl;
+        this._lvlJc = init.lvlJc;
+        this._lvlPicBulletId = init.lvlPicBulletId;
+        this.extraAttributes = init.extraAttributes != null ? init.extraAttributes : [];
+        this.extras = init.extras != null ? init.extras.slice() : [];
+    }
+    Object.defineProperty(NumberingLevel.prototype, "ilvl", {
+        /** Zero-based level index (`@w:ilvl`). */
+        get: function () {
+            return this._ilvl;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingLevel.prototype, "start", {
+        /** Starting value (`w:start/@w:val`), when present. */
+        get: function () {
+            return this._start;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.setStart = function (value) {
+        this._start = value;
+    };
+    Object.defineProperty(NumberingLevel.prototype, "numFmt", {
+        /**
+         * Number format token (`w:numFmt/@w:val`, `ST_NumberFormat`).
+         * Values are not invented by this library.
+         */
+        get: function () {
+            return this._numFmt;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.setNumFmt = function (value) {
+        this._numFmt = value;
+    };
+    Object.defineProperty(NumberingLevel.prototype, "lvlText", {
+        /** Level text pattern (`w:lvlText/@w:val`). */
+        get: function () {
+            return this._lvlText;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.setLvlText = function (value) {
+        this._lvlText = value;
+    };
+    Object.defineProperty(NumberingLevel.prototype, "isLgl", {
+        /** Legal style numbering (`w:isLgl`), when present. */
+        get: function () {
+            return this._isLgl;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.setIsLgl = function (value) {
+        this._isLgl = value;
+    };
+    Object.defineProperty(NumberingLevel.prototype, "lvlJc", {
+        /** Level justification token (`w:lvlJc/@w:val`, `ST_Jc`). */
+        get: function () {
+            return this._lvlJc;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.setLvlJc = function (value) {
+        this._lvlJc = value;
+    };
+    Object.defineProperty(NumberingLevel.prototype, "lvlPicBulletId", {
+        /** Picture bullet id reference (`w:lvlPicBulletId/@w:val`). */
+        get: function () {
+            return this._lvlPicBulletId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private Unmodeled CT_Lvl children including `suff`, `lvlRestart`, `pStyle`, `pPr`, `rPr`.
+     */
+    NumberingLevel.prototype.getExtras = function () {
+        return this.extras;
+    };
+    /**
+     * @private Replace or insert a single WML child in extras by local name.
+     */
+    NumberingLevel.prototype.setExtraElement = function (localName, element) {
+        var next = [];
+        var replaced = false;
+        for (var i = 0; i < this.extras.length; i += 1) {
+            var extra = this.extras[i];
+            if (extra !== undefined && isWml(extra, localName)) {
+                if (!replaced && element !== undefined) {
+                    next.push(element);
+                    replaced = true;
+                }
+                continue;
+            }
+            if (extra !== undefined) {
+                next.push(extra);
+            }
+        }
+        if (!replaced && element !== undefined) {
+            // Insert pPr/rPr near the end; other mid children before pPr.
+            if (localName === 'pPr' || localName === 'rPr' || localName === 'legacy') {
+                next.push(element);
+            }
+            else {
+                var insertAt = next.length;
+                for (var i = 0; i < next.length; i += 1) {
+                    var el = next[i];
+                    if (el !== undefined && (isWml(el, 'pPr') || isWml(el, 'rPr') || isWml(el, 'legacy'))) {
+                        insertAt = i;
+                        break;
+                    }
+                }
+                next.splice(insertAt, 0, element);
+            }
+        }
+        this.extras = next;
+    };
+    /**
+     * @private Find first extras child by local name.
+     */
+    NumberingLevel.prototype.findExtra = function (localName) {
+        for (var i = 0; i < this.extras.length; i += 1) {
+            var extra = this.extras[i];
+            if (extra !== undefined && isWml(extra, localName)) {
+                return extra;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * @private
+     */
+    NumberingLevel.prototype.toOpenXml = function () {
+        var e_1, _a;
+        var children = [];
+        if (this._start !== undefined) {
+            children.push(wmlElement('start', { attributes: [wmlAttr('val', String(this._start))] }));
+        }
+        if (this._numFmt !== undefined) {
+            children.push(wmlElement('numFmt', { attributes: [wmlAttr('val', this._numFmt)] }));
+        }
+        // Unmodeled extras keep original relative order among themselves; modeled
+        // fields above emit in CT_Lvl head order first, then remaining extras, then
+        // remaining modeled tail (isLgl / lvlText / lvlPicBulletId / lvlJc).
+        var headModeled = new Set(['start', 'numFmt']);
+        var tailModeled = new Set(['isLgl', 'lvlText', 'lvlPicBulletId', 'lvlJc']);
+        var midExtras = [];
+        var tailExtras = [];
+        var pastMid = false;
+        try {
+            for (var _b = __values(this.extras), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var extra = _c.value;
+                if (isWml(extra, 'pPr') || isWml(extra, 'rPr') || isWml(extra, 'legacy')) {
+                    pastMid = true;
+                }
+                if (pastMid ||
+                    isWml(extra, 'pPr') ||
+                    isWml(extra, 'rPr') ||
+                    isWml(extra, 'legacy') ||
+                    isWml(extra, 'lvlJc')) {
+                    // lvlJc may appear in extras only if modeling failed; treat as tail region.
+                    tailExtras.push(extra);
+                }
+                else if (!headModeled.has(extra.localName) && !tailModeled.has(extra.localName)) {
+                    midExtras.push(extra);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        children.push.apply(children, __spread(midExtras));
+        if (this._isLgl !== undefined) {
+            children.push(serializeOnOffChild('isLgl', this._isLgl));
+        }
+        if (this._lvlText !== undefined) {
+            children.push(wmlElement('lvlText', { attributes: [wmlAttr('val', this._lvlText)] }));
+        }
+        if (this._lvlPicBulletId !== undefined) {
+            children.push(wmlElement('lvlPicBulletId', {
+                attributes: [wmlAttr('val', String(this._lvlPicBulletId))],
+            }));
+        }
+        if (this._lvlJc !== undefined) {
+            children.push(wmlElement('lvlJc', { attributes: [wmlAttr('val', this._lvlJc)] }));
+        }
+        children.push.apply(children, __spread(tailExtras));
+        return wmlElement('lvl', {
+            attributes: __spread([wmlAttr('ilvl', String(this._ilvl))], this.extraAttributes),
+            children: children,
+        });
+    };
+    return NumberingLevel;
+}());
+export { NumberingLevel };
+/**
+ * Parse a `w:lvl` element into {@link NumberingLevel}.
+ *
+ * @private
+ */
+export function parseNumberingLevel(element) {
+    var e_2, _a;
+    if (!isWml(element, 'lvl')) {
+        return undefined;
+    }
+    var ilvl = decimalAttribute(element, 'ilvl');
+    if (ilvl === undefined) {
+        return undefined;
+    }
+    var start;
+    var numFmt;
+    var lvlText;
+    var isLgl;
+    var lvlJc;
+    var lvlPicBulletId;
+    var extras = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'start') && start === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined && /^-?\d+$/.test(raw)) {
+                    start = Number.parseInt(raw, 10);
+                    continue;
+                }
+            }
+            if (isWml(child, 'numFmt') && numFmt === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    numFmt = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'lvlText') && lvlText === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    lvlText = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'isLgl') && isLgl === undefined) {
+                isLgl = parseOnOffChild(child);
+                continue;
+            }
+            if (isWml(child, 'lvlJc') && lvlJc === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    lvlJc = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'lvlPicBulletId') && lvlPicBulletId === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined && /^-?\d+$/.test(raw)) {
+                    lvlPicBulletId = Number.parseInt(raw, 10);
+                    continue;
+                }
+            }
+            extras.push(child);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var extraAttributes = element.attributes.filter(function (a) { return !(a.localName === 'ilvl' && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE); });
+    return new NumberingLevel(__assign({ ilvl: ilvl }, (start !== undefined ? { start: start } : {}), (numFmt !== undefined ? { numFmt: numFmt } : {}), (lvlText !== undefined ? { lvlText: lvlText } : {}), (isLgl !== undefined ? { isLgl: isLgl } : {}), (lvlJc !== undefined ? { lvlJc: lvlJc } : {}), (lvlPicBulletId !== undefined ? { lvlPicBulletId: lvlPicBulletId } : {}), { extraAttributes: extraAttributes,
+        extras: extras }));
+}
+/**
+ * Minimal level-0 bullet or decimal definition used by ensure/create paths.
+ *
+ * @private
+ */
+export function createMinimalNumberingLevel(ilvl, format) {
+    var numFmt = format === 'bullet' ? 'bullet' : 'decimal';
+    var lvlText = format === 'bullet' ? '•' : '%1.';
+    return new NumberingLevel({
+        ilvl: ilvl,
+        start: 1,
+        numFmt: numFmt,
+        lvlText: lvlText,
+        lvlJc: 'left',
+        extras: [
+            wmlElement('pPr', {
+                children: [
+                    wmlElement('ind', { attributes: [wmlAttr('left', '720'), wmlAttr('hanging', '360')] }),
+                ],
+            }),
+        ],
+    });
+}
+/**
+ * Bullet character, font name, and format token at a given 0-based position in the
+ * three-slot repeating pattern used by DocIO `WListLevel.CreateDefBulletLvl`.
+ */
+var BULLET_PATTERN = [
+    { lvlText: '\uf0b7', font: 'Symbol' },
+    { lvlText: 'o', font: 'Courier New' },
+    { lvlText: '\uf0a7', font: 'Wingdings' },
+];
+/**
+ * Number format and justification at a given 0-based position in the three-slot
+ * repeating pattern used by DocIO `WListLevel.CreateDefNumberLvl`.
+ */
+var NUMBER_PATTERN = [
+    { numFmt: 'decimal', lvlJc: 'left' },
+    { numFmt: 'lowerLetter', lvlJc: 'right' },
+    { numFmt: 'lowerRoman', lvlJc: 'left' },
+];
+/**
+ * Build one `w:lvl` for a default nine-level bullet abstract numbering definition.
+ *
+ * DocIO formula (points → twips): `left = (ilvl + 1) * 36 pt * 20 = (ilvl + 1) * 720`;
+ * `hanging = 18 pt * 20 = 360` for all levels.
+ *
+ * @private
+ */
+export function createDefaultBulletLevel(ilvl) {
+    var __ts33_0;
+    var slot = ilvl % 3;
+    // slot is always 0, 1, or 2 because BULLET_PATTERN has exactly 3 entries.
+    // Provide a safe fallback (slot=0) to avoid non-null assertion.
+    var pattern = ((__ts33_0 = BULLET_PATTERN[slot] != null ? BULLET_PATTERN[slot] : BULLET_PATTERN[0]), __ts33_0 != null ? __ts33_0 : { lvlText: '\uf0b7', font: 'Symbol' });
+    var leftTwips = (ilvl + 1) * 720;
+    return new NumberingLevel({
+        ilvl: ilvl,
+        start: 1,
+        numFmt: 'bullet',
+        lvlText: pattern.lvlText,
+        lvlJc: 'left',
+        extras: [
+            wmlElement('pPr', {
+                children: [
+                    wmlElement('ind', {
+                        attributes: [
+                            wmlAttr('left', String(leftTwips)),
+                            wmlAttr('hanging', '360'),
+                        ],
+                    }),
+                ],
+            }),
+            wmlElement('rPr', {
+                children: [
+                    wmlElement('rFonts', {
+                        attributes: [
+                            wmlAttr('ascii', pattern.font),
+                            wmlAttr('hAnsi', pattern.font),
+                        ],
+                    }),
+                ],
+            }),
+        ],
+    });
+}
+/**
+ * Build one `w:lvl` for a default nine-level numbered abstract numbering definition.
+ *
+ * Level text token: `%<N>.` where N = ilvl + 1 (1-based, matches DocIO `%N<suffix>`).
+ *
+ * @private
+ */
+export function createDefaultNumberedLevel(ilvl) {
+    var __ts33_1;
+    var slot = ilvl % 3;
+    // slot is always 0, 1, or 2 because NUMBER_PATTERN has exactly 3 entries.
+    var pattern = ((__ts33_1 = NUMBER_PATTERN[slot] != null ? NUMBER_PATTERN[slot] : NUMBER_PATTERN[0]), __ts33_1 != null ? __ts33_1 : { numFmt: 'decimal', lvlJc: 'left' });
+    var leftTwips = (ilvl + 1) * 720;
+    return new NumberingLevel({
+        ilvl: ilvl,
+        start: 1,
+        numFmt: pattern.numFmt,
+        lvlText: "%" + String(ilvl + 1) + ".",
+        lvlJc: pattern.lvlJc,
+        extras: [
+            wmlElement('pPr', {
+                children: [
+                    wmlElement('ind', {
+                        attributes: [
+                            wmlAttr('left', String(leftTwips)),
+                            wmlAttr('hanging', '360'),
+                        ],
+                    }),
+                ],
+            }),
+        ],
+    });
+}
+function decimalAttribute(el, localName) {
+    var found = el.attributes.find(function (a) { return a.localName === localName && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE; });
+    if ((found == null ? undefined : found.value) === undefined || !/^-?\d+$/.test(found.value)) {
+        return undefined;
+    }
+    return Number.parseInt(found.value, 10);
+}
+function parseOnOffChild(el) {
+    var raw = wValAttribute(el);
+    if (raw === undefined || raw === '' || raw === '1' || raw === 'true' || raw === 'on') {
+        return true;
+    }
+    if (raw === '0' || raw === 'false' || raw === 'off') {
+        return false;
+    }
+    return true;
+}
+function serializeOnOffChild(localName, value) {
+    if (value) {
+        return wmlElement(localName);
+    }
+    return wmlElement(localName, { attributes: [wmlAttr('val', '0')] });
+}

package/src/features/numbering/picture-bullet.d.ts

@@ -0,0 +1,34 @@
+import { OpenXmlAttribute, OpenXmlChild, OpenXmlElement } from '../../core/xml/index';
+/**
+ * Picture bullet definition (`w:numPicBullet` / `CT_NumPicBullet`).
+ *
+ * MVP exposes the id and preserves `w:pict` / `w:drawing` (and any other)
+ * children opaquely — no drawing authoring in this task.
+ *
+ * @private
+ */
+export declare class NumberingPictureBullet {
+    private readonly _numPicBulletId;
+    private readonly children;
+    private readonly extraAttributes;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly numPicBulletId: number;
+        readonly children?: ReadonlyArray<OpenXmlChild>;
+        readonly extraAttributes?: ReadonlyArray<OpenXmlAttribute>;
+    });
+    /** Picture bullet id (`@w:numPicBulletId`). */
+    readonly numPicBulletId: number;
+    /**
+     * @private
+     */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Parse `w:numPicBullet` into {@link NumberingPictureBullet}.
+ *
+ * @private
+ */
+export declare function parseNumberingPictureBullet(element: OpenXmlElement): NumberingPictureBullet | undefined;

package/src/features/numbering/picture-bullet.js

@@ -0,0 +1,88 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { isWml, wmlAttr, wmlElement, } from '../document/wml';
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+/**
+ * Picture bullet definition (`w:numPicBullet` / `CT_NumPicBullet`).
+ *
+ * MVP exposes the id and preserves `w:pict` / `w:drawing` (and any other)
+ * children opaquely — no drawing authoring in this task.
+ *
+ * @private
+ */
+var NumberingPictureBullet = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NumberingPictureBullet(init) {
+        this._numPicBulletId = init.numPicBulletId;
+        this.children = init.children != null ? init.children : [];
+        this.extraAttributes = init.extraAttributes != null ? init.extraAttributes : [];
+    }
+    Object.defineProperty(NumberingPictureBullet.prototype, "numPicBulletId", {
+        /** Picture bullet id (`@w:numPicBulletId`). */
+        get: function () {
+            return this._numPicBulletId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingPictureBullet.prototype.toOpenXml = function () {
+        return wmlElement('numPicBullet', {
+            attributes: __spread([
+                wmlAttr('numPicBulletId', String(this._numPicBulletId))
+            ], this.extraAttributes),
+            children: this.children,
+        });
+    };
+    return NumberingPictureBullet;
+}());
+export { NumberingPictureBullet };
+/**
+ * Parse `w:numPicBullet` into {@link NumberingPictureBullet}.
+ *
+ * @private
+ */
+export function parseNumberingPictureBullet(element) {
+    if (!isWml(element, 'numPicBullet')) {
+        return undefined;
+    }
+    var numPicBulletId = decimalAttribute(element, 'numPicBulletId');
+    if (numPicBulletId === undefined) {
+        return undefined;
+    }
+    var extraAttributes = element.attributes.filter(function (a) { return !(a.localName === 'numPicBulletId' && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE); });
+    return new NumberingPictureBullet({
+        numPicBulletId: numPicBulletId,
+        children: __spread(element.children),
+        extraAttributes: extraAttributes,
+    });
+}
+function decimalAttribute(el, localName) {
+    var found = el.attributes.find(function (a) { return a.localName === localName && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE; });
+    if ((found == null ? undefined : found.value) === undefined || !/^-?\d+$/.test(found.value)) {
+        return undefined;
+    }
+    return Number.parseInt(found.value, 10);
+}