@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/styles/doc-defaults.js

@@ -0,0 +1,178 @@
+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, wmlElement } from '../document/wml';
+import { EMPTY_MODELED_PARAGRAPH_PROPERTIES, parseModeledParagraphProperties } from './paragraph-properties';
+import { EMPTY_MODELED_RUN_PROPERTIES, parseModeledRunProperties } from './run-properties';
+/**
+ * WordDocument-level default paragraph and run properties (`w:docDefaults` / `CT_DocDefaults`).
+ *
+ * Sequence: optional `w:rPrDefault`, optional `w:pPrDefault` (Transitional `wml.xsd`).
+ * Unmodeled children are retained and re-emitted after the two known slots.
+ *
+ * @private
+ */
+var DocDefaults = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function DocDefaults(rPrDefault, pPrDefault, extras) {
+        if (extras === void 0) { extras = []; }
+        this.rPrDefaultElement = rPrDefault;
+        this.pPrDefaultElement = pPrDefault;
+        this.extras = extras;
+    }
+    /**
+     * Opaque `w:rPrDefault` element when present.
+     *
+     * @public
+     */
+    DocDefaults.prototype.rPrDefault = function () {
+        return this.rPrDefaultElement;
+    };
+    /**
+     * Modeled run properties from `w:rPrDefault/w:rPr`.
+     *
+     * @public
+     */
+    DocDefaults.prototype.runProperties = function () {
+        var e_1, _a;
+        if (this.rPrDefaultElement === undefined) {
+            return EMPTY_MODELED_RUN_PROPERTIES;
+        }
+        try {
+            for (var _b = __values(elementChildren(this.rPrDefaultElement)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (isWml(child, 'rPr')) {
+                    return parseModeledRunProperties(child);
+                }
+            }
+        }
+        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; }
+        }
+        return EMPTY_MODELED_RUN_PROPERTIES;
+    };
+    /**
+     * Opaque `w:pPrDefault` element when present.
+     *
+     * @public
+     */
+    DocDefaults.prototype.pPrDefault = function () {
+        return this.pPrDefaultElement;
+    };
+    /**
+     * Modeled paragraph properties from `w:pPrDefault/w:pPr`.
+     *
+     * Spacing fields use plain point `number`s (twips on the wire). Absent markup
+     * yields an empty model (`spacing` undefined) — create-path defaults are not
+     * injected on load.
+     *
+     * @public
+     */
+    DocDefaults.prototype.paragraphProperties = function () {
+        var e_2, _a;
+        if (this.pPrDefaultElement === undefined) {
+            return EMPTY_MODELED_PARAGRAPH_PROPERTIES;
+        }
+        try {
+            for (var _b = __values(elementChildren(this.pPrDefaultElement)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (isWml(child, 'pPr')) {
+                    return parseModeledParagraphProperties(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; }
+        }
+        return EMPTY_MODELED_PARAGRAPH_PROPERTIES;
+    };
+    /**
+     * @private
+     */
+    DocDefaults.prototype.serialize = function () {
+        var children = [];
+        if (this.rPrDefaultElement !== undefined) {
+            children.push(this.rPrDefaultElement);
+        }
+        if (this.pPrDefaultElement !== undefined) {
+            children.push(this.pPrDefaultElement);
+        }
+        children.push.apply(children, __spread(this.extras));
+        return wmlElement('docDefaults', { children: children });
+    };
+    return DocDefaults;
+}());
+export { DocDefaults };
+/**
+ * Parse `w:docDefaults` into {@link DocDefaults}.
+ *
+ * @private
+ */
+export function parseDocDefaults(element) {
+    var e_3, _a;
+    if (!isWml(element, 'docDefaults')) {
+        return undefined;
+    }
+    var rPrDefault;
+    var pPrDefault;
+    var extras = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'rPrDefault') && rPrDefault === undefined) {
+                rPrDefault = child;
+                continue;
+            }
+            if (isWml(child, 'pPrDefault') && pPrDefault === undefined) {
+                pPrDefault = child;
+                continue;
+            }
+            extras.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; }
+    }
+    return new DocDefaults(rPrDefault, pPrDefault, extras);
+}

package/src/features/styles/formatting-resolver.d.ts

