@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

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

@@ -0,0 +1,90 @@
+import { OpenXmlAttribute, OpenXmlElement } from '../../core/xml/index';
+import { NumberingLevel } from './numbering-level';
+/**
+ * Multilevel classification (`w:multiLevelType/@w:val`, `ST_MultiLevelType`).
+ *
+ * @private
+ */
+export declare type MultiLevelType = 'singleLevel' | 'multilevel' | 'hybridMultilevel';
+/**
+ * Abstract numbering definition (`w:abstractNum` / `CT_AbstractNum`).
+ *
+ * @private
+ */
+export declare class AbstractNumbering {
+    private readonly _abstractNumId;
+    private readonly _multiLevelType;
+    private _name;
+    private _styleLink;
+    private _numStyleLink;
+    private readonly _levels;
+    private readonly extraAttributes;
+    /** Unmodeled children before `w:lvl` (`nsid`, `tmpl`, unknown, …). */
+    private readonly prefixExtras;
+    /** Unmodeled children after levels (rare). */
+    private readonly suffixExtras;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly abstractNumId: number;
+        readonly multiLevelType?: MultiLevelType;
+        readonly name?: string;
+        readonly styleLink?: string;
+        readonly numStyleLink?: string;
+        readonly levels?: ReadonlyArray<NumberingLevel>;
+        readonly extraAttributes?: ReadonlyArray<OpenXmlAttribute>;
+        readonly prefixExtras?: ReadonlyArray<OpenXmlElement>;
+        readonly suffixExtras?: ReadonlyArray<OpenXmlElement>;
+    });
+    /** Abstract definition id (`@w:abstractNumId`). */
+    readonly abstractNumId: number;
+    /** Multilevel type (`w:multiLevelType/@w:val`), when present. */
+    readonly multiLevelType: MultiLevelType | undefined;
+    /** Friendly name (`w:name/@w:val`), when present. */
+    readonly name: string | undefined;
+    /**
+     * @private
+     */
+    setName(value: string | undefined): void;
+    /** Style link (`w:styleLink/@w:val`), when present. */
+    readonly styleLink: string | undefined;
+    /**
+     * @private
+     */
+    setStyleLink(value: string | undefined): void;
+    /** Numbering style link (`w:numStyleLink/@w:val`), when present. */
+    readonly numStyleLink: string | undefined;
+    /** Ordered level definitions (`w:lvl`, max 9 in schema). */
+    readonly levels: ReadonlyArray<NumberingLevel>;
+    /**
+     * @private
+     */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * Parse `w:abstractNum` into {@link AbstractNumbering}.
+ *
+ * @private
+ */
+export declare function parseAbstractNumbering(element: OpenXmlElement): AbstractNumbering | undefined;
+/**
+ * Minimal single-level abstract definition for ensure/create paths (legacy fallback).
+ *
+ * @private
+ */
+export declare function createMinimalAbstractNumbering(abstractNumId: number, format: 'bullet' | 'decimal'): AbstractNumbering;
+/**
+ * Default nine-level abstract numbering definition following the DocIO
+ * `ListStyle.CreateDefListLevels` repeating pattern.
+ *
+ * - **bullet:** ilvl 0/3/6 = `\uf0b7`/Symbol, ilvl 1/4/7 = `o`/Courier New,
+ *   ilvl 2/5/8 = `\uf0a7`/Wingdings; indents (ilvl+1)×720 twips left, 360 twips hanging.
+ * - **decimal:** cycling `decimal`/`lowerLetter`/`lowerRoman`; level text `%N.`;
+ *   same indent ladder.
+ *
+ * `multiLevelType` is set to `hybridMultilevel` to match DocIO output.
+ *
+ * @private
+ */
+export declare function createDefaultAbstractNumbering(abstractNumId: number, format: 'bullet' | 'decimal'): AbstractNumbering;

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

