@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

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

@@ -0,0 +1,65 @@
+/**
+ * `w:documentProtection` DOM (`CT_DocProtect`, Transitional `wml.xsd`).
+ *
+ * Modeled flags: `edit` / `formatting` / `enforcement`. Password and hash attributes
+ * (`AG_Password` / `AG_TransitionalPassword`) are preserved on flag-only updates and
+ * dropped only when the element is removed.
+ *
+ * @private
+ */
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * `ST_DocProtect` (Transitional `wml.xsd`). *
+ * @private
+ */
+export declare type DocumentProtectionEdit = 'none' | 'readOnly' | 'comments' | 'trackedChanges' | 'forms';
+/**
+ * Modeled `w:documentProtection` flags. Password/hash attributes are not included.
+ *
+ * @private
+ */
+export declare type DocumentProtectionFlags = {
+    readonly edit?: DocumentProtectionEdit;
+    readonly formatting?: boolean;
+    readonly enforcement?: boolean;
+};
+/**
+ * First-class `w:documentProtection` node.
+ *
+ * Kept public because {@link SettingsPart.documentProtectionNode} returns it (R7.3).
+ *
+ * @private
+ */
+export declare class DocumentProtection {
+    private edit;
+    private formatting;
+    private enforcement;
+    private leftoverAttributes;
+    private readonly elementChildren;
+    private readonly namespaceDeclarations;
+    private constructor();
+    /**
+     * @private
+   * Parse from a `w:documentProtection` element. */
+    static fromElement(element: OpenXmlElement): DocumentProtection;
+    /**
+     * @private
+   * Build from modeled flags only (create path). */
+    static fromFlags(flags: DocumentProtectionFlags): DocumentProtection;
+    /**
+     * Snapshot of modeled flags (password/hash attrs omitted).
+     *
+     * @public
+     */
+    flags(): DocumentProtectionFlags;
+    /**
+     * Replace modeled flags; leftover password/hash attributes are kept.
+     *
+     * @private
+     */
+    applyFlags(flags: DocumentProtectionFlags): void;
+    /**
+     * @private
+     */
+    serialize(): OpenXmlElement;
+}

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

