@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/numbering/numbering-instance.d.ts

@@ -0,0 +1,101 @@
+import { OpenXmlAttribute, OpenXmlElement } from '../../core/xml/index';
+import { NumberingLevel } from './numbering-level';
+/**
+ * Level override on a numbering instance (`w:lvlOverride` / `CT_NumLvl`).
+ *
+ * MVP exposes `ilvl` and optional `startOverride`; nested `w:lvl` and other
+ * children are preserved opaquely via {@link NumberingLevel} when present.
+ *
+ * @private
+ */
+export declare class NumberingLevelOverride {
+    private readonly _ilvl;
+    private _startOverride;
+    private readonly _level;
+    private readonly extraAttributes;
+    private readonly extras;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly ilvl: number;
+        readonly startOverride?: number;
+        readonly level?: NumberingLevel;
+        readonly extraAttributes?: ReadonlyArray<OpenXmlAttribute>;
+        readonly extras?: ReadonlyArray<OpenXmlElement>;
+    });
+    /** Zero-based level index (`@w:ilvl`). */
+    readonly ilvl: number;
+    /** Start override (`w:startOverride/@w:val`), when present. */
+    readonly startOverride: number | undefined;
+    /**
+     * Update `w:startOverride/@w:val` on this override.
+     *
+     * @private
+     */
+    setStartOverride(startAt: number): void;
+    /** Nested level replacement (`w:lvl`), when present. */
+    readonly level: NumberingLevel | undefined;
+    /**
+     * @private
+     */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Concrete numbering instance (`w:num` / `CT_Num`).
+ *
+ * @private
+ */
+export declare class NumberingInstance {
+    private readonly _numId;
+    private readonly _abstractNumId;
+    private readonly _levelOverrides;
+    private readonly extraAttributes;
+    private readonly prefixExtras;
+    private readonly suffixExtras;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly numId: number;
+        readonly abstractNumId: number;
+        readonly levelOverrides?: ReadonlyArray<NumberingLevelOverride>;
+        readonly extraAttributes?: ReadonlyArray<OpenXmlAttribute>;
+        readonly prefixExtras?: ReadonlyArray<OpenXmlElement>;
+        readonly suffixExtras?: ReadonlyArray<OpenXmlElement>;
+    });
+    /** Instance id (`@w:numId`). */
+    readonly numId: number;
+    /** Linked abstract definition id (`w:abstractNumId/@w:val`). */
+    readonly abstractNumId: number;
+    /** Ordered level overrides (`w:lvlOverride`). */
+    readonly levelOverrides: ReadonlyArray<NumberingLevelOverride>;
+    /**
+     * Set or replace the start override for `ilvl` (`w:startOverride`).
+     *
+     * @private
+     */
+    setStartOverride(ilvl: number, startAt: number): void;
+    /**
+     * @private
+     */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Parse `w:lvlOverride` into {@link NumberingLevelOverride}.
+ *
+ * @private
+ */
+export declare function parseNumberingLevelOverride(element: OpenXmlElement): NumberingLevelOverride | undefined;
+/**
+ * Parse `w:num` into {@link NumberingInstance}.
+ *
+ * @private
+ */
+export declare function parseNumberingInstance(element: OpenXmlElement): NumberingInstance | undefined;
+/**
+ * Minimal `w:num` linking to an abstract definition.
+ *
+ * @private
+ */
+export declare function createNumberingInstance(numId: number, abstractNumId: number): NumberingInstance;

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

