@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

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

@@ -0,0 +1,126 @@
+import { WordDocument } from '../document/document';
+import { FeaturePackagePart } from '../document/feature-package-part';
+/**
+ * @private DrawingML Main namespace (ECMA-376-1 §14.2.7). */
+export declare const DML_MAIN_NAMESPACE = "http://schemas.openxmlformats.org/drawingml/2006/main";
+/**
+ * @private Transitional theme relationship (ECMA-376-4 §12.2.7). */
+export declare const THEME_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+/**
+ * @private Strict theme relationship (ECMA-376-1 §14.2.7). */
+export declare const STRICT_THEME_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/theme";
+/**
+ * @private ECMA-376-1 §14.2.7 Theme part content type. */
+export declare const THEME_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.theme+xml";
+/** @private */
+export declare const THEME_PART_NAME: import("../../core/opc/part-name").PartName;
+/** @private */
+interface ThemeFontCollection {
+    readonly latin: string | undefined;
+    readonly ea: string | undefined;
+    readonly cs: string | undefined;
+}
+/** @private */
+interface ThemeFontScheme {
+    readonly major: ThemeFontCollection;
+    readonly minor: ThemeFontCollection;
+}
+/** @private */
+interface ThemeMetadata {
+    readonly name: string | undefined;
+    readonly colorSchemeName: string | undefined;
+    readonly fontSchemeName: string | undefined;
+    readonly formatSchemeName: string | undefined;
+    readonly fontScheme: ThemeFontScheme | undefined;
+}
+/** Theme font slot (`ST_Theme`, ECMA-376-1 §17.18.96).
+ * @private
+ */
+export declare type ThemeFontSlot = 'majorEastAsia' | 'majorBidi' | 'majorAscii' | 'majorHAnsi' | 'minorEastAsia' | 'minorBidi' | 'minorAscii' | 'minorHAnsi';
+/**
+ * @private
+ * Parse `ST_Theme` attribute value. */
+export declare function parseThemeFontSlot(raw: string | undefined): ThemeFontSlot | undefined;
+/**
+ * In-memory Theme part (`word/theme/theme1.xml`).
+ *
+ * When no Theme package part exists on load or {@link WordDocument.create}, the library
+ * materializes a Word-proven default Office Theme (`dirty = true`) so save emits
+ * `/word/theme/theme1.xml`. Existing package bytes are preserved when `dirty` is
+ * false. Full typed theme editors remain out of scope (ADR D13).
+ * @private
+ */
+export declare class ThemePart implements FeaturePackagePart {
+    private readonly bytes;
+    private readonly metadata;
+    private readonly dirty;
+    /**
+     * @private
+     */
+    constructor(bytes: Uint8Array | undefined, metadata: ThemeMetadata | undefined, dirty: boolean);
+    /**
+     * `a:theme/@name`, or `undefined` when metadata could not be parsed.
+     *
+     * @public
+     */
+    name(): string | undefined;
+    /**
+     * `a:themeElements/a:clrScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    colorSchemeName(): string | undefined;
+    /**
+     * `a:themeElements/a:fontScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    fontSchemeName(): string | undefined;
+    /**
+     * `a:themeElements/a:fmtScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    formatSchemeName(): string | undefined;
+    /**
+     * Resolve a theme font slot to a typeface name from `a:fontScheme`.
+     *
+     * Returns `undefined` when the part, font scheme, or slot typeface is absent.
+     *
+     * @public
+     */
+    typefaceFor(slot: ThemeFontSlot): string | undefined;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    serialize(): Uint8Array;
+}
+/**
+ * Build the Word-proven default Office Theme part used when no Theme package
+ * part exists (create path and load without theme). Evidence:
+ * `input-documents/Sample_With_All_word_Element.docx` → `word/theme/theme1.xml`
+ * (ECMA-376-1 §14.2.7). Marked dirty so save emits the part.
+ * @private
+ */
+export declare function createDefaultThemePart(): ThemePart;
+/**
+ * @private
+ * Test hook */
+export declare function resetThemeFeatureForTests(): void;
+/**
+ * @private
+ * Register the theme package-part handler. Idempotent. */
+export declare function registerThemeFeature(): void;
+/**
+ * Theme catalog for a document. Requires {@link registerStylesFeature} or
+ * {@link registerThemeFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the theme handler was not registered before load.
+ * @private
+ */
+export declare function themeFor(document: WordDocument): ThemePart;
+export {};

package/src/features/styles/theme.js