@@ -0,0 +1,157 @@
+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;
+};
+/**
+ * `w:documentProtection` DOM (`CT_DocProtect`, Transitional `wml.xsd`).
+ *
+ * Modeled flags: `edit` / `formatting` / `enforcement`. Password and hash attributes
+ * (`AG_Password` / `AG_TransitionalPassword`) are preserved on flag-only updates and
+ * dropped only when the element is removed.
+ *
+ * @private
+ */
+import { WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { wmlAttr, wmlElement } from '../document/wml';
+var MODELED_PROTECTION_ATTRS = new Set(['edit', 'formatting', 'enforcement']);
+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 parseOnOffAttribute(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return undefined;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function onOffAttribute(localName, value) {
+    return wmlAttr(localName, value ? 'true' : 'false');
+}
+function parseProtectionEdit(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    switch (raw) {
+        case 'none':
+        case 'readOnly':
+        case 'comments':
+        case 'trackedChanges':
+        case 'forms':
+            return raw;
+        default:
+            return undefined;
+    }
+}
+/**
+ * First-class `w:documentProtection` node.
+ *
+ * Kept public because {@link SettingsPart.documentProtectionNode} returns it (R7.3).
+ *
+ * @private
+ */
+var DocumentProtection = /** @class */ (function () {
+    function DocumentProtection(edit, formatting, enforcement, leftoverAttributes, elementChildren, namespaceDeclarations) {
+        this.edit = edit;
+        this.formatting = formatting;
+        this.enforcement = enforcement;
+        this.leftoverAttributes = leftoverAttributes;
+        this.elementChildren = elementChildren;
+        this.namespaceDeclarations = namespaceDeclarations;
+    }
+    /**
+     * @private
+   * Parse from a `w:documentProtection` element. */
+    DocumentProtection.fromElement = function (element) {
+        var leftover = element.attributes.filter(function (attribute) { return !MODELED_PROTECTION_ATTRS.has(attribute.localName); });
+        return new DocumentProtection(parseProtectionEdit(wmlAttribute(element, 'edit')), parseOnOffAttribute(wmlAttribute(element, 'formatting')), parseOnOffAttribute(wmlAttribute(element, 'enforcement')), leftover, __spread(element.children), element.namespaceDeclarations);
+    };
+    /**
+     * @private
+   * Build from modeled flags only (create path). */
+    DocumentProtection.fromFlags = function (flags) {
+        return new DocumentProtection(flags.edit, flags.formatting, flags.enforcement, [], [], []);
+    };
+    /**
+     * Snapshot of modeled flags (password/hash attrs omitted).
+     *
+     * @public
+     */
+    DocumentProtection.prototype.flags = function () {
+        var out = {};
+        if (this.edit !== undefined) {
+            out.edit = this.edit;
+        }
+        if (this.formatting !== undefined) {
+            out.formatting = this.formatting;
+        }
+        if (this.enforcement !== undefined) {
+            out.enforcement = this.enforcement;
+        }
+        return out;
+    };
+    /**
+     * Replace modeled flags; leftover password/hash attributes are kept.
+     *
+     * @private
+     */
+    DocumentProtection.prototype.applyFlags = function (flags) {
+        this.edit = flags.edit;
+        this.formatting = flags.formatting;
+        this.enforcement = flags.enforcement;
+    };
+    /**
+     * @private
+     */
+    DocumentProtection.prototype.serialize = function () {
+        var modeled = [];
+        if (this.edit !== undefined) {
+            modeled.push(wmlAttr('edit', this.edit));
+        }
+        if (this.formatting !== undefined) {
+            modeled.push(onOffAttribute('formatting', this.formatting));
+        }
+        if (this.enforcement !== undefined) {
+            modeled.push(onOffAttribute('enforcement', this.enforcement));
+        }
+        return wmlElement('documentProtection', __assign({ attributes: __spread(modeled, this.leftoverAttributes), children: this.elementChildren }, (this.namespaceDeclarations.length > 0
+            ? { namespaceDeclarations: this.namespaceDeclarations }
+            : {})));
+    };
+    return DocumentProtection;
+}());
+export { DocumentProtection };

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

@@ -0,0 +1,108 @@
+import { WordDocument } from '../document/document';
+import { AttachedTemplate } from './attached-template';
+import { CompatibilityMode } from './compat-settings';
+import { DocumentViewType } from './settings-children';
+import { ZoomSettings, ZoomType } from './zoom';
+/** Minimal SettingsPart surface used by public facades. */
+export interface SettingsPartFacadeHost {
+    trackRevisions(): boolean | undefined;
+    setTrackRevisions(value: boolean | undefined): void;
+    defaultTabStop(): number | undefined;
+    setDefaultTabStop(value: number | undefined): void;
+    view(): {
+        asDocumentViewType(): DocumentViewType | undefined;
+    } | undefined;
+    setView(value: DocumentViewType | string | undefined): void;
+    zoom(): ZoomSettings | undefined;
+    setZoom(value: ZoomSettings | undefined): void;
+    compatibilityMode(): string | undefined;
+    setCompatibilityMode(value: CompatibilityMode | string): void;
+    displayBackgroundShape(): boolean | undefined;
+    setDisplayBackgroundShape(value: boolean | undefined): void;
+    attachedTemplate(): AttachedTemplate | undefined;
+}
+/**
+ * Bind SettingsPart accessors from the settings feature entry (call once after
+ * `settingsFor` is defined).
+ *
+ * @private
+ */
+export declare function bindDocumentSettingsFacades(deps: {
+    settingsFor: (document: WordDocument) => SettingsPartFacadeHost;
+    registerSettingsFeature: () => void;
+    attachedTemplateTarget: (document: WordDocument) => string | undefined;
+}): void;
+/**
+ * Document view and zoom configuration (`w:view`, `w:zoom`).
+ *
+ * @public
+ */
+export declare class ViewSetup {
+    private readonly document;
+    /**
+     * @private
+     */
+    constructor(document: WordDocument);
+    /**
+     * Gets or sets the view used when the document is opened in Microsoft Word.
+     *
+     * @public
+     */
+    documentViewType: DocumentViewType;
+    /**
+     * Gets or sets how the document view is fitted in the application window.
+     *
+     * @public
+     */
+    zoomType: ZoomType;
+    /**
+     * Gets or sets the document zoom percentage.
+     *
+     * @public
+     */
+    zoomPercent: number;
+}
+/**
+ * Focused document compatibility and display settings.
+ *
+ * @public
+ */
+export declare class DocumentSettings {
+    private readonly document;
+    /**
+     * @private
+     */
+    constructor(document: WordDocument);
+    /**
+     * Gets or sets the Word compatibility mode for this document.
+     *
+     * @public
+     */
+    compatibilityMode: CompatibilityMode;
+    /**
+     * Gets or sets whether document background shapes are displayed
+     * (`w:displayBackgroundShape`).
+     *
+     * @public
+     */
+    displayBackgrounds: boolean;
+}
+/**
+ * Stable {@link ViewSetup} for `document`.
+ *
+ * @private
+ */
+export declare function viewSetupFor(document: WordDocument): ViewSetup;
+/**
+ * Stable {@link DocumentSettings} for `document`.
+ *
+ * @private
+ */
+export declare function documentSettingsFor(document: WordDocument): DocumentSettings;
+/**
+ * Install WordDocument property facades for settings-backed members.
+ * Idempotent; call from the settings feature entry after binding accessors.
+ *
+ * @private
+ */
+export declare function registerDocumentSettingsFacades(): void;

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

@@ -0,0 +1,312 @@
+/**
+ * Public property facades over SettingsPart: {@link ViewSetup} and
+ * {@link DocumentSettings}. Stable per-{@link WordDocument} identity via WeakMap.
+ *
+ * Linked from `settings/index.ts` after {@link settingsFor} is defined (avoids cycle).
+ *
+ * @private
+ */
+import { InvalidArgumentError } from '../../core/errors/docx-error';
+import { WordDocument } from '../document/document';
+import { CompatibilityMode } from './compat-settings';
+import { DocumentViewType } from './settings-children';
+import { ZoomSettings, ZoomType } from './zoom';
+/** Default `w:view` when the element is absent (Word print layout). */
+var DEFAULT_DOCUMENT_VIEW = DocumentViewType.PrintLayout;
+/** Default zoom percent when `w:zoom` is absent (matches createDefault). */
+var DEFAULT_ZOOM_PERCENT = 100;
+/** Default tab stop in points when `w:defaultTabStop` is absent (0.5 in). */
+var DEFAULT_TAB_STOP_POINTS = 36;
+function requireFiniteNonNegative(name, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new InvalidArgumentError(name + " must be a finite non-negative number");
+    }
+}
+function zoomTypeFromWire(wire) {
+    if (wire === undefined) {
+        return ZoomType.None;
+    }
+    switch (wire) {
+        case 'none':
+            return ZoomType.None;
+        case 'fullPage':
+            return ZoomType.FullPage;
+        case 'bestFit':
+            return ZoomType.BestFit;
+        case 'textFit':
+            return ZoomType.TextFit;
+        default:
+            return ZoomType.None;
+    }
+}
+function compatibilityModeFromWire(wire) {
+    if (wire === CompatibilityMode.Word2007) {
+        return CompatibilityMode.Word2007;
+    }
+    if (wire === CompatibilityMode.Word2010) {
+        return CompatibilityMode.Word2010;
+    }
+    if (wire === CompatibilityMode.Word2013) {
+        return CompatibilityMode.Word2013;
+    }
+    // Absent or unknown → Word 2013 (createDefault / modern Word default).
+    return CompatibilityMode.Word2013;
+}
+var settingsForRef;
+var registerSettingsFeatureRef;
+var attachedTemplateTargetRef;
+/**
+ * Bind SettingsPart accessors from the settings feature entry (call once after
+ * `settingsFor` is defined).
+ *
+ * @private
+ */
+export function bindDocumentSettingsFacades(deps) {
+    settingsForRef = deps.settingsFor;
+    registerSettingsFeatureRef = deps.registerSettingsFeature;
+    attachedTemplateTargetRef = deps.attachedTemplateTarget;
+}
+function settingsFor(document) {
+    if (settingsForRef === undefined) {
+        throw new InvalidArgumentError('Document settings facades are not bound; load @syncfusion/ej2-docx settings feature first');
+    }
+    return settingsForRef(document);
+}
+/**
+ * Document view and zoom configuration (`w:view`, `w:zoom`).
+ *
+ * @public
+ */
+var ViewSetup = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ViewSetup(document) {
+        this.document = document;
+    }
+    Object.defineProperty(ViewSetup.prototype, "documentViewType", {
+        /**
+         * Gets or sets the view used when the document is opened in Microsoft Word.
+         *
+         * @public
+         */
+        get: function () {
+            var view = settingsFor(this.document).view();
+            if (view === undefined) {
+                return DEFAULT_DOCUMENT_VIEW;
+            }
+            var known = view.asDocumentViewType();
+            return known === undefined ? DEFAULT_DOCUMENT_VIEW : known;
+        },
+        set: function (value) {
+            settingsFor(this.document).setView(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ViewSetup.prototype, "zoomType", {
+        /**
+         * Gets or sets how the document view is fitted in the application window.
+         *
+         * @public
+         */
+        get: function () {
+            var zoom = settingsFor(this.document).zoom();
+            return zoomTypeFromWire(zoom === undefined ? undefined : zoom.type());
+        },
+        set: function (value) {
+            var part = settingsFor(this.document);
+            var existing = part.zoom();
+            if (existing === undefined) {
+                part.setZoom(ZoomSettings.create(DEFAULT_ZOOM_PERCENT, value));
+                return;
+            }
+            existing.setType(value);
+            part.setZoom(existing);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ViewSetup.prototype, "zoomPercent", {
+        /**
+         * Gets or sets the document zoom percentage.
+         *
+         * @public
+         */
+        get: function () {
+            var zoom = settingsFor(this.document).zoom();
+            if (zoom === undefined) {
+                return DEFAULT_ZOOM_PERCENT;
+            }
+            var percent = zoom.percent();
+            return percent === undefined ? DEFAULT_ZOOM_PERCENT : percent;
+        },
+        set: function (value) {
+            requireFiniteNonNegative('zoomPercent', value);
+            var part = settingsFor(this.document);
+            var existing = part.zoom();
+            if (existing === undefined) {
+                part.setZoom(ZoomSettings.create(value, ZoomType.None));
+                return;
+            }
+            existing.setPercent(value);
+            part.setZoom(existing);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ViewSetup;
+}());
+export { ViewSetup };
+/**
+ * Focused document compatibility and display settings.
+ *
+ * @public
+ */
+var DocumentSettings = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function DocumentSettings(document) {
+        this.document = document;
+    }
+    Object.defineProperty(DocumentSettings.prototype, "compatibilityMode", {
+        /**
+         * Gets or sets the Word compatibility mode for this document.
+         *
+         * @public
+         */
+        get: function () {
+            return compatibilityModeFromWire(settingsFor(this.document).compatibilityMode());
+        },
+        set: function (value) {
+            settingsFor(this.document).setCompatibilityMode(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentSettings.prototype, "displayBackgrounds", {
+        /**
+         * Gets or sets whether document background shapes are displayed
+         * (`w:displayBackgroundShape`).
+         *
+         * @public
+         */
+        get: function () {
+            var value = settingsFor(this.document).displayBackgroundShape();
+            return value === true;
+        },
+        set: function (value) {
+            // Omission represents the default (false); remove the element when false.
+            settingsFor(this.document).setDisplayBackgroundShape(value ? true : undefined);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return DocumentSettings;
+}());
+export { DocumentSettings };
+var viewSetups = new WeakMap();
+var documentSettingsMap = new WeakMap();
+/**
+ * Stable {@link ViewSetup} for `document`.
+ *
+ * @private
+ */
+export function viewSetupFor(document) {
+    if (registerSettingsFeatureRef !== undefined) {
+        registerSettingsFeatureRef();
+    }
+    var cached = viewSetups.get(document);
+    if (cached !== undefined) {
+        return cached;
+    }
+    var setup = new ViewSetup(document);
+    viewSetups.set(document, setup);
+    return setup;
+}
+/**
+ * Stable {@link DocumentSettings} for `document`.
+ *
+ * @private
+ */
+export function documentSettingsFor(document) {
+    if (registerSettingsFeatureRef !== undefined) {
+        registerSettingsFeatureRef();
+    }
+    var cached = documentSettingsMap.get(document);
+    if (cached !== undefined) {
+        return cached;
+    }
+    var settings = new DocumentSettings(document);
+    documentSettingsMap.set(document, settings);
+    return settings;
+}
+var facadesRegistered = false;
+/**
+ * Install WordDocument property facades for settings-backed members.
+ * Idempotent; call from the settings feature entry after binding accessors.
+ *
+ * @private
+ */
+export function registerDocumentSettingsFacades() {
+    if (facadesRegistered) {
+        return;
+    }
+    facadesRegistered = true;
+    if (registerSettingsFeatureRef !== undefined) {
+        registerSettingsFeatureRef();
+    }
+    Object.defineProperty(WordDocument.prototype, 'viewSetup', {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            return viewSetupFor(this);
+        },
+    });
+    Object.defineProperty(WordDocument.prototype, 'settings', {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            return documentSettingsFor(this);
+        },
+    });
+    Object.defineProperty(WordDocument.prototype, 'trackRevisions', {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            return settingsFor(this).trackRevisions() === true;
+        },
+        set: function (value) {
+            // Omission represents default off.
+            settingsFor(this).setTrackRevisions(value ? true : undefined);
+        },
+    });
+    Object.defineProperty(WordDocument.prototype, 'defaultTabStop', {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            var value = settingsFor(this).defaultTabStop();
+            return value === undefined ? DEFAULT_TAB_STOP_POINTS : value;
+        },
+        set: function (value) {
+            requireFiniteNonNegative('defaultTabStop', value);
+            settingsFor(this).setDefaultTabStop(value);
+        },
+    });
+    Object.defineProperty(WordDocument.prototype, 'attachedTemplate', {
+        configurable: true,
+        enumerable: false,
+        get: function () {
+            var template = settingsFor(this).attachedTemplate();
+            if (template === undefined) {
+                return undefined;
+            }
+            // Resolve relationship target when available (read-only surface).
+            if (attachedTemplateTargetRef !== undefined) {
+                void attachedTemplateTargetRef(this);
+            }
+            return template;
+        },
+    });
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Simple typed wrappers for `w:defaultTabStop` and `w:characterSpacingControl`
+ * (`CT_TwipsMeasure` and `ST_CharacterSpacing`, Transitional `wml.xsd`).
+ *
+ * @private
+ */
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * `ST_CharacterSpacing` values from Transitional `wml.xsd`.
+ *
+ * - `doNotCompress` — no compression
+ * - `compressPunctuation` — compress punctuation
+ * - `compressPunctuationAndJapaneseKana` — compress both
+ *
+ * @public
+ */
+export declare type CharacterSpacingControl = 'doNotCompress' | 'compressPunctuation' | 'compressPunctuationAndJapaneseKana';
+/**
+ * Parse `w:defaultTabStop/@w:val` (`ST_TwipsMeasure` on the wire) into plain points.
+ * Returns `undefined` when missing or non-numeric.
+ *
+ * @private
+ */
+export declare function parseDefaultTabStop(element: OpenXmlElement): number | undefined;
+/**
+ * Serialize `w:defaultTabStop` from a plain points value (writes twips on the wire).
+ *
+ * @private
+ */
+export declare function serializeDefaultTabStop(value: number): OpenXmlElement;
+/**
+ * Parse `w:characterSpacingControl/@w:val`.
+ * Returns `undefined` when missing or not a recognised value.
+ *
+ * @private
+ */
+export declare function parseCharacterSpacingControl(element: OpenXmlElement): CharacterSpacingControl | undefined;
+/**
+ * Serialize `w:characterSpacingControl` from a value.
+ *
+ * @private
+ */
+export declare function serializeCharacterSpacingControl(value: CharacterSpacingControl): OpenXmlElement;