@@ -0,0 +1,329 @@
+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 __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;
+};
+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 };
+        }
+    };
+};
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, } from '../document/wml';
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { parseNumberingLevel } from './numbering-level';
+/**
+ * Level override on a numbering instance (`w:lvlOverride` / `CT_NumLvl`).
+ *
+ * MVP exposes `ilvl` and optional `startOverride`; nested `w:lvl` and other
+ * children are preserved opaquely via {@link NumberingLevel} when present.
+ *
+ * @private
+ */
+var NumberingLevelOverride = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NumberingLevelOverride(init) {
+        this._ilvl = init.ilvl;
+        this._startOverride = init.startOverride;
+        this._level = init.level;
+        this.extraAttributes = init.extraAttributes != null ? init.extraAttributes : [];
+        this.extras = init.extras != null ? init.extras : [];
+    }
+    Object.defineProperty(NumberingLevelOverride.prototype, "ilvl", {
+        /** Zero-based level index (`@w:ilvl`). */
+        get: function () {
+            return this._ilvl;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingLevelOverride.prototype, "startOverride", {
+        /** Start override (`w:startOverride/@w:val`), when present. */
+        get: function () {
+            return this._startOverride;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Update `w:startOverride/@w:val` on this override.
+     *
+     * @private
+     */
+    NumberingLevelOverride.prototype.setStartOverride = function (startAt) {
+        this._startOverride = startAt;
+    };
+    Object.defineProperty(NumberingLevelOverride.prototype, "level", {
+        /** Nested level replacement (`w:lvl`), when present. */
+        get: function () {
+            return this._level;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    NumberingLevelOverride.prototype.toOpenXml = function () {
+        var children = [];
+        if (this._startOverride !== undefined) {
+            children.push(wmlElement('startOverride', {
+                attributes: [wmlAttr('val', String(this._startOverride))],
+            }));
+        }
+        if (this._level !== undefined) {
+            children.push(this._level.toOpenXml());
+        }
+        children.push.apply(children, __spread(this.extras));
+        return wmlElement('lvlOverride', {
+            attributes: __spread([wmlAttr('ilvl', String(this._ilvl))], this.extraAttributes),
+            children: children,
+        });
+    };
+    return NumberingLevelOverride;
+}());
+export { NumberingLevelOverride };
+/**
+ * Concrete numbering instance (`w:num` / `CT_Num`).
+ *
+ * @private
+ */
+var NumberingInstance = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NumberingInstance(init) {
+        this._numId = init.numId;
+        this._abstractNumId = init.abstractNumId;
+        this._levelOverrides = init.levelOverrides != null ? __spread(init.levelOverrides) : [];
+        this.extraAttributes = init.extraAttributes != null ? init.extraAttributes : [];
+        this.prefixExtras = init.prefixExtras != null ? init.prefixExtras : [];
+        this.suffixExtras = init.suffixExtras != null ? init.suffixExtras : [];
+    }
+    Object.defineProperty(NumberingInstance.prototype, "numId", {
+        /** Instance id (`@w:numId`). */
+        get: function () {
+            return this._numId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingInstance.prototype, "abstractNumId", {
+        /** Linked abstract definition id (`w:abstractNumId/@w:val`). */
+        get: function () {
+            return this._abstractNumId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingInstance.prototype, "levelOverrides", {
+        /** Ordered level overrides (`w:lvlOverride`). */
+        get: function () {
+            return this._levelOverrides;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Set or replace the start override for `ilvl` (`w:startOverride`).
+     *
+     * @private
+     */
+    NumberingInstance.prototype.setStartOverride = function (ilvl, startAt) {
+        var existing = this._levelOverrides.find(function (entry) { return entry.ilvl === ilvl; });
+        if (existing !== undefined) {
+            existing.setStartOverride(startAt);
+            return;
+        }
+        this._levelOverrides.push(new NumberingLevelOverride({ ilvl: ilvl, startOverride: startAt }));
+    };
+    /**
+     * @private
+     */
+    NumberingInstance.prototype.toOpenXml = function () {
+        var e_1, _a;
+        var children = __spread(this.prefixExtras, [
+            wmlElement('abstractNumId', {
+                attributes: [wmlAttr('val', String(this._abstractNumId))],
+            }),
+        ]);
+        try {
+            for (var _b = __values(this._levelOverrides), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var override = _c.value;
+                children.push(override.toOpenXml());
+            }
+        }
+        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(this.suffixExtras));
+        return wmlElement('num', {
+            attributes: __spread([wmlAttr('numId', String(this._numId))], this.extraAttributes),
+            children: children,
+        });
+    };
+    return NumberingInstance;
+}());
+export { NumberingInstance };
+/**
+ * Parse `w:lvlOverride` into {@link NumberingLevelOverride}.
+ *
+ * @private
+ */
+export function parseNumberingLevelOverride(element) {
+    var e_2, _a;
+    if (!isWml(element, 'lvlOverride')) {
+        return undefined;
+    }
+    var ilvl = decimalAttribute(element, 'ilvl');
+    if (ilvl === undefined) {
+        return undefined;
+    }
+    var startOverride;
+    var level;
+    var extras = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'startOverride') && startOverride === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined && /^-?\d+$/.test(raw)) {
+                    startOverride = Number.parseInt(raw, 10);
+                    continue;
+                }
+            }
+            if (isWml(child, 'lvl') && level === undefined) {
+                level = parseNumberingLevel(child);
+                if (level !== undefined) {
+                    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 NumberingLevelOverride(__assign({ ilvl: ilvl }, (startOverride !== undefined ? { startOverride: startOverride } : {}), (level !== undefined ? { level: level } : {}), { extraAttributes: extraAttributes,
+        extras: extras }));
+}
+/**
+ * Parse `w:num` into {@link NumberingInstance}.
+ *
+ * @private
+ */
+export function parseNumberingInstance(element) {
+    var e_3, _a;
+    if (!isWml(element, 'num')) {
+        return undefined;
+    }
+    var numId = decimalAttribute(element, 'numId');
+    if (numId === undefined) {
+        return undefined;
+    }
+    var prefixExtras = [];
+    var suffixExtras = [];
+    var levelOverrides = [];
+    var abstractNumId = 0;
+    var seenAbstract = false;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'abstractNumId') && !seenAbstract) {
+                var val = wValAttribute(child);
+                if (val !== undefined && /^-?\d+$/.test(val)) {
+                    abstractNumId = Number.parseInt(val, 10);
+                    seenAbstract = true;
+                    continue;
+                }
+            }
+            if (isWml(child, 'lvlOverride')) {
+                var override = parseNumberingLevelOverride(child);
+                if (override !== undefined) {
+                    levelOverrides.push(override);
+                }
+                continue;
+            }
+            if (!seenAbstract) {
+                prefixExtras.push(child);
+                continue;
+            }
+            suffixExtras.push(child);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (!seenAbstract) {
+        return undefined;
+    }
+    var extraAttributes = element.attributes.filter(function (a) { return !(a.localName === 'numId' && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE); });
+    return new NumberingInstance({
+        numId: numId,
+        abstractNumId: abstractNumId,
+        levelOverrides: levelOverrides,
+        extraAttributes: extraAttributes,
+        prefixExtras: prefixExtras,
+        suffixExtras: suffixExtras,
+    });
+}
+/**
+ * Minimal `w:num` linking to an abstract definition.
+ *
+ * @private
+ */
+export function createNumberingInstance(numId, abstractNumId) {
+    return new NumberingInstance({ numId: numId, abstractNumId: abstractNumId });
+}
+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);
+}

package/src/features/numbering/numbering-level.d.ts

@@ -0,0 +1,118 @@
+import { OpenXmlAttribute, OpenXmlElement } 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
+ */
+export declare class NumberingLevel {
+    private readonly _ilvl;
+    private _start;
+    private _numFmt;
+    private _lvlText;
+    private _isLgl;
+    private _lvlJc;
+    private _lvlPicBulletId;
+    private readonly extraAttributes;
+    /** Unmodeled children in document order (`lvlRestart`, `pStyle`, `suff`, `legacy`, `pPr`, `rPr`, …). */
+    private extras;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly ilvl: number;
+        readonly start?: number;
+        readonly numFmt?: string;
+        readonly lvlText?: string;
+        readonly isLgl?: boolean;
+        readonly lvlJc?: string;
+        readonly lvlPicBulletId?: number;
+        readonly extraAttributes?: ReadonlyArray<OpenXmlAttribute>;
+        readonly extras?: ReadonlyArray<OpenXmlElement>;
+    });
+    /** Zero-based level index (`@w:ilvl`). */
+    readonly ilvl: number;
+    /** Starting value (`w:start/@w:val`), when present. */
+    readonly start: number | undefined;
+    /**
+     * @private
+     */
+    setStart(value: number | undefined): void;
+    /**
+     * Number format token (`w:numFmt/@w:val`, `ST_NumberFormat`).
+     * Values are not invented by this library.
+     */
+    readonly numFmt: string | undefined;
+    /**
+     * @private
+     */
+    setNumFmt(value: string | undefined): void;
+    /** Level text pattern (`w:lvlText/@w:val`). */
+    readonly lvlText: string | undefined;
+    /**
+     * @private
+     */
+    setLvlText(value: string | undefined): void;
+    /** Legal style numbering (`w:isLgl`), when present. */
+    readonly isLgl: boolean | undefined;
+    /**
+     * @private
+     */
+    setIsLgl(value: boolean | undefined): void;
+    /** Level justification token (`w:lvlJc/@w:val`, `ST_Jc`). */
+    readonly lvlJc: string | undefined;
+    /**
+     * @private
+     */
+    setLvlJc(value: string | undefined): void;
+    /** Picture bullet id reference (`w:lvlPicBulletId/@w:val`). */
+    readonly lvlPicBulletId: number | undefined;
+    /**
+     * @private Unmodeled CT_Lvl children including `suff`, `lvlRestart`, `pStyle`, `pPr`, `rPr`.
+     */
+    getExtras(): ReadonlyArray<OpenXmlElement>;
+    /**
+     * @private Replace or insert a single WML child in extras by local name.
+     */
+    setExtraElement(localName: string, element: OpenXmlElement | undefined): void;
+    /**
+     * @private Find first extras child by local name.
+     */
+    findExtra(localName: string): OpenXmlElement | undefined;
+    /**
+     * @private
+     */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Parse a `w:lvl` element into {@link NumberingLevel}.
+ *
+ * @private
+ */
+export declare function parseNumberingLevel(element: OpenXmlElement): NumberingLevel | undefined;
+/**
+ * Minimal level-0 bullet or decimal definition used by ensure/create paths.
+ *
+ * @private
+ */
+export declare function createMinimalNumberingLevel(ilvl: number, format: 'bullet' | 'decimal'): NumberingLevel;
+/**
+ * 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 declare function createDefaultBulletLevel(ilvl: number): NumberingLevel;
+/**
+ * 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 declare function createDefaultNumberedLevel(ilvl: number): NumberingLevel;