@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/document/headers-footers.d.ts

@@ -0,0 +1,206 @@
+import { Body } from './body';
+import { BlockContent, Paragraph } from './paragraph';
+import { Document } from './document';
+import { Section } from './section';
+/**
+ * OOXML header/footer reference slot (`default` | `first` | `even`).
+ *
+ * @private
+ */
+export declare type HeaderFooterSlotRef = 'default' | 'first' | 'even';
+/**
+ * Header vs footer story kind.
+ *
+ * @public
+ */
+export declare type HeaderFooterKind = 'header' | 'footer';
+/**
+ * Header or footer story body (`w:hdr` / `w:ftr`).
+ *
+ * Extends {@link Body} so section body and header/footer stories share one
+ * collection architecture. Header/footer-specific state only: kind, slot,
+ * relationship id, and lazy part materialization hooks (feature-bound).
+ *
+ * @public
+ */
+export declare class HeaderFooter extends Body {
+    private readonly kindValue;
+    private readonly refTypeValue;
+    private relationshipIdValue;
+    private materializeHandler;
+    private syncHandler;
+    private suppressSync;
+    private requireFeatureOnMutate;
+    /**
+     * @private
+     */
+    constructor(section: Section | undefined, kind: HeaderFooterKind, refType: HeaderFooterSlotRef, items?: ReadonlyArray<BlockContent>, document?: Document, relationshipId?: string);
+    /**
+     * Header or footer kind for this story.
+     *
+     * @public
+     */
+    readonly kind: HeaderFooterKind;
+    /**
+     * OOXML reference slot (`default` | `first` | `even`).
+     *
+     * @private
+     */
+    readonly refType: HeaderFooterSlotRef;
+    /**
+     * Main Document relationship id for this part when materialized.
+     *
+     * @private
+     */
+    readonly relationshipId: string;
+    /**
+     * @private
+     * Bind or rebind the relationship id after lazy part creation.
+     */
+    bindRelationshipId(relationshipId: string): void;
+    /**
+     * @private
+     * Feature wires lazy part creation and catalog block sync.
+     */
+    bindLifecycleHandlers(materialize: () => void, sync: () => void): void;
+    /**
+     * @private
+     * Unregistered placeholder: mutations throw feature-not-registered.
+     */
+    markFeatureRequiredOnMutate(): void;
+    /**
+     * @private
+     * Replace internal store without materializing or marking the part dirty
+     * (catalog load / initial bind).
+     */
+    replaceItemsSilent(items: ReadonlyArray<BlockContent>): void;
+    /**
+     * @private
+     */
+    replaceRawBlocks(blocks: ReadonlyArray<BlockContent>): void;
+    /**
+     * @private
+     */
+    replaceItems(items: ReadonlyArray<BlockContent>): void;
+    /**
+     * @private
+     * Nested paragraph/item mutation path: materialize + catalog dirty.
+     * Block-level replace already runs sync; in-place TextRange/format edits
+     * only reach Body via assertAttachedParagraph and must dirty the part too.
+     */
+    assertAttachedParagraph(target: Paragraph): void;
+    private ensureMaterializedForMutation;
+    private runSync;
+}
+/**
+ * Factory hooks so the headers-footers feature can bind live HeaderFooter
+ * slot views without core importing the feature module.
+ *
+ * @private
+ */
+export declare type HeadersFootersSlotFactory = {
+    createHeader(section: Section, refType: HeaderFooterSlotRef): HeaderFooter;
+    createFooter(section: Section, refType: HeaderFooterSlotRef): HeaderFooter;
+};
+/**
+ * @private
+ */
+export declare function registerHeadersFootersSlotFactory(factory: HeadersFootersSlotFactory): void;
+/**
+ * @private
+ */
+export declare function resetHeadersFootersSlotFactoryForTests(): void;
+/**
+ * @private
+ */
+export declare function currentHeadersFootersSlotFactory(): HeadersFootersSlotFactory | undefined;
+/**
+ * Header and footer slots for one section.
+ *
+ * Six getters always return {@link HeaderFooter} instances (never `undefined`).
+ * Empty slots have no child items until content is written; package parts are
+ * created lazily on first body mutation.
+ *
+ * @public
+ */
+export declare class HeadersFooters {
+    private section;
+    private oddHeaderInstance;
+    private firstPageHeaderInstance;
+    private evenHeaderInstance;
+    private oddFooterInstance;
+    private firstPageFooterInstance;
+    private evenFooterInstance;
+    private linkToPreviousValue;
+    /**
+     * @private
+     */
+    constructor(section?: Section);
+    /**
+     * @private
+     * Bind the owning section (called from {@link Section} construction).
+     */
+    bindSection(section: Section): void;
+    /**
+     * Odd/default-page header (OOXML `w:type="default"`).
+     *
+     * @public
+     */
+    readonly oddHeader: HeaderFooter;
+    /**
+     * Header used on the first page when different first page is enabled.
+     *
+     * @public
+     */
+    readonly firstPageHeader: HeaderFooter;
+    /**
+     * Header used on even pages when different odd and even is enabled.
+     *
+     * @public
+     */
+    readonly evenHeader: HeaderFooter;
+    /**
+     * Odd/default-page footer (OOXML `w:type="default"`).
+     *
+     * @public
+     */
+    readonly oddFooter: HeaderFooter;
+    /**
+     * Footer used on the first page when different first page is enabled.
+     *
+     * @public
+     */
+    readonly firstPageFooter: HeaderFooter;
+    /**
+     * Footer used on even pages when different odd and even is enabled.
+     *
+     * @public
+     */
+    readonly evenFooter: HeaderFooter;
+    /**
+     * When `true`, this section inherits headers/footers from the previous
+     * section (no local header/footer references). Setting `false` materializes
+     * empty local parts so the section no longer inherits.
+     *
+     * @public
+     */
+    linkToPrevious: boolean;
+    private computeLinkToPrevious;
+    private headerSlot;
+    private footerSlot;
+    private createHeader;
+    private createFooter;
+    private createUnregisteredPlaceholder;
+}
+declare type LinkToPreviousHandler = (section: Section, link: boolean) => void;
+declare type LinkToPreviousQuery = (section: Section) => boolean;
+/**
+ * @private
+ * Feature registers package-side linkToPrevious apply/query.
+ */
+export declare function registerHeadersFootersLinkToPreviousHandlers(apply: LinkToPreviousHandler, query: LinkToPreviousQuery): void;
+/**
+ * @private
+ */
+export declare function resetHeadersFootersLinkToPreviousHandlersForTests(): void;
+export {};

