@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/styles/style-collection.js

@@ -0,0 +1,714 @@
+/**
+ * Document-owned live StyleCollection (public Styles DOM).
+ *
+ * Merges live authoring APIs (paragraph/character facades, StyleOwner) with
+ * table-style support, pending ensure, and stable DocxStyle projection cache.
+ *
+ * @public
+ */
+import { DocxError, InvalidArgumentError } from '../../core/errors/docx-error';
+import { wmlAttr, wmlElement } from '../document/wml';
+import { normalizeStyleName } from './builtin-catalog';
+import { resolveReferencedStyle, resolveStyleForTarget } from './builtin-resolver';
+import { CharacterStyle, createMinimalStyle, createStyleFromDocxStyle, ParagraphStyle, } from './style-base';
+import { createMinimalDocxStyle, DocxStyle } from './style';
+import { TableStyle } from './table-style';
+/**
+ * Public styles collection on {@link WordDocument.styles}.
+ *
+ * Stable identity: `document.styles === document.styles`.
+ * Entry identity: `getStyle(id) === getStyle(id)`.
+ *
+ * @public
+ */
+var StyleCollection = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function StyleCollection(document, host, initial) {
+        if (initial === void 0) { initial = []; }
+        this.cachedLength = 0;
+        this.document = document;
+        this.host = host;
+        this.styleList = [];
+        this.styleById = new Map();
+        this.pendingParagraphStyles = new Set();
+        this.pendingCharacterStyles = new Set();
+        this.pendingTableStyles = new Set();
+        this.projected = new Map();
+        void this.document;
+        for (var i = 0; i < initial.length; i += 1) {
+            var style = initial[i];
+            this.attachAndIndex(style, false);
+        }
+    }
+    Object.defineProperty(StyleCollection.prototype, "ownerDocument", {
+        /**
+         * Owning document.
+         *
+         * @private
+         */
+        get: function () {
+            return this.document;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(StyleCollection.prototype, "count", {
+        /**
+         * Number of styles in document order.
+         *
+         * @public
+         */
+        get: function () {
+            this.rebuildIndexProperties();
+            return this.styleList.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Style at zero-based index, or `undefined` when out of range.
+     *
+     * @public
+     */
+    StyleCollection.prototype.itemAt = function (index) {
+        return this.styleList[index];
+    };
+    StyleCollection.prototype[Symbol.iterator] = function () {
+        var items = this.styleList.slice();
+        var i = 0;
+        return {
+            next: function () {
+                if (i >= items.length) {
+                    return { done: true, value: undefined };
+                }
+                var value = items[i];
+                i += 1;
+                return { done: false, value: value };
+            },
+        };
+    };
+    /**
+     * Look up any style by `w:styleId`.
+     *
+     * @public
+     */
+    StyleCollection.prototype.getStyle = function (styleId) {
+        return this.styleById.get(styleId);
+    };
+    /**
+     * Look up any style by `w:styleId` (alias of {@link getStyle}).
+     *
+     * @public
+     */
+    StyleCollection.prototype.findById = function (styleId) {
+        return this.getStyle(styleId);
+    };
+    /**
+     * Look up a paragraph style by id.
+     *
+     * @public
+     */
+    StyleCollection.prototype.getParagraphStyle = function (styleId) {
+        var style = this.styleById.get(styleId);
+        if (style instanceof ParagraphStyle) {
+            return style;
+        }
+        return undefined;
+    };
+    /**
+     * Look up a character style by id.
+     *
+     * @public
+     */
+    StyleCollection.prototype.getCharacterStyle = function (styleId) {
+        var style = this.styleById.get(styleId);
+        if (style instanceof CharacterStyle) {
+            return style;
+        }
+        return undefined;
+    };
+    /**
+     * Look up a table style by id.
+     *
+     * @public
+     */
+    StyleCollection.prototype.getTableStyle = function (styleId) {
+        var style = this.styleById.get(styleId);
+        if (style instanceof TableStyle) {
+            return style;
+        }
+        return undefined;
+    };
+    /**
+     * Find a style whose display name matches `name` (normalized).
+     *
+     * @public
+     */
+    StyleCollection.prototype.findByName = function (name) {
+        var normalized = normalizeStyleName(name);
+        if (normalized.length === 0) {
+            return undefined;
+        }
+        for (var i = 0; i < this.styleList.length; i += 1) {
+            var style = this.styleList[i];
+            if (style.normalizedName() === normalized) {
+                return style;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Whether a style id exists (including pending ensure).
+     *
+     * @public
+     */
+    StyleCollection.prototype.hasStyle = function (styleId) {
+        return (this.styleById.has(styleId) ||
+            this.pendingParagraphStyles.has(styleId) ||
+            this.pendingCharacterStyles.has(styleId) ||
+            this.pendingTableStyles.has(styleId));
+    };
+    /**
+     * Create and add a paragraph style with the given id.
+     * Throws when the id is empty or already present.
+     *
+     * @public
+     */
+    StyleCollection.prototype.addParagraphStyle = function (styleId) {
+        this.assertNewId(styleId);
+        var style = ParagraphStyle.createMinimal(styleId);
+        this.attachAndIndex(style, true);
+        return style;
+    };
+    /**
+     * Create and add a character style with the given id.
+     *
+     * @public
+     */
+    StyleCollection.prototype.addCharacterStyle = function (styleId) {
+        this.assertNewId(styleId);
+        var style = CharacterStyle.createMinimal(styleId);
+        this.attachAndIndex(style, true);
+        return style;
+    };
+    /**
+     * Create a custom table style and add it to this collection.
+     *
+     * @public
+     */
+    StyleCollection.prototype.addTableStyle = function (name) {
+        var _this = this;
+        var trimmed = name.trim();
+        if (trimmed.length === 0) {
+            throw new InvalidArgumentError('Table style name must not be empty');
+        }
+        var styleId = sanitizeStyleId(trimmed);
+        if (styleId.length === 0) {
+            styleId = 'TableStyle';
+        }
+        styleId = uniqueStyleId(styleId, function (candidate) { return _this.styleById.has(candidate); });
+        var shell = new DocxStyle(styleId, 'table', undefined, true, [
+            wmlElement('name', { attributes: [wmlAttr('val', trimmed)] }),
+        ]);
+        var live = this.appendFromDocxShell(shell, true);
+        return live;
+    };
+    /**
+     * Ensure a paragraph style exists (built-in catalog or minimal stub).
+     * Returns the live style.
+     *
+     * @public
+     */
+    StyleCollection.prototype.ensureParagraphStyle = function (styleId) {
+        var existing = this.getParagraphStyle(styleId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        this.ensureStyle(styleId, 'paragraph');
+        var created = this.getParagraphStyle(styleId);
+        if (created === undefined) {
+            var byName = this.findByName(styleId);
+            if (byName instanceof ParagraphStyle) {
+                return byName;
+            }
+            throw new DocxError('styles/undefined-style', "Failed to ensure paragraph style \"" + styleId + "\"");
+        }
+        return created;
+    };
+    /**
+     * Ensure a character style exists (built-in catalog or minimal stub).
+     *
+     * @public
+     */
+    StyleCollection.prototype.ensureCharacterStyle = function (styleId) {
+        var existing = this.getCharacterStyle(styleId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        this.ensureStyle(styleId, 'character');
+        var created = this.getCharacterStyle(styleId);
+        if (created === undefined) {
+            var byName = this.findByName(styleId);
+            if (byName instanceof CharacterStyle) {
+                return byName;
+            }
+            throw new DocxError('styles/undefined-style', "Failed to ensure character style \"" + styleId + "\"");
+        }
+        return created;
+    };
+    /**
+     * Ensure a table style exists (built-in catalog or minimal stub).
+     *
+     * @public
+     */
+    StyleCollection.prototype.ensureTableStyle = function (styleId) {
+        var existing = this.getTableStyle(styleId);
+        if (existing !== undefined) {
+            return existing;
+        }
+        this.ensureStyle(styleId, 'table');
+        var created = this.getTableStyle(styleId);
+        if (created === undefined) {
+            var byName = this.findByName(styleId);
+            if (byName instanceof TableStyle) {
+                return byName;
+            }
+            throw new DocxError('styles/undefined-style', "Failed to ensure table style \"" + styleId + "\"");
+        }
+        return created;
+    };
+    /**
+     * Remove a style by id or instance. Detaches the style, clears pending /
+     * projection caches, strips content references (`pStyle` / `rStyle` / table
+     * style) and catalog edges (`basedOn` / `next` / `link`) that point at the
+     * removed id so save-time materialize cannot re-create a minimal stub.
+     * Returns `true` when removed.
+     *
+     * Not part of the public Styles collection surface — use {@link Style.remove}.
+     *
+     * @private
+     */
+    StyleCollection.prototype.remove = function (styleOrId) {
+        var styleId = typeof styleOrId === 'string' ? styleOrId : styleOrId.styleId;
+        var style = this.styleById.get(styleId);
+        if (style === undefined) {
+            return false;
+        }
+        if (typeof styleOrId !== 'string' && styleOrId !== style) {
+            throw new InvalidArgumentError('Style instance is not the collection entry for its styleId');
+        }
+        // Content refs first so materialize cannot observe a dangling id after detach.
+        if (typeof this.host.purgeContentStyleReferences === 'function') {
+            this.host.purgeContentStyleReferences(this.document, styleId);
+        }
+        this.purgeCatalogReferencesTo(styleId, style);
+        var index = this.styleList.indexOf(style);
+        if (index >= 0) {
+            this.styleList.splice(index, 1);
+        }
+        this.styleById.delete(styleId);
+        this.projected.delete(styleId);
+        this.pendingParagraphStyles.delete(styleId);
+        this.pendingCharacterStyles.delete(styleId);
+        this.pendingTableStyles.delete(styleId);
+        if (typeof this.host.forgetProjectedStyle === 'function') {
+            this.host.forgetProjectedStyle(styleId);
+        }
+        style.detach();
+        this.host.markStylesDirty();
+        this.rebuildIndexProperties();
+        return true;
+    };
+    /**
+     * Clear `basedOn` / `next` / `link` on remaining styles that point at `styleId`.
+     *
+     * @private
+     */
+    StyleCollection.prototype.purgeCatalogReferencesTo = function (styleId, removed) {
+        for (var i = 0; i < this.styleList.length; i += 1) {
+            var other = this.styleList[i];
+            if (other === removed) {
+                continue;
+            }
+            other.clearReferencesToStyleId(styleId);
+        }
+    };
+    /**
+     * Ordered styles for package serialization.
+     *
+     * @private
+     */
+    StyleCollection.prototype.stylesInOrder = function () {
+        return this.styleList;
+    };
+    /**
+     * StyleOwner: mark styles part dirty and drop projection for all styles when
+     * a live mutation may have changed modeled XML (host may call for any style).
+     *
+     * @private
+     */
+    StyleCollection.prototype.markStylesDirty = function () {
+        // Drop projection cache so subsequent projectDocxStyle re-serializes.
+        this.projected.clear();
+        this.host.markStylesDirty();
+    };
+    /**
+     * StyleOwner: lookup by id.
+     *
+     * @private
+     */
+    StyleCollection.prototype.lookupStyle = function (styleId) {
+        return this.styleById.get(styleId);
+    };
+    /**
+     * Resolver / part surface: find by display name.
+     *
+     * @private
+     */
+    StyleCollection.prototype.findStyleByDisplayName = function (name) {
+        var live = this.findByName(name);
+        if (live === undefined) {
+            return undefined;
+        }
+        return this.projectDocxStyle(live.styleId);
+    };
+    /**
+     * Add a live style (resolver / hydrate). No-op when id already present.
+     *
+     * @private
+     */
+    StyleCollection.prototype.addStyle = function (style) {
+        if (style instanceof DocxStyle) {
+            if (this.styleById.has(style.styleId)) {
+                return;
+            }
+            this.appendFromDocxShell(style, true);
+            return;
+        }
+        if (this.styleById.has(style.styleId)) {
+            return;
+        }
+        if (style.isAttached && style.owner !== this) {
+            throw new DocxError('argument/invalid', "Style \"" + style.styleId + "\" is owned by another document");
+        }
+        this.attachAndIndex(style, true);
+    };
+    /**
+     * Hydrate from temporary DocxStyle shells (parse / create path). Does not mark dirty
+     * when `markDirty` is false (load path).
+     *
+     * @private
+     */
+    StyleCollection.prototype.hydrateFromDocxStyles = function (sources, markDirty) {
+        for (var i = 0; i < sources.length; i += 1) {
+            var shell = sources[i];
+            if (this.styleById.has(shell.styleId)) {
+                continue;
+            }
+            this.appendFromDocxShell(shell, markDirty);
+        }
+    };
+    /**
+     * Replace contents from DocxStyle shells (load / create). Clears existing entries.
+     *
+     * @private
+     */
+    StyleCollection.prototype.replaceFromDocxStyles = function (sources, markDirty) {
+        for (var i = 0; i < this.styleList.length; i += 1) {
+            this.styleList[i].detach();
+        }
+        this.styleList.length = 0;
+        this.styleById.clear();
+        this.projected.clear();
+        this.hydrateFromDocxStyles(sources, markDirty);
+        this.rebuildIndexProperties();
+    };
+    /** @private */
+    StyleCollection.prototype.registerPendingParagraphStyle = function (styleId) {
+        if (styleId.length === 0 || this.styleById.has(styleId)) {
+            return;
+        }
+        this.pendingParagraphStyles.add(styleId);
+    };
+    /** @private */
+    StyleCollection.prototype.registerPendingCharacterStyle = function (styleId) {
+        if (styleId.length === 0 || this.styleById.has(styleId)) {
+            return;
+        }
+        this.pendingCharacterStyles.add(styleId);
+    };
+    /** @private */
+    StyleCollection.prototype.registerPendingTableStyle = function (styleId) {
+        if (styleId.length === 0 || this.styleById.has(styleId)) {
+            return;
+        }
+        this.pendingTableStyles.add(styleId);
+    };
+    /**
+     * Materialize pending style ids and canonicalize dangling refs (save path).
+     *
+     * @private
+     */
+    StyleCollection.prototype.materializePendingIds = function (onParagraphStyle, onCharacterStyle, onTableStyle) {
+        var pendingParagraph = Array.from(this.pendingParagraphStyles);
+        this.pendingParagraphStyles.clear();
+        for (var i = 0; i < pendingParagraph.length; i += 1) {
+            var styleId = pendingParagraph[i];
+            if (!this.styleById.has(styleId)) {
+                this.ensureStyle(styleId, 'paragraph');
+            }
+            var resolved = this.styleById.get(styleId);
+            if (resolved !== undefined && resolved.styleId !== styleId) {
+                onParagraphStyle(styleId, resolved.styleId);
+            }
+            else if (resolved === undefined) {
+                var byName = this.findByName(styleId);
+                if (byName !== undefined && byName.styleId !== styleId) {
+                    onParagraphStyle(styleId, byName.styleId);
+                }
+            }
+        }
+        var pendingCharacter = Array.from(this.pendingCharacterStyles);
+        this.pendingCharacterStyles.clear();
+        for (var i = 0; i < pendingCharacter.length; i += 1) {
+            var styleId = pendingCharacter[i];
+            if (!this.styleById.has(styleId)) {
+                this.ensureStyle(styleId, 'character');
+            }
+            var resolved = this.styleById.get(styleId);
+            if (resolved !== undefined && resolved.styleId !== styleId) {
+                onCharacterStyle(styleId, resolved.styleId);
+            }
+            else if (resolved === undefined) {
+                var byName = this.findByName(styleId);
+                if (byName !== undefined && byName.styleId !== styleId) {
+                    onCharacterStyle(styleId, byName.styleId);
+                }
+            }
+        }
+        if (onTableStyle !== undefined) {
+            var pendingTable = Array.from(this.pendingTableStyles);
+            this.pendingTableStyles.clear();
+            for (var i = 0; i < pendingTable.length; i += 1) {
+                var styleId = pendingTable[i];
+                if (!this.styleById.has(styleId)) {
+                    this.ensureStyle(styleId, 'table');
+                }
+                var resolved = this.styleById.get(styleId);
+                if (resolved !== undefined && resolved.styleId !== styleId) {
+                    onTableStyle(styleId, resolved.styleId);
+                }
+                else if (resolved === undefined) {
+                    var byName = this.findByName(styleId);
+                    if (byName !== undefined && byName.styleId !== styleId) {
+                        onTableStyle(styleId, byName.styleId);
+                    }
+                }
+            }
+        }
+        else {
+            this.pendingTableStyles.clear();
+        }
+    };
+    /**
+     * Adapter so the existing DocxStyle-based catalog resolver can read/add into this collection.
+     *
+     * @private
+     */
+    StyleCollection.prototype.asDocxLookup = function () {
+        var self = this;
+        return {
+            getStyle: function (styleId) {
+                return self.projectDocxStyle(styleId);
+            },
+            findStyleByDisplayName: function (name) {
+                return self.findStyleByDisplayName(name);
+            },
+            addStyle: function (style) {
+                if (self.styleById.has(style.styleId)) {
+                    return;
+                }
+                self.appendFromDocxShell(style, true);
+            },
+        };
+    };
+    /**
+     * Project live styles to temporary DocxStyle shells (resolver / transitional StylesPart surface).
+     *
+     * @private
+     */
+    StyleCollection.prototype.projectDocxStyles = function () {
+        var out = [];
+        for (var i = 0; i < this.styleList.length; i += 1) {
+            var shell = this.projectDocxStyle(this.styleList[i].styleId);
+            if (shell !== undefined) {
+                out.push(shell);
+            }
+        }
+        return out;
+    };
+    /**
+     * Project one live style to a DocxStyle shell, or `undefined`.
+     * Caches by styleId so StylesPart can keep stable object identity until dirty.
+     *
+     * @private
+     */
+    StyleCollection.prototype.projectDocxStyle = function (styleId) {
+        var cached = this.projected.get(styleId);
+        if (cached !== undefined) {
+            return cached;
+        }
+        var live = this.styleById.get(styleId);
+        if (live === undefined) {
+            return undefined;
+        }
+        var shell = live.toDocxStyle();
+        this.projected.set(styleId, shell);
+        return shell;
+    };
+    /**
+     * @private
+     */
+    StyleCollection.prototype.ensureStyle = function (styleId, type) {
+        if (styleId.length === 0) {
+            throw new DocxError('content/invalid-style-id', 'Style id must not be empty');
+        }
+        if (this.styleById.has(styleId)) {
+            return;
+        }
+        if (type === 'paragraph' || type === 'character') {
+            try {
+                resolveStyleForTarget(this.asDocxLookup(), styleId, type);
+            }
+            catch (err) {
+                void err;
+            }
+            if (this.styleById.has(styleId)) {
+                return;
+            }
+        }
+        var referenced = resolveReferencedStyle(this.asDocxLookup(), styleId, type);
+        if (referenced !== undefined) {
+            if (!this.styleById.has(referenced.styleId)) {
+                this.appendFromDocxShell(referenced, true);
+            }
+            return;
+        }
+        if (type === 'table') {
+            var created_1 = createMinimalDocxStyle(styleId, 'table');
+            this.appendFromDocxShell(created_1, true);
+            return;
+        }
+        var created = createMinimalStyle(styleId, type);
+        this.attachAndIndex(created, true);
+    };
+    StyleCollection.prototype.assertNewId = function (styleId) {
+        if (styleId.length === 0) {
+            throw new InvalidArgumentError('Style id must not be empty');
+        }
+        if (this.styleById.has(styleId)) {
+            throw new DocxError('argument/invalid', "Style id \"" + styleId + "\" already exists in this document");
+        }
+    };
+    /**
+     * Build live Style (or TableStyle) from a DocxStyle shell and index it.
+     *
+     * @private
+     */
+    StyleCollection.prototype.appendFromDocxShell = function (shell, markDirty) {
+        var self = this;
+        var live;
+        if (shell.type === 'table') {
+            var tableHost = {
+                notifyTableStyleMutation: function () {
+                    self.projected.delete(shell.styleId);
+                    self.host.markStylesDirty();
+                },
+            };
+            live = new TableStyle(shell, tableHost);
+        }
+        else {
+            live = createStyleFromDocxStyle(shell);
+        }
+        this.attachAndIndex(live, markDirty);
+        // Prefer the original shell for stable identity when freshly loaded.
+        this.projected.set(live.styleId, shell);
+        return live;
+    };
+    StyleCollection.prototype.attachAndIndex = function (style, markDirty) {
+        if (this.styleById.has(style.styleId)) {
+            return;
+        }
+        if (style instanceof TableStyle) {
+            var self_1 = this;
+            style.bindHost({
+                notifyTableStyleMutation: function () {
+                    self_1.projected.delete(style.styleId);
+                    self_1.host.markStylesDirty();
+                },
+            });
+        }
+        style.attach(this);
+        this.styleList.push(style);
+        this.styleById.set(style.styleId, style);
+        if (markDirty) {
+            this.host.markStylesDirty();
+        }
+        this.rebuildIndexProperties();
+    };
+    /**
+     * Numeric index properties (CommentCollection pattern).
+     *
+     * @private
+     */
+    StyleCollection.prototype.rebuildIndexProperties = function () {
+        var items = this.styleList;
+        var nextLen = items.length;
+        var prevLen = this.cachedLength;
+        var limit = prevLen > nextLen ? prevLen : nextLen;
+        for (var i = 0; i < limit; i += 1) {
+            var key = String(i);
+            if (i < nextLen) {
+                Object.defineProperty(this, key, {
+                    value: items[i],
+                    writable: false,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            else {
+                delete this[key];
+            }
+        }
+        this.cachedLength = nextLen;
+    };
+    return StyleCollection;
+}());
+export { StyleCollection };
+function sanitizeStyleId(name) {
+    var out = '';
+    for (var i = 0; i < name.length; i += 1) {
+        var ch = name.charAt(i);
+        var code = name.charCodeAt(i);
+        var isLetter = (code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            code > 127;
+        var isDigit = code >= 48 && code <= 57;
+        if (isLetter || isDigit) {
+            out += ch;
+        }
+    }
+    return out;
+}
+function uniqueStyleId(base, exists) {
+    if (!exists(base)) {
+        return base;
+    }
+    var n = 1;
+    while (exists(base + String(n))) {
+        n += 1;
+    }
+    return base + String(n);
+}