@@ -0,0 +1,27 @@
+import { Paragraph } from '../document/paragraph';
+import { TextRange } from '../document/text-range';
+import { ModeledRunProperties } from './run-properties';
+import { ThemePart } from './theme';
+/**
+ * Effective run formatting after document defaults, paragraph style, character
+ * style inheritance, and direct run properties.
+ *
+ * @private
+ */
+export declare type ResolvedRunFormatting = {
+    readonly bold: boolean;
+    readonly italic: boolean;
+    readonly fontSize: number | undefined;
+    readonly asciiFont: string | undefined;
+    readonly hAnsiFont: string | undefined;
+};
+/** @public Style data required to resolve run formatting. */
+export interface StyleFormatAccess {
+    docDefaultsRunProperties(): ModeledRunProperties;
+    styleRunProperties(styleId: string): ModeledRunProperties | undefined;
+    styleBasedOn(styleId: string): string | undefined;
+}
+/**
+ * @private
+ */
+export declare function resolveRunFormattingWithStyles(styles: StyleFormatAccess, paragraph: Paragraph, run: TextRange, theme: ThemePart | undefined): ResolvedRunFormatting;

package/src/features/styles/formatting-resolver.js

@@ -0,0 +1,72 @@
+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);
+};
+import { effectiveBold, effectiveItalic, EMPTY_MODELED_RUN_PROPERTIES, mergeModeledRunProperties, parseDirectRunFontProperties } from './run-properties';
+function directRunProperties(run) {
+    var cf = run.characterFormat;
+    return __assign({}, EMPTY_MODELED_RUN_PROPERTIES, { bold: cf.bold, italic: cf.italic, fontSize: cf.fontSize, kerning: cf.kerning }, parseDirectRunFontProperties(run));
+}
+function characterStyleChainProperties(styleId, styles) {
+    if (styleId === undefined) {
+        return EMPTY_MODELED_RUN_PROPERTIES;
+    }
+    var chain = [];
+    var seen = new Set();
+    var current = styleId;
+    while (current !== undefined && current.length > 0 && !seen.has(current)) {
+        seen.add(current);
+        chain.push(current);
+        current = styles.styleBasedOn(current);
+    }
+    var merged = EMPTY_MODELED_RUN_PROPERTIES;
+    for (var index = chain.length - 1; index >= 0; index -= 1) {
+        var id = chain[index];
+        if (id === undefined) {
+            continue;
+        }
+        var layer = styles.styleRunProperties(id);
+        if (layer !== undefined) {
+            merged = mergeModeledRunProperties(merged, layer);
+        }
+    }
+    return merged;
+}
+function resolveEffectiveFont(explicit, themeSlot, theme) {
+    if (themeSlot !== undefined) {
+        if (theme === undefined) {
+            return undefined;
+        }
+        return theme.typefaceFor(themeSlot);
+    }
+    return explicit;
+}
+/**
+ * @private
+ */
+export function resolveRunFormattingWithStyles(styles, paragraph, run, theme) {
+    var merged = styles.docDefaultsRunProperties();
+    var paragraphStyleId = paragraph.styleId;
+    if (paragraphStyleId !== undefined) {
+        var paragraphStyle = styles.styleRunProperties(paragraphStyleId);
+        if (paragraphStyle !== undefined) {
+            merged = mergeModeledRunProperties(merged, paragraphStyle);
+        }
+    }
+    merged = mergeModeledRunProperties(merged, characterStyleChainProperties(run.characterFormat.characterStyle, styles));
+    merged = mergeModeledRunProperties(merged, directRunProperties(run));
+    return {
+        bold: effectiveBold(merged),
+        italic: effectiveItalic(merged),
+        fontSize: merged.fontSize,
+        asciiFont: resolveEffectiveFont(merged.asciiFont, merged.asciiTheme, theme),
+        hAnsiFont: resolveEffectiveFont(merged.hAnsiFont, merged.hAnsiTheme, theme),
+    };
+}

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