@@ -0,0 +1,292 @@
+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 { createDefaultBulletLevel, createDefaultNumberedLevel, createMinimalNumberingLevel, parseNumberingLevel } from './numbering-level';
+var MULTI_LEVEL_TYPES = new Set(['singleLevel', 'multilevel', 'hybridMultilevel']);
+/**
+ * Abstract numbering definition (`w:abstractNum` / `CT_AbstractNum`).
+ *
+ * @private
+ */
+var AbstractNumbering = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function AbstractNumbering(init) {
+        this._abstractNumId = init.abstractNumId;
+        this._multiLevelType = init.multiLevelType;
+        this._name = init.name;
+        this._styleLink = init.styleLink;
+        this._numStyleLink = init.numStyleLink;
+        this._levels = init.levels != null ? init.levels.slice() : [];
+        this.extraAttributes = init.extraAttributes != null ? init.extraAttributes : [];
+        this.prefixExtras = init.prefixExtras != null ? init.prefixExtras : [];
+        this.suffixExtras = init.suffixExtras != null ? init.suffixExtras : [];
+    }
+    Object.defineProperty(AbstractNumbering.prototype, "abstractNumId", {
+        /** Abstract definition id (`@w:abstractNumId`). */
+        get: function () {
+            return this._abstractNumId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractNumbering.prototype, "multiLevelType", {
+        /** Multilevel type (`w:multiLevelType/@w:val`), when present. */
+        get: function () {
+            return this._multiLevelType;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractNumbering.prototype, "name", {
+        /** Friendly name (`w:name/@w:val`), when present. */
+        get: function () {
+            return this._name;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    AbstractNumbering.prototype.setName = function (value) {
+        this._name = value;
+    };
+    Object.defineProperty(AbstractNumbering.prototype, "styleLink", {
+        /** Style link (`w:styleLink/@w:val`), when present. */
+        get: function () {
+            return this._styleLink;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    AbstractNumbering.prototype.setStyleLink = function (value) {
+        this._styleLink = value;
+    };
+    Object.defineProperty(AbstractNumbering.prototype, "numStyleLink", {
+        /** Numbering style link (`w:numStyleLink/@w:val`), when present. */
+        get: function () {
+            return this._numStyleLink;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractNumbering.prototype, "levels", {
+        /** Ordered level definitions (`w:lvl`, max 9 in schema). */
+        get: function () {
+            return this._levels;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    AbstractNumbering.prototype.toOpenXml = function () {
+        var e_1, _a;
+        var children = __spread(this.prefixExtras);
+        if (this._multiLevelType !== undefined) {
+            children.push(wmlElement('multiLevelType', { attributes: [wmlAttr('val', this._multiLevelType)] }));
+        }
+        if (this._name !== undefined) {
+            children.push(wmlElement('name', { attributes: [wmlAttr('val', this._name)] }));
+        }
+        if (this._styleLink !== undefined) {
+            children.push(wmlElement('styleLink', { attributes: [wmlAttr('val', this._styleLink)] }));
+        }
+        if (this._numStyleLink !== undefined) {
+            children.push(wmlElement('numStyleLink', { attributes: [wmlAttr('val', this._numStyleLink)] }));
+        }
+        try {
+            for (var _b = __values(this._levels), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var level = _c.value;
+                children.push(level.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('abstractNum', {
+            attributes: __spread([
+                wmlAttr('abstractNumId', String(this._abstractNumId))
+            ], this.extraAttributes),
+            children: children,
+        });
+    };
+    return AbstractNumbering;
+}());
+export { AbstractNumbering };
+/**
+ * Parse `w:abstractNum` into {@link AbstractNumbering}.
+ *
+ * @private
+ */
+export function parseAbstractNumbering(element) {
+    var e_2, _a;
+    if (!isWml(element, 'abstractNum')) {
+        return undefined;
+    }
+    var abstractNumId = decimalAttribute(element, 'abstractNumId');
+    if (abstractNumId === undefined) {
+        return undefined;
+    }
+    var multiLevelType;
+    var name;
+    var styleLink;
+    var numStyleLink;
+    var levels = [];
+    var prefixExtras = [];
+    var suffixExtras = [];
+    var seenLevel = false;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'lvl')) {
+                var level = parseNumberingLevel(child);
+                if (level !== undefined) {
+                    levels.push(level);
+                }
+                seenLevel = true;
+                continue;
+            }
+            if (isWml(child, 'multiLevelType') && multiLevelType === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined && MULTI_LEVEL_TYPES.has(raw)) {
+                    multiLevelType = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'name') && name === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    name = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'styleLink') && styleLink === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    styleLink = raw;
+                    continue;
+                }
+            }
+            if (isWml(child, 'numStyleLink') && numStyleLink === undefined) {
+                var raw = wValAttribute(child);
+                if (raw !== undefined) {
+                    numStyleLink = raw;
+                    continue;
+                }
+            }
+            if (!seenLevel) {
+                prefixExtras.push(child);
+            }
+            else {
+                suffixExtras.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 === 'abstractNumId' && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE); });
+    return new AbstractNumbering(__assign({ abstractNumId: abstractNumId }, (multiLevelType !== undefined ? { multiLevelType: multiLevelType } : {}), (name !== undefined ? { name: name } : {}), (styleLink !== undefined ? { styleLink: styleLink } : {}), (numStyleLink !== undefined ? { numStyleLink: numStyleLink } : {}), { levels: levels,
+        extraAttributes: extraAttributes,
+        prefixExtras: prefixExtras,
+        suffixExtras: suffixExtras }));
+}
+/**
+ * Minimal single-level abstract definition for ensure/create paths (legacy fallback).
+ *
+ * @private
+ */
+export function createMinimalAbstractNumbering(abstractNumId, format) {
+    return new AbstractNumbering({
+        abstractNumId: abstractNumId,
+        multiLevelType: 'singleLevel',
+        levels: [createMinimalNumberingLevel(0, format)],
+    });
+}
+/**
+ * Default nine-level abstract numbering definition following the DocIO
+ * `ListStyle.CreateDefListLevels` repeating pattern.
+ *
+ * - **bullet:** ilvl 0/3/6 = `\uf0b7`/Symbol, ilvl 1/4/7 = `o`/Courier New,
+ *   ilvl 2/5/8 = `\uf0a7`/Wingdings; indents (ilvl+1)×720 twips left, 360 twips hanging.
+ * - **decimal:** cycling `decimal`/`lowerLetter`/`lowerRoman`; level text `%N.`;
+ *   same indent ladder.
+ *
+ * `multiLevelType` is set to `hybridMultilevel` to match DocIO output.
+ *
+ * @private
+ */
+export function createDefaultAbstractNumbering(abstractNumId, format) {
+    var levels = [];
+    for (var ilvl = 0; ilvl < 9; ilvl++) {
+        levels.push(format === 'bullet' ? createDefaultBulletLevel(ilvl) : createDefaultNumberedLevel(ilvl));
+    }
+    return new AbstractNumbering({
+        abstractNumId: abstractNumId,
+        multiLevelType: 'hybridMultilevel',
+        levels: levels,
+    });
+}
+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/index.d.ts

@@ -0,0 +1,182 @@
+export * from './abstract-numbering';
+export * from './list-string';
+export * from './list-style';
+export * from './numbering-instance';
+export * from './numbering-level';
+export * from './picture-bullet';
+import { WordDocument } from '../document/document';
+import { FeaturePackagePart } from '../document/feature-package-part';
+import { OpenXmlElement } from '../../core/xml/index';
+import { AbstractNumbering } from './abstract-numbering';
+import { NumberingInstance } from './numbering-instance';
+import { NumberingPictureBullet } from './picture-bullet';
+import './list-style';
+import './list-string';
+/**
+ * @private
+ * Transitional numbering relationship (ECMA-376-4 section 9.2.11). */
+export declare const NUMBERING_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+/**
+ * @private
+ * Strict numbering relationship (ECMA-376-1 section 11.3.11). */
+export declare const STRICT_NUMBERING_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/numbering";
+/**
+ * @private
+ * ECMA-376-1 section 11.3.11 Numbering Definitions content type. */
+export declare const NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
+/**
+ * @private
+ */
+export declare const NUMBERING_PART_NAME: import("../../core/opc/part-name").PartName;
+/**
+ * In-memory Numbering Definitions part (`word/numbering.xml`).
+ *
+ * Typed DOM for `CT_Numbering`: picture bullets, abstract definitions,
+ * numbering instances, and optional `numIdMacAtCleanup`. Unmodeled root
+ * children are preserved in prefix/suffix order.
+ *
+ * @private
+ */
+export declare class NumberingPart implements FeaturePackagePart {
+    private readonly rootPrefix;
+    private readonly rootSuffix;
+    private readonly pictureBulletList;
+    private readonly abstractNumberingList;
+    private readonly numberingList;
+    private readonly abstractById;
+    private readonly numberingById;
+    private readonly pictureById;
+    private readonly pendingNumIds;
+    /** Subset of pendingNumIds that should materialize as decimal (numbered) format. */
+    private readonly pendingDecimalNumIds;
+    private numIdMacAtCleanupValue;
+    private dirty;
+    /**
+     * @private
+     */
+    constructor(init: {
+        readonly rootPrefix?: ReadonlyArray<OpenXmlElement>;
+        readonly rootSuffix?: ReadonlyArray<OpenXmlElement>;
+        readonly pictureBullets?: ReadonlyArray<NumberingPictureBullet>;
+        readonly abstractNumberings?: ReadonlyArray<AbstractNumbering>;
+        readonly numberings?: ReadonlyArray<NumberingInstance>;
+        readonly numIdMacAtCleanup?: number;
+        readonly dirty: boolean;
+    });
+    /** Ordered picture bullet definitions (`w:numPicBullet`). */
+    readonly pictureBullets: ReadonlyArray<NumberingPictureBullet>;
+    /** Ordered abstract numbering definitions (`w:abstractNum`). */
+    readonly abstractNumberings: ReadonlyArray<AbstractNumbering>;
+    /** Ordered numbering instances (`w:num`). */
+    readonly numberings: ReadonlyArray<NumberingInstance>;
+    /** Optional `w:numIdMacAtCleanup/@w:val`. */
+    readonly numIdMacAtCleanup: number | undefined;
+    /** Lookup abstract definition by id. */
+    getAbstractNumbering(abstractNumId: number): AbstractNumbering | undefined;
+    /** Lookup numbering instance by id. */
+    getNumbering(numId: number): NumberingInstance | undefined;
+    /** Lookup picture bullet by id. */
+    getPictureBullet(numPicBulletId: number): NumberingPictureBullet | undefined;
+    /** Whether a numbering instance id exists in the catalog (including pending). */
+    hasInstance(numId: number): boolean;
+    /**
+     * Ensure a numbering instance exists, creating a nine-level default definition when absent.
+     *
+     * @param format - List format used when creating a new abstract numbering definition.
+     *   `'bullet'` (default) produces the standard bullet pattern; `'decimal'` produces the
+     *   cycling `decimal` / `lowerLetter` / `lowerRoman` pattern. Has no effect if the
+     *   instance already exists.
+     */
+    ensureInstance(numId: number, format?: 'bullet' | 'decimal'): void;
+    /**
+     * Allocate a new bullet list instance id with a nine-level bullet definition on materialize.
+     */
+    createBulletInstance(): number;
+    /**
+     * Allocate a new decimal (numbered) list instance id with a nine-level definition on materialize.
+     *
+     * The cycling pattern (`decimal` / `lowerLetter` / `lowerRoman`) is materialized at
+     * save time when the paragraph's `numbering` property is set.
+     */
+    createDecimalInstance(): number;
+    /**
+     * Register an existing abstract numbering definition and mark the part dirty.
+     *
+     * @private
+     */
+    registerAbstract(abstract: AbstractNumbering): void;
+    /**
+     * Allocate the next unused abstract numbering id.
+     *
+     * @private
+     */
+    allocateAbstractNumId(): number;
+    /**
+     * Create a concrete `w:num` linked to an existing abstract definition.
+     *
+     * @param abstractNumId - Existing abstract id.
+     * @param startOverride - Optional level-0 start override.
+     * @private
+     */
+    createInstanceFromAbstract(abstractNumId: number, startOverride?: number): number;
+    /**
+     * Mark the numbering part dirty after an in-place abstract/level mutation.
+     *
+     * @private
+     */
+    markDirty(): void;
+    /**
+     * @private
+     * Track a numbering instance referenced before save.
+     */
+    registerPendingInstance(numId: number, format?: 'bullet' | 'decimal'): void;
+    /**
+     * @private
+     * Whether a pending (not yet materialized) numbering id was allocated as decimal.
+     */
+    isPendingDecimal(numId: number): boolean;
+    /**
+     * @private
+     */
+    materializePending(document: WordDocument): void;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    serialize(): Uint8Array;
+    private nextNumId;
+    private nextAbstractNumId;
+}
+/**
+ * @private
+ * Test hook */
+export declare function resetNumberingFeatureForTests(): void;
+/**
+ * @private
+ * Register the numbering package-part handler. Idempotent. */
+export declare function registerNumberingFeature(): void;
+/**
+ * Numbering catalog for a document.
+ *
+ * On the default `@syncfusion/ej2-docx` entry, numbering is always-on: the package-part
+ * handler is registered at module load and re-armed via
+ * {@link registerAlwaysOnBodyFeatureBootstrap} before each
+ * {@link WordDocument.create} / load. On {@link WordDocument.create}, feature package
+ * parts are not pre-attached; this attaches an empty {@link NumberingPart} so
+ * authoring APIs (`createBulletInstance`, paragraph numbering) work without a load.
+ *
+ * @throws DocxError `feature/not-registered` when the numbering module was not
+ * registered (pure core path without the main entry / numbering subpath).
+ * @private
+ */
+export declare function numberingFor(document: WordDocument): NumberingPart;
+/**
+ * List kind used when creating a default nine-level definition.
+ * Maps only to existing {@link NumberingPart.ensureInstance} formats — not free-form ST_NumberFormat.
+ *
+ * @public
+ */
+export declare type ListFormatType = 'bullet' | 'decimal';