package/src/features/document/headers-footers.js

@@ -0,0 +1,384 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { Body } from './body';
+/**
+ * Header or footer story body (`w:hdr` / `w:ftr`).
+ *
+ * Extends {@link Body} so section body and header/footer stories share one
+ * collection architecture. Header/footer-specific state only: kind, slot,
+ * relationship id, and lazy part materialization hooks (feature-bound).
+ *
+ * @public
+ */
+var HeaderFooter = /** @class */ (function (_super) {
+    __extends(HeaderFooter, _super);
+    /**
+     * @private
+     */
+    function HeaderFooter(section, kind, refType, items, document, relationshipId) {
+        if (items === void 0) { items = []; }
+        if (relationshipId === void 0) { relationshipId = ''; }
+        var _this = this;
+        var ownerDocument = document !== undefined
+            ? document
+            : section !== undefined
+                ? (function () {
+                    try {
+                        return section.owningDocument();
+                    }
+                    catch (_a) {
+                        return undefined;
+                    }
+                })()
+                : undefined;
+        _this = _super.call(this, ownerDocument, items, section) || this;
+        _this.kindValue = kind;
+        _this.refTypeValue = refType;
+        _this.relationshipIdValue = relationshipId;
+        _this.materializeHandler = undefined;
+        _this.syncHandler = undefined;
+        _this.suppressSync = false;
+        _this.requireFeatureOnMutate = false;
+        return _this;
+    }
+    Object.defineProperty(HeaderFooter.prototype, "kind", {
+        /**
+         * Header or footer kind for this story.
+         *
+         * @public
+         */
+        get: function () {
+            return this.kindValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeaderFooter.prototype, "refType", {
+        /**
+         * OOXML reference slot (`default` | `first` | `even`).
+         *
+         * @private
+         */
+        get: function () {
+            return this.refTypeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeaderFooter.prototype, "relationshipId", {
+        /**
+         * Main Document relationship id for this part when materialized.
+         *
+         * @private
+         */
+        get: function () {
+            return this.relationshipIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * Bind or rebind the relationship id after lazy part creation.
+     */
+    HeaderFooter.prototype.bindRelationshipId = function (relationshipId) {
+        this.relationshipIdValue = relationshipId;
+    };
+    /**
+     * @private
+     * Feature wires lazy part creation and catalog block sync.
+     */
+    HeaderFooter.prototype.bindLifecycleHandlers = function (materialize, sync) {
+        this.materializeHandler = materialize;
+        this.syncHandler = sync;
+        this.requireFeatureOnMutate = false;
+    };
+    /**
+     * @private
+     * Unregistered placeholder: mutations throw feature-not-registered.
+     */
+    HeaderFooter.prototype.markFeatureRequiredOnMutate = function () {
+        this.requireFeatureOnMutate = true;
+    };
+    /**
+     * @private
+     * Replace internal store without materializing or marking the part dirty
+     * (catalog load / initial bind).
+     */
+    HeaderFooter.prototype.replaceItemsSilent = function (items) {
+        this.suppressSync = true;
+        try {
+            _super.prototype.replaceItems.call(this, items);
+        }
+        finally {
+            this.suppressSync = false;
+        }
+    };
+    /**
+     * @private
+     */
+    HeaderFooter.prototype.replaceRawBlocks = function (blocks) {
+        this.ensureMaterializedForMutation();
+        _super.prototype.replaceRawBlocks.call(this, blocks);
+        this.runSync();
+    };
+    /**
+     * @private
+     */
+    HeaderFooter.prototype.replaceItems = function (items) {
+        this.ensureMaterializedForMutation();
+        _super.prototype.replaceItems.call(this, items);
+        this.runSync();
+    };
+    /**
+     * @private
+     * Nested paragraph/item mutation path: materialize + catalog dirty.
+     * Block-level replace already runs sync; in-place TextRange/format edits
+     * only reach Body via assertAttachedParagraph and must dirty the part too.
+     */
+    HeaderFooter.prototype.assertAttachedParagraph = function (target) {
+        this.ensureMaterializedForMutation();
+        _super.prototype.assertAttachedParagraph.call(this, target);
+        this.runSync();
+    };
+    HeaderFooter.prototype.ensureMaterializedForMutation = function () {
+        if (this.suppressSync) {
+            return;
+        }
+        if (this.requireFeatureOnMutate) {
+            throw new Error('Headers/footers feature is not registered; call registerHeadersFootersFeature() before mutating header/footer content');
+        }
+        if (this.materializeHandler !== undefined) {
+            this.materializeHandler();
+        }
+    };
+    HeaderFooter.prototype.runSync = function () {
+        if (this.suppressSync) {
+            return;
+        }
+        if (this.syncHandler !== undefined) {
+            this.syncHandler();
+        }
+    };
+    return HeaderFooter;
+}(Body));
+export { HeaderFooter };
+var slotFactory;
+/**
+ * @private
+ */
+export function registerHeadersFootersSlotFactory(factory) {
+    slotFactory = factory;
+}
+/**
+ * @private
+ */
+export function resetHeadersFootersSlotFactoryForTests() {
+    slotFactory = undefined;
+}
+/**
+ * @private
+ */
+export function currentHeadersFootersSlotFactory() {
+    return slotFactory;
+}
+/**
+ * Header and footer slots for one section.
+ *
+ * Six getters always return {@link HeaderFooter} instances (never `undefined`).
+ * Empty slots have no child items until content is written; package parts are
+ * created lazily on first body mutation.
+ *
+ * @public
+ */
+var HeadersFooters = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function HeadersFooters(section) {
+        this.section = section;
+        this.linkToPreviousValue = true;
+    }
+    /**
+     * @private
+     * Bind the owning section (called from {@link Section} construction).
+     */
+    HeadersFooters.prototype.bindSection = function (section) {
+        this.section = section;
+    };
+    Object.defineProperty(HeadersFooters.prototype, "oddHeader", {
+        /**
+         * Odd/default-page header (OOXML `w:type="default"`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.headerSlot('default', 'oddHeaderInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "firstPageHeader", {
+        /**
+         * Header used on the first page when different first page is enabled.
+         *
+         * @public
+         */
+        get: function () {
+            return this.headerSlot('first', 'firstPageHeaderInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "evenHeader", {
+        /**
+         * Header used on even pages when different odd and even is enabled.
+         *
+         * @public
+         */
+        get: function () {
+            return this.headerSlot('even', 'evenHeaderInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "oddFooter", {
+        /**
+         * Odd/default-page footer (OOXML `w:type="default"`).
+         *
+         * @public
+         */
+        get: function () {
+            return this.footerSlot('default', 'oddFooterInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "firstPageFooter", {
+        /**
+         * Footer used on the first page when different first page is enabled.
+         *
+         * @public
+         */
+        get: function () {
+            return this.footerSlot('first', 'firstPageFooterInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "evenFooter", {
+        /**
+         * Footer used on even pages when different odd and even is enabled.
+         *
+         * @public
+         */
+        get: function () {
+            return this.footerSlot('even', 'evenFooterInstance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(HeadersFooters.prototype, "linkToPrevious", {
+        /**
+         * When `true`, this section inherits headers/footers from the previous
+         * section (no local header/footer references). Setting `false` materializes
+         * empty local parts so the section no longer inherits.
+         *
+         * @public
+         */
+        get: function () {
+            return this.computeLinkToPrevious();
+        },
+        set: function (value) {
+            this.linkToPreviousValue = value;
+            var handler = linkToPreviousHandler;
+            if (handler !== undefined && this.section !== undefined) {
+                handler(this.section, value);
+                return;
+            }
+            if (!value && this.section !== undefined) {
+                // Feature not registered: force materialize attempt via empty mutate path is unavailable.
+                // Leaving local flag only; feature handler applies package-side unlink when registered.
+                return;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    HeadersFooters.prototype.computeLinkToPrevious = function () {
+        var handler = linkToPreviousQuery;
+        if (handler !== undefined && this.section !== undefined) {
+            return handler(this.section);
+        }
+        return this.linkToPreviousValue;
+    };
+    HeadersFooters.prototype.headerSlot = function (refType, cacheKey) {
+        var cached = this[cacheKey];
+        if (cached !== undefined) {
+            return cached;
+        }
+        var created = this.createHeader(refType);
+        this[cacheKey] = created;
+        return created;
+    };
+    HeadersFooters.prototype.footerSlot = function (refType, cacheKey) {
+        var cached = this[cacheKey];
+        if (cached !== undefined) {
+            return cached;
+        }
+        var created = this.createFooter(refType);
+        this[cacheKey] = created;
+        return created;
+    };
+    HeadersFooters.prototype.createHeader = function (refType) {
+        var section = this.section;
+        var factory = slotFactory;
+        if (section !== undefined && factory !== undefined) {
+            return factory.createHeader(section, refType);
+        }
+        return this.createUnregisteredPlaceholder('header', refType);
+    };
+    HeadersFooters.prototype.createFooter = function (refType) {
+        var section = this.section;
+        var factory = slotFactory;
+        if (section !== undefined && factory !== undefined) {
+            return factory.createFooter(section, refType);
+        }
+        return this.createUnregisteredPlaceholder('footer', refType);
+    };
+    HeadersFooters.prototype.createUnregisteredPlaceholder = function (kind, refType) {
+        var placeholder = new HeaderFooter(this.section, kind, refType, []);
+        placeholder.markFeatureRequiredOnMutate();
+        return placeholder;
+    };
+    return HeadersFooters;
+}());
+export { HeadersFooters };
+var linkToPreviousHandler;
+var linkToPreviousQuery;
+/**
+ * @private
+ * Feature registers package-side linkToPrevious apply/query.
+ */
+export function registerHeadersFootersLinkToPreviousHandlers(apply, query) {
+    linkToPreviousHandler = apply;
+    linkToPreviousQuery = query;
+}
+/**
+ * @private
+ */
+export function resetHeadersFootersLinkToPreviousHandlersForTests() {
+    linkToPreviousHandler = undefined;
+    linkToPreviousQuery = undefined;
+}

package/src/features/document/index.d.ts

@@ -0,0 +1,41 @@
+export * from './alignment';
+export * from './alt-chunk';
+export * from './assert-never';
+export * from './augmentations';
+export * from './body-always-on';
+export * from './body-blocks';
+export * from './body-item-adapters';
+export * from './body-item-collection';
+export * from './body-item';
+export * from './body';
+export * from './character-format';
+export * from './color';
+export { WordDocument } from './document';
+export * from './element-type';
+export * from './entity-type';
+export * from './feature-block';
+export * from './feature-inline';
+export * from './feature-multi-package-part';
+export * from './feature-package-level-part';
+export * from './feature-package-part';
+export * from './feature-run-leaf';
+export * from './headers-footers';
+export * from './length';
+export * from './load-options';
+export * from './locale-ids';
+export * from './on-off';
+export * from './page-setup';
+export { TabJustification, TabLeader, TabStopAlignment, TabStopLeader, } from './paragraph-format';
+export * from './paragraph-item-collection';
+export * from './paragraph-item';
+export * from './paragraph';
+export * from './section-partition-flatten';
+export { ParagraphItem, ParagraphItemOwner } from './text-range';
+export * from './section-properties-model';
+export * from './section';
+export * from './sections';
+export * from './sub-super-script';
+export * from './text-range';
+export * from './typed-body-collections';
+export * from './underline-style';
+export * from './wml';

package/src/features/document/index.js

@@ -0,0 +1,34 @@
+export * from './alignment';
+export * from './alt-chunk';
+export * from './assert-never';
+export * from './body-always-on';
+export * from './body-blocks';
+export * from './body-item-adapters';
+export * from './body-item-collection';
+export * from './body-item';
+export * from './body';
+export * from './character-format';
+export * from './color';
+export { WordDocument } from './document';
+export * from './element-type';
+export * from './entity-type';
+export * from './feature-multi-package-part';
+export * from './feature-package-level-part';
+export * from './headers-footers';
+export * from './length';
+export * from './locale-ids';
+export * from './on-off';
+export * from './page-setup';
+export { TabJustification, TabLeader, } from './paragraph-format';
+export * from './paragraph-item-collection';
+export * from './paragraph-item';
+export * from './paragraph';
+export * from './section-partition-flatten';
+export { ParagraphItem } from './text-range';
+export * from './section';
+export * from './sections';
+export * from './sub-super-script';
+export * from './text-range';
+export * from './typed-body-collections';
+export * from './underline-style';
+export * from './wml';