@@ -0,0 +1,256 @@
+export * from './builtin-catalog';
+export * from './builtin-resolver';
+export * from './default-styles';
+export * from './default-theme';
+export * from './doc-defaults';
+export * from './formatting-resolver';
+export * from './latent-styles';
+export * from './paragraph-properties';
+export * from './run-properties';
+export * from './style-base';
+export * from './style-collection';
+export * from './style-format-bridge';
+export * from './style';
+export * from './styles-with-effects';
+export * from './table-style';
+export * from './theme';
+import { WordDocument } from '../document/document';
+import { FeaturePackagePart } from '../document/feature-package-part';
+import { Paragraph } from '../document/paragraph';
+import { TextRange } from '../document/text-range';
+import { OpenXmlElement } from '../../core/xml/index';
+import { DocDefaults } from './doc-defaults';
+import { StyleLookupSurface } from './builtin-resolver';
+import { StyleCollection, StyleCollectionHost } from './style-collection';
+import { ResolvedRunFormatting } from './formatting-resolver';
+import { LatentStyles } from './latent-styles';
+import { ModeledParagraphProperties } from './paragraph-properties';
+import { ModeledRunProperties } from './run-properties';
+import { DocxStyle } from './style';
+/**
+ * @private
+ * Transitional styles relationship (ECMA-376-4 §9.2.12). */
+export declare const STYLES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+/**
+ * @private
+ * Strict styles relationship (ECMA-376-1 §11.3.12). */
+export declare const STRICT_STYLES_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/styles";
+/**
+ * @private
+ * ECMA-376-1 §11.3.12 Style Definitions content type. */
+export declare const STYLES_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml";
+/**
+ * @private
+ */
+export declare const STYLES_PART_NAME: import("../../core/opc/part-name").PartName;
+/**
+ * In-memory Style Definitions part (`word/styles.xml`).
+ *
+ * Models `CT_Styles` as optional {@link DocDefaults}, optional {@link LatentStyles},
+ * and an ordered list of {@link DocxStyle}. Serialize rebuilds the part from that
+ * class graph (not an opaque XML bag). Unmodeled root children are retained in
+ * document order relative to the three schema slots when dirty-path serialize runs.
+ *
+ * @private
+ */
+/**
+ * In-memory Style Definitions part (`word/styles.xml`).
+ *
+ * Hosts package metadata (`docDefaults`, `latentStyles`, extras) and binds a
+ * document-owned live {@link StyleCollection}. Transitional {@link DocxStyle}
+ * lookups project from the live DOM with a stable shell cache so existing
+ * resolver tests keep identity for getStyle.
+ *
+ * @private
+ */
+export declare class StylesPart implements FeaturePackagePart, StyleLookupSurface, StyleCollectionHost {
+    private docDefaultsValue;
+    private latentStylesValue;
+    /** Unbound create/load shells until {@link bindLiveCollection}. */
+    private shellList;
+    private readonly shellById;
+    private collection;
+    /** Stable DocxStyle projection cache (cleared only on bindLiveCollection). */
+    private readonly projectedById;
+    private readonly rootExtrasBeforeStyles;
+    private readonly rootExtrasAfterStyles;
+    private readonly pendingParagraphStyles;
+    private readonly pendingCharacterStyles;
+    private readonly pendingTableStyles;
+    private dirty;
+    /**
+     * @private
+     */
+    constructor(docDefaults: DocDefaults | undefined, latentStyles: LatentStyles | undefined, styles: DocxStyle[], rootExtrasBeforeStyles: OpenXmlElement[], rootExtrasAfterStyles: OpenXmlElement[], dirty: boolean);
+    /**
+     * @private
+     * StyleCollectionHost: styles package dirty + invalidate DocxStyle projection cache.
+     */
+    markStylesDirty(): void;
+    /**
+     * Drop a stable DocxStyle projection after the live style is removed.
+     *
+     * @private
+     */
+    forgetProjectedStyle(styleId: string): void;
+    /**
+     * Clear body (and header/footer when registered) content references to `styleId`
+     * so save-time materialize cannot re-create a minimal stub.
+     *
+     * @private
+     */
+    purgeContentStyleReferences(document: WordDocument, styleId: string): void;
+    /**
+     * Bind the live StyleCollection and drain create/load shells into it.
+     *
+     * @private
+     */
+    bindLiveCollection(collection: StyleCollection): void;
+    /**
+     * Drain unbound DocxStyle shells (load/create path).
+     *
+     * @private
+     */
+    takeShells(): DocxStyle[];
+    /**
+     * Live styles collection when bound.
+     *
+     * @private
+     */
+    liveCollection(): StyleCollection | undefined;
+    /**
+     * Ordered style definitions as they appear under `w:styles`.
+     * Projects live styles to DocxStyle shells when the collection is bound.
+     *
+     * @public
+     */
+    readonly styles: ReadonlyArray<DocxStyle>;
+    /**
+     * WordDocument defaults (`w:docDefaults`), when present.
+     *
+     * @public
+     */
+    readonly docDefaults: DocDefaults | undefined;
+    /**
+     * Latent styles (`w:latentStyles`), when present.
+     *
+     * @public
+     */
+    readonly latentStyles: LatentStyles | undefined;
+    /**
+     * Look up a style by `w:styleId` (DocxStyle projection; stable while clean).
+     *
+     * @public
+     */
+    getStyle(styleId: string): DocxStyle | undefined;
+    /** Whether a style id exists in the catalog (including pending ensure). */
+    hasStyle(styleId: string): boolean;
+    /**
+     * Modeled run properties from `w:docDefaults/w:rPrDefault/w:rPr`.
+     *
+     * @public
+     */
+    docDefaultsRunProperties(): ModeledRunProperties;
+    /**
+     * Modeled paragraph properties from `w:docDefaults/w:pPrDefault/w:pPr`.
+     *
+     * Spacing uses branded point `number` (twips). Absent markup is not filled
+     * with create-path defaults on load.
+     *
+     * @public
+     */
+    docDefaultsParagraphProperties(): ModeledParagraphProperties;
+    /**
+     * Modeled `w:rPr` on a style definition, or `undefined` when the style is absent.
+     *
+     * @public
+     */
+    styleRunProperties(styleId: string): ModeledRunProperties | undefined;
+    /**
+     * `w:basedOn/@w:val` for a style id, or `undefined` when absent or unknown.
+     *
+     * @public
+     */
+    styleBasedOn(styleId: string): string | undefined;
+    /**
+     * Ensure a paragraph style exists, creating a minimal `CT_Style` when absent.
+     */
+    ensureParagraphStyle(styleId: string): void;
+    /**
+     * Ensure a character style exists, creating a minimal `CT_Style` when absent.
+     */
+    ensureCharacterStyle(styleId: string): void;
+    /**Ensure a table style exists, creating a minimal `CT_Style` when absent.
+     */
+    ensureTableStyle(styleId: string): void;
+    /**
+     * @private
+   * Record a paragraph style reference before save. */
+    registerPendingParagraphStyle(styleId: string): void;
+    /**
+     * @private
+   * Record a character style reference before save. */
+    registerPendingCharacterStyle(styleId: string): void;
+    /**
+     * @private
+   * Record a table style reference before save. */
+    registerPendingTableStyle(styleId: string): void;
+    /**
+     * @private
+     */
+    materializePending(document: WordDocument): void;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    serialize(): Uint8Array;
+    private ensureStyle;
+    /**
+     * @private
+   * Style-collection surface for the built-in resolver. */
+    findStyleByDisplayName(name: string): DocxStyle | undefined;
+    /**
+     * @private
+   * Style-collection surface for the built-in resolver. */
+    addStyle(style: DocxStyle): void;
+}
+/**
+ * Document-owned live StyleCollection. Stable identity per document.
+ *
+ * @public
+ */
+export declare function styleCollectionFor(document: WordDocument): StyleCollection;
+/**
+ * @private
+ * Test hook */
+export declare function resetStylesFeatureForTests(): void;
+/**
+ * @private
+ * Register the styles, theme, and font table package-part handlers. Idempotent. */
+export declare function registerStylesFeature(): void;
+/**
+ * Styles catalog for a document. Requires {@link registerStylesFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the styles module was not registered before load.
+ * @private
+ */
+export declare function stylesFor(document: WordDocument): StylesPart;
+/**
+ * Assign a run character style id and ensure a matching style definition exists.
+ *
+ * Unknown styles throw `styles/undefined-style` (spec §5.2).
+ *
+ * @private
+ */
+export declare function assignRunStyle(document: WordDocument, run: TextRange, styleId: string): void;
+/**
+ * Resolve effective bold, italic, font size, and font names for a run in a paragraph.
+ *
+ * Requires {@link registerStylesFeature} before {@link WordDocument.open}.
+ *
+ * @private
+ */
+export declare function resolveRunFormatting(document: WordDocument, paragraph: Paragraph, run: TextRange): ResolvedRunFormatting;