@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/settings/compat-settings.js

@@ -0,0 +1,508 @@
+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 };
+        }
+    };
+};
+/**
+ * `w:compat` / `w:compatSetting` DOM (`CT_Compat` / `CT_CompatSetting`, Transitional `wml.xsd`).
+ *
+ * MVP: detect/list `compatSetting` name/uri/val; model selected nested OnOff flags
+ * (`noColumnBalance`); preserve remaining nested OnOff flags and unknown children in
+ * document order. Compatibility *engine* / layout behavior is out of scope.
+ *
+ * @public
+ */
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlElement } from '../document/wml';
+function wmlAttribute(element, localName) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === WML_TRANSITIONAL_NAMESPACE || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+/** Modeled CT_OnOff local names under `w:compat` (ECMA-376-4 transitional). */
+var MODELED_COMPAT_ON_OFF = new Set(['noColumnBalance']);
+/** Word `compatibilityMode` setting URI (Microsoft Office Word). */
+var WORD_COMPAT_URI = 'http://schemas.microsoft.com/office/word';
+/**
+ * Word compatibility engine level from
+ * `w:compat/w:compatSetting[@w:name='compatibilityMode']/@w:val`.
+ *
+ * Wire values are ECMA-376 / Word practice: `"12"` | `"14"` | `"15"`.
+ *
+ * @public
+ */
+export var CompatibilityMode;
+(function (CompatibilityMode) {
+    /** Word 2007 compatibility (`"12"`). */
+    CompatibilityMode["Word2007"] = "12";
+    /** Word 2010 compatibility (`"14"`). */
+    CompatibilityMode["Word2010"] = "14";
+    /** Word 2013 and later compatibility (`"15"`). */
+    CompatibilityMode["Word2013"] = "15";
+})(CompatibilityMode || (CompatibilityMode = {}));
+/**
+ * One `w:compatSetting` entry (`CT_CompatSetting`).
+ * Preserve-only infrastructure; not part of the supported public surface.
+ *
+ * @private
+ */
+var CompatSetting = /** @class */ (function () {
+    function CompatSetting(settingName, settingUri, settingVal, attributes, elementChildren, namespaceDeclarations) {
+        this.settingName = settingName;
+        this.settingUri = settingUri;
+        this.settingVal = settingVal;
+        this.attributes = attributes;
+        this.elementChildren = elementChildren;
+        this.namespaceDeclarations = namespaceDeclarations;
+    }
+    /**
+     * @private
+     */
+    CompatSetting.fromElement = function (element) {
+        return new CompatSetting(wmlAttribute(element, 'name'), wmlAttribute(element, 'uri'), wmlAttribute(element, 'val'), element.attributes, __spread(element.children), element.namespaceDeclarations);
+    };
+    /**
+     * Build a `w:compatSetting` with standard `name` / `uri` / `val` attributes.
+     *
+     * @private
+     */
+    CompatSetting.create = function (name, uri, val) {
+        return CompatSetting.fromElement(wmlElement('compatSetting', {
+            attributes: [
+                { namespaceUri: WML_TRANSITIONAL_NAMESPACE, localName: 'name', prefix: 'w', value: name },
+                { namespaceUri: WML_TRANSITIONAL_NAMESPACE, localName: 'uri', prefix: 'w', value: uri },
+                { namespaceUri: WML_TRANSITIONAL_NAMESPACE, localName: 'val', prefix: 'w', value: val },
+            ],
+        }));
+    };
+    /**
+     * `w:name` value, if present.
+     *
+     * @private
+     */
+    CompatSetting.prototype.name = function () {
+        return this.settingName;
+    };
+    /**
+     * `w:uri` value, if present.
+     *
+     * @private
+     */
+    CompatSetting.prototype.uri = function () {
+        return this.settingUri;
+    };
+    /**
+     * `w:val` value, if present.
+     *
+     * @private
+     */
+    CompatSetting.prototype.val = function () {
+        return this.settingVal;
+    };
+    /**
+     * @private
+     */
+    CompatSetting.prototype.serialize = function () {
+        return wmlElement('compatSetting', __assign({ attributes: this.attributes, children: this.elementChildren }, (this.namespaceDeclarations.length > 0
+            ? { namespaceDeclarations: this.namespaceDeclarations }
+            : {})));
+    };
+    return CompatSetting;
+}());
+export { CompatSetting };
+/**
+ * Opaque nested child under `w:compat` (legacy OnOff flags, unknown markup).
+ *
+ * @private
+ */
+var CompatOpaqueChild = /** @class */ (function () {
+    function CompatOpaqueChild(element) {
+        this.element = element;
+    }
+    CompatOpaqueChild.prototype.serialize = function () {
+        return this.element;
+    };
+    return CompatOpaqueChild;
+}());
+/**
+ * Modeled `CT_OnOff` child under `w:compat` (currently `w:noColumnBalance`).
+ *
+ * @private
+ */
+var CompatOnOffChild = /** @class */ (function () {
+    function CompatOnOffChild(localName, value) {
+        this.localName = localName;
+        this.value = value;
+    }
+    CompatOnOffChild.tryFromElement = function (element) {
+        if (!MODELED_COMPAT_ON_OFF.has(element.localName) || !isWml(element, element.localName)) {
+            return undefined;
+        }
+        var parsed = parseOnOff(element);
+        if (parsed === undefined) {
+            return undefined;
+        }
+        return new CompatOnOffChild(element.localName, parsed);
+    };
+    CompatOnOffChild.prototype.read = function () {
+        return this.value;
+    };
+    CompatOnOffChild.prototype.write = function (value) {
+        this.value = value;
+    };
+    CompatOnOffChild.prototype.serialize = function () {
+        return serializeOnOff(this.localName, this.value);
+    };
+    return CompatOnOffChild;
+}());
+/**
+ * First-class `w:compat` container.
+ *
+ * @public
+ */
+var CompatSettings = /** @class */ (function () {
+    function CompatSettings(children, attributes, namespaceDeclarations, onDirty) {
+        this.children = children;
+        this.attributes = attributes;
+        this.namespaceDeclarations = namespaceDeclarations;
+        this.onDirty = onDirty;
+    }
+    /**
+     * @private
+     */
+    CompatSettings.fromElement = function (element) {
+        var e_1, _a;
+        var children = [];
+        try {
+            for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (isWml(child, 'compatSetting')) {
+                    children.push(CompatSetting.fromElement(child));
+                    continue;
+                }
+                var onOff = CompatOnOffChild.tryFromElement(child);
+                if (onOff !== undefined) {
+                    children.push(onOff);
+                    continue;
+                }
+                children.push(new CompatOpaqueChild(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 new CompatSettings(children, element.attributes, element.namespaceDeclarations);
+    };
+    /**
+     * @private
+     * Empty `w:compat` shell used when authors need a first-class OnOff under compat.
+     */
+    CompatSettings.createEmpty = function (onDirty) {
+        return new CompatSettings([], [], [], onDirty);
+    };
+    /**
+     * @private
+     * Bind dirty callback after SettingsPart wraps the node.
+     */
+    CompatSettings.prototype.bindDirty = function (onDirty) {
+        this.onDirty = onDirty;
+    };
+    CompatSettings.prototype.markDirty = function () {
+        if (this.onDirty !== undefined) {
+            this.onDirty();
+        }
+    };
+    CompatSettings.prototype.findOnOff = function (localName) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(this.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (child instanceof CompatOnOffChild && child.localName === localName) {
+                    return 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 undefined;
+    };
+    CompatSettings.prototype.setOnOff = function (localName, value) {
+        var existingIndex = this.children.findIndex(function (child) { return child instanceof CompatOnOffChild && child.localName === localName; });
+        if (value === undefined) {
+            if (existingIndex >= 0) {
+                this.children.splice(existingIndex, 1);
+                this.markDirty();
+            }
+            return;
+        }
+        if (existingIndex >= 0) {
+            var existing = this.children[existingIndex];
+            if (existing instanceof CompatOnOffChild) {
+                existing.write(value);
+                this.markDirty();
+            }
+            return;
+        }
+        // Schema order places legacy OnOff flags before `compatSetting` list.
+        var insertAt = this.children.length;
+        for (var index = 0; index < this.children.length; index += 1) {
+            if (this.children[index] instanceof CompatSetting) {
+                insertAt = index;
+                break;
+            }
+        }
+        this.children.splice(insertAt, 0, new CompatOnOffChild(localName, value));
+        this.markDirty();
+    };
+    /**
+     * `w:compatSetting` entries in document order.
+     *
+     * @private
+     */
+    CompatSettings.prototype.settings = function () {
+        var e_3, _a;
+        var out = [];
+        try {
+            for (var _b = __values(this.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (child instanceof CompatSetting) {
+                    out.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 out;
+    };
+    /**
+     * Names from `w:compatSetting/@w:name`, in document order (empty names skipped).
+     *
+     * @private
+     */
+    CompatSettings.prototype.settingNames = function () {
+        var e_4, _a;
+        var names = [];
+        try {
+            for (var _b = __values(this.settings()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var setting = _c.value;
+                var name_1 = setting.name();
+                if (name_1 !== undefined && name_1.length > 0) {
+                    names.push(name_1);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return names;
+    };
+    /**
+     * Count of `w:compatSetting` children.
+     *
+     * @private
+     */
+    CompatSettings.prototype.settingCount = function () {
+        return this.settings().length;
+    };
+    /**
+     * Returns the `w:val` of the first `w:compatSetting` matching `name`, or
+     * `undefined` when not found.
+     *
+     * @private
+     */
+    CompatSettings.prototype.setting = function (name) {
+        var e_5, _a;
+        try {
+            for (var _b = __values(this.settings()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var s = _c.value;
+                if (s.name() === name)
+                    return s.val();
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return undefined;
+    };
+    /**
+     * Word compatibility mode from
+     * `w:compat` / `w:compatSetting[@w:name='compatibilityMode']/@w:val`.
+     *
+     * Reports the document’s declared compatibility engine level when present.
+     * Common values:
+     * - `"15"` — Word 2013 and later
+     * - `"14"` — Word 2010
+     * - `"12"` — Word 2007
+     *
+     * Returns `undefined` when the setting is absent. This method does not change
+     * layout or feature behavior; it only reads the stored attribute value.
+     *
+     * @returns Compatibility mode string, or `undefined` if not set.
+     *
+     * @example
+     * ```ts
+     * const settings = settingsFor(document);
+     * const mode = settings.compat()?.compatibilityMode();
+     * // "15" for typical Word 2013+ documents
+     * ```
+     *
+     * @public
+     */
+    CompatSettings.prototype.compatibilityMode = function () {
+        return this.setting('compatibilityMode');
+    };
+    /**
+     * Set or replace the first `w:compatSetting[@w:name='compatibilityMode']`.
+     *
+     * Uses Microsoft Office Word URI and preserves other compat settings / order.
+     * Creates a new entry at the end of the settings list when absent.
+     *
+     * @param value Wire token (`"12"` | `"14"` | `"15"`) or {@link CompatibilityMode}.
+     * @private
+     */
+    CompatSettings.prototype.setCompatibilityMode = function (value) {
+        var wire = typeof value === 'string' ? value : value;
+        var existingIndex = this.children.findIndex(function (child) { return child instanceof CompatSetting && child.name() === 'compatibilityMode'; });
+        var entry = CompatSetting.create('compatibilityMode', WORD_COMPAT_URI, wire);
+        if (existingIndex >= 0) {
+            this.children[existingIndex] = entry;
+        }
+        else {
+            this.children.push(entry);
+        }
+        this.markDirty();
+    };
+    /**
+     * Whether multi-column section content should **not** be balanced across columns
+     * (`w:compat/w:noColumnBalance`, `CT_OnOff`, ECMA-376 Part 4 transitional
+     * migration features).
+     *
+     * When the element is present and on (`true`, including bare element with no
+     * `w:val`), consumers should fill columns top-to-bottom sequentially instead of
+     * balancing line heights across columns. When absent, Word’s default is to
+     * **balance** multi-column content (this method returns `undefined`).
+     *
+     * This library stores and round-trips the flag only; it does not implement a
+     * layout engine. Column geometry remains on section properties
+     * (`SectionProperties.textColumns` / `equalWidthColumns`).
+     *
+     * @returns `true`/`false` when the element is present; `undefined` when absent.
+     *
+     * @example
+     * ```ts
+     * const compat = settingsFor(document).compat();
+     * if (compat?.noColumnBalance() === true) {
+     *   // sequential column fill requested
+     * }
+     * ```
+     *
+     * @private
+     */
+    CompatSettings.prototype.noColumnBalance = function () {
+        var child = this.findOnOff('noColumnBalance');
+        return child === undefined ? undefined : child.read();
+    };
+    /**
+     * Set or clear `w:compat/w:noColumnBalance`.
+     *
+     * - `true` — emit bare `w:noColumnBalance` (OnOff true)
+     * - `false` — emit `w:noColumnBalance w:val="0"` / false form via serializeOnOff
+     * - `undefined` — remove the element
+     *
+     * Marks the owning settings part dirty when a dirty callback is bound.
+     *
+     * @private
+     */
+    CompatSettings.prototype.setNoColumnBalance = function (value) {
+        this.setOnOff('noColumnBalance', value);
+    };
+    /**
+     * Creates the default Word-2013 compat settings block.
+     *
+     * Matches the `w:compat` element emitted by Microsoft Word for new documents:
+     * `compatibilityMode=15`, `overrideTableStyleFontSizeAndJustification=1`,
+     * `enableOpenTypeFeatures=1`, `doNotFlipMirrorIndents=1`,
+     * `differentiateMultirowTableHeaders=1`.
+     *
+     * @private
+     */
+    CompatSettings.createDefault = function () {
+        var children = [
+            CompatSetting.create('compatibilityMode', WORD_COMPAT_URI, CompatibilityMode.Word2013),
+            CompatSetting.create('overrideTableStyleFontSizeAndJustification', WORD_COMPAT_URI, '1'),
+            CompatSetting.create('enableOpenTypeFeatures', WORD_COMPAT_URI, '1'),
+            CompatSetting.create('doNotFlipMirrorIndents', WORD_COMPAT_URI, '1'),
+            CompatSetting.create('differentiateMultirowTableHeaders', WORD_COMPAT_URI, '1'),
+        ];
+        return new CompatSettings(children, [], []);
+    };
+    /**
+     * @private
+     */
+    CompatSettings.prototype.serialize = function () {
+        return wmlElement('compat', __assign({ attributes: this.attributes, children: this.children.map(function (child) { return child.serialize(); }) }, (this.namespaceDeclarations.length > 0
+            ? { namespaceDeclarations: this.namespaceDeclarations }
+            : {})));
+    };
+    return CompatSettings;
+}());
+export { CompatSettings };

package/src/features/settings/document-background.d.ts

@@ -0,0 +1,59 @@
+import { WordDocument } from '../document/document';
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * Main Document page background metadata (`w:document/w:background`).
+ *
+ * @private
+ */
+export declare class Background {
+    private readonly metadata;
+    private readonly displayBackgroundShapeValue;
+    /**
+     * @private
+     */
+    constructor(background: OpenXmlElement | undefined, displayBackgroundShapeValue: boolean | undefined);
+    /**
+     * Whether `w:background` was present on the Main Document.
+     *
+     * @public
+     */
+    present(): boolean;
+    /**
+     * `w:background/@w:color`, or `undefined` when absent.
+     *
+     * @public
+     */
+    color(): string | undefined;
+    /**
+     * `w:background/@w:themeColor`, or `undefined` when absent.
+     *
+     * @public
+     */
+    themeColor(): string | undefined;
+    /**
+     * `w:background/@w:themeTint`, or `undefined` when absent.
+     *
+     * @public
+     */
+    themeTint(): string | undefined;
+    /**
+     * `w:background/@w:themeShade`, or `undefined` when absent.
+     *
+     * @public
+     */
+    themeShade(): string | undefined;
+    /**
+     * Whether a `w:drawing` child exists under `w:background`.
+     *
+     * @public
+     */
+    hasDrawing(): boolean;
+    /**
+     * `w:settings/w:displayBackgroundShape`, or `undefined` when absent.
+     *
+     * @public
+     */
+    displayBackgroundShape(): boolean | undefined;
+}
+/** @public */
+export declare function createBackground(document: WordDocument, displayBackgroundShapeValue: boolean | undefined): Background;

package/src/features/settings/document-background.js

@@ -0,0 +1,131 @@
+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 } from '../document/wml';
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+function wmlAttribute(element, localName) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === WML_TRANSITIONAL_NAMESPACE || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function parseBackgroundMetadata(background) {
+    var e_1, _a;
+    if (background === undefined || !isWml(background, 'background')) {
+        return {
+            present: false,
+            color: undefined,
+            themeColor: undefined,
+            themeTint: undefined,
+            themeShade: undefined,
+            hasDrawing: false,
+        };
+    }
+    var hasDrawing = false;
+    try {
+        for (var _b = __values(elementChildren(background)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'drawing')) {
+                hasDrawing = true;
+                break;
+            }
+        }
+    }
+    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 {
+        present: true,
+        color: wmlAttribute(background, 'color'),
+        themeColor: wmlAttribute(background, 'themeColor'),
+        themeTint: wmlAttribute(background, 'themeTint'),
+        themeShade: wmlAttribute(background, 'themeShade'),
+        hasDrawing: hasDrawing,
+    };
+}
+/**
+ * Main Document page background metadata (`w:document/w:background`).
+ *
+ * @private
+ */
+var Background = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Background(background, displayBackgroundShapeValue) {
+        this.metadata = parseBackgroundMetadata(background);
+        this.displayBackgroundShapeValue = displayBackgroundShapeValue;
+    }
+    /**
+     * Whether `w:background` was present on the Main Document.
+     *
+     * @public
+     */
+    Background.prototype.present = function () {
+        return this.metadata.present;
+    };
+    /**
+     * `w:background/@w:color`, or `undefined` when absent.
+     *
+     * @public
+     */
+    Background.prototype.color = function () {
+        return this.metadata.color;
+    };
+    /**
+     * `w:background/@w:themeColor`, or `undefined` when absent.
+     *
+     * @public
+     */
+    Background.prototype.themeColor = function () {
+        return this.metadata.themeColor;
+    };
+    /**
+     * `w:background/@w:themeTint`, or `undefined` when absent.
+     *
+     * @public
+     */
+    Background.prototype.themeTint = function () {
+        return this.metadata.themeTint;
+    };
+    /**
+     * `w:background/@w:themeShade`, or `undefined` when absent.
+     *
+     * @public
+     */
+    Background.prototype.themeShade = function () {
+        return this.metadata.themeShade;
+    };
+    /**
+     * Whether a `w:drawing` child exists under `w:background`.
+     *
+     * @public
+     */
+    Background.prototype.hasDrawing = function () {
+        return this.metadata.hasDrawing;
+    };
+    /**
+     * `w:settings/w:displayBackgroundShape`, or `undefined` when absent.
+     *
+     * @public
+     */
+    Background.prototype.displayBackgroundShape = function () {
+        return this.displayBackgroundShapeValue;
+    };
+    return Background;
+}());
+export { Background };
+/** @public */
+export function createBackground(document, displayBackgroundShapeValue) {
+    return new Background(document.preservedBackground(), displayBackgroundShapeValue);
+}