@@ -0,0 +1,377 @@
+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 { DocxError } from '../../core/errors/docx-error';
+import { partName } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeaturePartHandler, } from '../../core/registry/index';
+import { parseXml } from '../../core/xml/index';
+import { DEFAULT_OFFICE_THEME_XML } from './default-theme';
+var THEME = featureId('theme');
+var utf8 = new TextEncoder();
+/**
+ * @private DrawingML Main namespace (ECMA-376-1 §14.2.7). */
+export var DML_MAIN_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+/**
+ * @private Transitional theme relationship (ECMA-376-4 §12.2.7). */
+export var THEME_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme';
+/**
+ * @private Strict theme relationship (ECMA-376-1 §14.2.7). */
+export var STRICT_THEME_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/theme';
+/**
+ * @private ECMA-376-1 §14.2.7 Theme part content type. */
+export var THEME_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.theme+xml';
+/** @private */
+export var THEME_PART_NAME = partName('/word/theme/theme1.xml');
+/** @private */
+var utf8Decoder = new TextDecoder('utf-8');
+/**
+* @private
+*/
+var THEME_FONT_SLOTS = [
+    'majorEastAsia',
+    'majorBidi',
+    'majorAscii',
+    'majorHAnsi',
+    'minorEastAsia',
+    'minorBidi',
+    'minorAscii',
+    'minorHAnsi',
+];
+/**
+ * @private
+ * Parse `ST_Theme` attribute value. */
+export function parseThemeFontSlot(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    // TS 3.3 / ES5 parity: avoid Array.prototype.includes.
+    return THEME_FONT_SLOTS.indexOf(raw) !== -1 ? raw : undefined;
+}
+function parseFontCollection(element) {
+    var e_1, _a;
+    var latin;
+    var ea;
+    var cs;
+    try {
+        for (var _b = __values(childElements(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isDml(child, 'latin')) {
+                latin = dmlAttribute(child, 'typeface');
+                continue;
+            }
+            if (isDml(child, 'ea')) {
+                ea = dmlAttribute(child, 'typeface');
+                continue;
+            }
+            if (isDml(child, 'cs')) {
+                cs = dmlAttribute(child, 'typeface');
+            }
+        }
+    }
+    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 { latin: latin, ea: ea, cs: cs };
+}
+function parseThemeFontScheme(root) {
+    var e_2, _a, e_3, _b, e_4, _c;
+    try {
+        for (var _d = __values(childElements(root)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var child = _e.value;
+            if (!isDml(child, 'themeElements')) {
+                continue;
+            }
+            var major = void 0;
+            var minor = void 0;
+            try {
+                for (var _f = __values(childElements(child)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var scheme = _g.value;
+                    if (isDml(scheme, 'fontScheme')) {
+                        try {
+                            for (var _h = __values(childElements(scheme)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                                var fontCollection = _j.value;
+                                if (isDml(fontCollection, 'majorFont')) {
+                                    major = parseFontCollection(fontCollection);
+                                }
+                                else if (isDml(fontCollection, 'minorFont')) {
+                                    minor = parseFontCollection(fontCollection);
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        break;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            if (major === undefined && minor === undefined) {
+                return undefined;
+            }
+            return {
+                major: major != null ? major : { latin: undefined, ea: undefined, cs: undefined },
+                minor: minor != null ? minor : { latin: undefined, ea: undefined, cs: undefined },
+            };
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function typefaceForSlot(scheme, slot) {
+    switch (slot) {
+        case 'majorAscii':
+        case 'majorHAnsi':
+            return scheme.major.latin;
+        case 'minorAscii':
+        case 'minorHAnsi':
+            return scheme.minor.latin;
+        case 'majorEastAsia':
+            return scheme.major.ea;
+        case 'minorEastAsia':
+            return scheme.minor.ea;
+        case 'majorBidi':
+            return scheme.major.cs;
+        case 'minorBidi':
+            return scheme.minor.cs;
+    }
+}
+function isDml(element, localName) {
+    return element.localName === localName && element.namespaceUri === DML_MAIN_NAMESPACE;
+}
+function dmlAttribute(element, localName) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === DML_MAIN_NAMESPACE || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function childElements(element) {
+    return element.children.filter(function (child) { return child.kind === 'element'; });
+}
+function parseThemeMetadata(root) {
+    var e_5, _a, e_6, _b;
+    if (!isDml(root, 'theme')) {
+        return undefined;
+    }
+    var colorSchemeName;
+    var fontSchemeName;
+    var formatSchemeName;
+    try {
+        for (var _c = __values(childElements(root)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (!isDml(child, 'themeElements')) {
+                continue;
+            }
+            try {
+                for (var _e = __values(childElements(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var scheme = _f.value;
+                    if (isDml(scheme, 'clrScheme')) {
+                        colorSchemeName = dmlAttribute(scheme, 'name');
+                    }
+                    else if (isDml(scheme, 'fontScheme')) {
+                        fontSchemeName = dmlAttribute(scheme, 'name');
+                    }
+                    else if (isDml(scheme, 'fmtScheme')) {
+                        formatSchemeName = dmlAttribute(scheme, 'name');
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            break;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return {
+        name: dmlAttribute(root, 'name'),
+        colorSchemeName: colorSchemeName,
+        fontSchemeName: fontSchemeName,
+        formatSchemeName: formatSchemeName,
+        fontScheme: parseThemeFontScheme(root),
+    };
+}
+function parseThemeMetadataFromBytes(bytes) {
+    var root = parseXml(utf8Decoder.decode(bytes));
+    return parseThemeMetadata(root);
+}
+/**
+ * In-memory Theme part (`word/theme/theme1.xml`).
+ *
+ * When no Theme package part exists on load or {@link WordDocument.create}, the library
+ * materializes a Word-proven default Office Theme (`dirty = true`) so save emits
+ * `/word/theme/theme1.xml`. Existing package bytes are preserved when `dirty` is
+ * false. Full typed theme editors remain out of scope (ADR D13).
+ * @private
+ */
+var ThemePart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ThemePart(bytes, metadata, dirty) {
+        this.bytes = bytes;
+        this.metadata = metadata;
+        this.dirty = dirty;
+    }
+    /**
+     * `a:theme/@name`, or `undefined` when metadata could not be parsed.
+     *
+     * @public
+     */
+    ThemePart.prototype.name = function () {
+        return this.metadata == null ? undefined : this.metadata.name;
+    };
+    /**
+     * `a:themeElements/a:clrScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    ThemePart.prototype.colorSchemeName = function () {
+        return this.metadata == null ? undefined : this.metadata.colorSchemeName;
+    };
+    /**
+     * `a:themeElements/a:fontScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    ThemePart.prototype.fontSchemeName = function () {
+        return this.metadata == null ? undefined : this.metadata.fontSchemeName;
+    };
+    /**
+     * `a:themeElements/a:fmtScheme/@name`, or `undefined` when absent.
+     *
+     * @public
+     */
+    ThemePart.prototype.formatSchemeName = function () {
+        return this.metadata == null ? undefined : this.metadata.formatSchemeName;
+    };
+    /**
+     * Resolve a theme font slot to a typeface name from `a:fontScheme`.
+     *
+     * Returns `undefined` when the part, font scheme, or slot typeface is absent.
+     *
+     * @public
+     */
+    ThemePart.prototype.typefaceFor = function (slot) {
+        var scheme = this.metadata == null ? undefined : this.metadata.fontScheme;
+        if (scheme === undefined) {
+            return undefined;
+        }
+        return typefaceForSlot(scheme, slot);
+    };
+    /**
+     * @private
+     */
+    ThemePart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    ThemePart.prototype.serialize = function () {
+        if (this.bytes !== undefined) {
+            return this.bytes;
+        }
+        return new Uint8Array(0);
+    };
+    return ThemePart;
+}());
+export { ThemePart };
+/**
+ * Build the Word-proven default Office Theme part used when no Theme package
+ * part exists (create path and load without theme). Evidence:
+ * `input-documents/Sample_With_All_word_Element.docx` → `word/theme/theme1.xml`
+ * (ECMA-376-1 §14.2.7). Marked dirty so save emits the part.
+ * @private
+ */
+export function createDefaultThemePart() {
+    var bytes = utf8.encode(DEFAULT_OFFICE_THEME_XML);
+    var metadata = parseThemeMetadataFromBytes(bytes);
+    return new ThemePart(bytes, metadata, true);
+}
+function loadThemePart(part) {
+    if (part === undefined) {
+        return createDefaultThemePart();
+    }
+    var metadata = parseThemeMetadataFromBytes(part.data);
+    return new ThemePart(part.data, metadata, false);
+}
+var themeRegistered = false;
+/**
+ * @private
+ * Test hook */
+export function resetThemeFeatureForTests() {
+    themeRegistered = false;
+}
+/**
+ * @private
+ * Register the theme package-part handler. Idempotent. */
+export function registerThemeFeature() {
+    if (themeRegistered) {
+        return;
+    }
+    themeRegistered = true;
+    registerFeature({ id: THEME });
+    registerFeaturePartHandler({
+        featureId: THEME,
+        relationshipTypes: [THEME_RELATIONSHIP_TYPE, STRICT_THEME_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'theme/theme1.xml',
+        partName: THEME_PART_NAME,
+        contentType: THEME_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadThemePart(part);
+        },
+    });
+}
+/**
+ * Theme catalog for a document. Requires {@link registerStylesFeature} or
+ * {@link registerThemeFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the theme handler was not registered before load.
+ * @private
+ */
+export function themeFor(document) {
+    registerThemeFeature();
+    var part = document.featurePart(THEME);
+    if (part === undefined || !(part instanceof ThemePart)) {
+        throw new DocxError('feature/not-registered', 'Theme part was not loaded; call registerStylesFeature() before WordDocument.open');
+    }
+    return part;
+}

package/src/features/tables/border-style-map.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Map between public {@link BorderStyle} and OOXML `CT_Border` `@w:val`.
+ *
+ * Unknown wire values are preserved internally and do not surface as a public enum.
+ */
+import { BorderStyle } from '../document/page-setup';
+/**
+ * Parse `@w:val` to {@link BorderStyle}, or `undefined` when unknown/absent.
+ *
+ * @private
+ */
+export declare function borderStyleFromWire(val: string | undefined): BorderStyle | undefined;
+/**
+ * Serialize {@link BorderStyle} to `@w:val`.
+ *
+ * @private
+ */
+export declare function borderStyleToWire(style: BorderStyle): string;
+/**
+ * True when `val` is a known public border style token.
+ *
+ * @private
+ */
+export declare function isKnownBorderWire(val: string | undefined): boolean;

package/src/features/tables/border-style-map.js

@@ -0,0 +1,81 @@
+/**
+ * Map between public {@link BorderStyle} and OOXML `CT_Border` `@w:val`.
+ *
+ * Unknown wire values are preserved internally and do not surface as a public enum.
+ */
+import { BorderStyle } from '../document/page-setup';
+var KNOWN_WIRE = {
+    nil: BorderStyle.Nil,
+    none: BorderStyle.None,
+    single: BorderStyle.Single,
+    thick: BorderStyle.Thick,
+    double: BorderStyle.Double,
+    dotted: BorderStyle.Dotted,
+    dashed: BorderStyle.Dashed,
+    dotDash: BorderStyle.DotDash,
+    dotDotDash: BorderStyle.DotDotDash,
+    triple: BorderStyle.Triple,
+    thinThickSmallGap: BorderStyle.ThinThickSmallGap,
+    thickThinSmallGap: BorderStyle.ThickThinSmallGap,
+    thinThickThinSmallGap: BorderStyle.ThinThickThinSmallGap,
+    thinThickMediumGap: BorderStyle.ThinThickMediumGap,
+    thickThinMediumGap: BorderStyle.ThickThinMediumGap,
+    thinThickThinMediumGap: BorderStyle.ThinThickThinMediumGap,
+    thinThickLargeGap: BorderStyle.ThinThickLargeGap,
+    thickThinLargeGap: BorderStyle.ThickThinLargeGap,
+    thinThickThinLargeGap: BorderStyle.ThinThickThinLargeGap,
+    wave: BorderStyle.Wave,
+    doubleWave: BorderStyle.DoubleWave,
+    dashSmallGap: BorderStyle.DashSmallGap,
+    dashDotStroked: BorderStyle.DashDotStroked,
+    threeDEmboss: BorderStyle.ThreeDEmboss,
+    threeDEngrave: BorderStyle.ThreeDEngrave,
+    outset: BorderStyle.Outset,
+    inset: BorderStyle.Inset,
+};
+/**
+ * Parse `@w:val` to {@link BorderStyle}, or `undefined` when unknown/absent.
+ *
+ * @private
+ */
+export function borderStyleFromWire(val) {
+    if (val === undefined) {
+        return undefined;
+    }
+    var mapped = KNOWN_WIRE[val];
+    return mapped !== undefined ? mapped : undefined;
+}
+var STYLE_TO_WIRE = (function () {
+    var out = {};
+    var keys = Object.keys(KNOWN_WIRE);
+    for (var i = 0; i < keys.length; i += 1) {
+        var wire = keys[i];
+        var style = KNOWN_WIRE[wire];
+        out[style] = wire;
+    }
+    return out;
+})();
+/**
+ * Serialize {@link BorderStyle} to `@w:val`.
+ *
+ * @private
+ */
+export function borderStyleToWire(style) {
+    var wire = STYLE_TO_WIRE[style];
+    if (wire !== undefined) {
+        return wire;
+    }
+    // Fall back only for values that already match a known wire token string.
+    if (KNOWN_WIRE[style] !== undefined) {
+        return style;
+    }
+    throw new RangeError('Unsupported BorderStyle value');
+}
+/**
+ * True when `val` is a known public border style token.
+ *
+ * @private
+ */
+export function isKnownBorderWire(val) {
+    return val !== undefined && KNOWN_WIRE[val] !== undefined;
+}