@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/properties/index.js

@@ -0,0 +1,549 @@
+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 { DocxError } from '../../core/errors/docx-error';
+import { allocateRelationshipId } from '../../core/opc/relationships';
+import { partName } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeaturePackagePartHandler, } from '../../core/registry/index';
+import { findPackageRelatedPart, replaceOrAddPackageLevelPart, usedPackageRelationshipIds } from '../../core/registry/package-part-handlers';
+import { parseXml, serializeXml } from '../../core/xml/index';
+var PROPERTIES = featureId('properties');
+/**
+ * @private
+ * Package core properties relationship (ECMA-376-2 §11). */
+export var CORE_PROPERTIES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties';
+/**
+ * @private
+ * Extended properties relationship (ECMA-376-1 §15.2.12.3). */
+export var EXTENDED_PROPERTIES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties';
+/**
+ * @private
+ * Custom properties relationship (ECMA-376-1 §15.2.12.2). */
+export var CUSTOM_PROPERTIES_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties';
+/**
+ * @private
+ * ECMA-376-2 core properties content type. */
+export var CORE_PROPERTIES_CONTENT_TYPE = 'application/vnd.openxmlformats-package.core-properties+xml';
+/**
+ * @private
+ * ECMA-376-1 extended properties content type. */
+export var EXTENDED_PROPERTIES_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.extended-properties+xml';
+/**
+ * @private
+ * ECMA-376-1 custom properties content type. */
+export var CUSTOM_PROPERTIES_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.custom-properties+xml';
+/**
+ * @private
+ */
+export var CORE_PROPERTIES_PART_NAME = partName('/docProps/core.xml');
+/**
+ * @private
+ */
+export var EXTENDED_PROPERTIES_PART_NAME = partName('/docProps/app.xml');
+/**
+ * @private
+ */
+export var CUSTOM_PROPERTIES_PART_NAME = partName('/docProps/custom.xml');
+var CORE_NS = 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties';
+var DC_NS = 'http://purl.org/dc/elements/1.1/';
+var DCTERMS_NS = 'http://purl.org/dc/terms/';
+var XSI_NS = 'http://www.w3.org/2001/XMLSchema-instance';
+var utf8Decoder = new TextDecoder('utf-8');
+var utf8 = new TextEncoder();
+function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+function textContent(el) {
+    var e_1, _a;
+    var out = '';
+    try {
+        for (var _b = __values(el.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'text') {
+                out += child.value;
+            }
+        }
+    }
+    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 out;
+}
+function isCoreElement(el, localName) {
+    return el.namespaceUri === CORE_NS && el.localName === localName;
+}
+function isDcElement(el, localName) {
+    return el.namespaceUri === DC_NS && el.localName === localName;
+}
+function coreElement(localName, text) {
+    return {
+        kind: 'element',
+        namespaceUri: CORE_NS,
+        localName: localName,
+        prefix: '',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: text.length > 0 ? [{ kind: 'text', value: text }] : [],
+    };
+}
+function dcElement(localName, text) {
+    return {
+        kind: 'element',
+        namespaceUri: DC_NS,
+        localName: localName,
+        prefix: 'dc',
+        attributes: [],
+        namespaceDeclarations: [],
+        children: text.length > 0 ? [{ kind: 'text', value: text }] : [],
+    };
+}
+/**
+ * In-memory core file properties (`docProps/core.xml`).
+ * Package infrastructure used by document-level property helpers; not a public
+ * mutation surface. Prefer `documentTitle` / `setDocumentTitle` and siblings.
+ *
+ * @private
+ */
+var CoreProperties = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CoreProperties(rootAttributes, rootNamespaceDeclarations, opaque, title, creator, subject, description, keywords, dirty) {
+        this.rootAttributes = rootAttributes;
+        this.rootNamespaceDeclarations = rootNamespaceDeclarations;
+        this.opaque = opaque;
+        this.titleValue = title;
+        this.creatorValue = creator;
+        this.subjectValue = subject;
+        this.descriptionValue = description;
+        this.keywordsValue = keywords;
+        this.dirty = dirty;
+    }
+    Object.defineProperty(CoreProperties.prototype, "title", {
+        /**
+         * @private
+       * Dublin Core title (`dc:title`), if present. */
+        get: function () {
+            return this.titleValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.titleValue = value;
+            this.dirty = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CoreProperties.prototype, "creator", {
+        /**
+         * @private
+       * Dublin Core creator (`dc:creator`), if present. */
+        get: function () {
+            return this.creatorValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.creatorValue = value;
+            this.dirty = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CoreProperties.prototype, "subject", {
+        /**
+         * @private
+       * Dublin Core subject (`dc:subject`), if present. */
+        get: function () {
+            return this.subjectValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.subjectValue = value;
+            this.dirty = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CoreProperties.prototype, "description", {
+        /**
+         * @private
+       * Dublin Core description (`dc:description`), if present. */
+        get: function () {
+            return this.descriptionValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.descriptionValue = value;
+            this.dirty = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CoreProperties.prototype, "keywords", {
+        /**
+         * @private
+       * Core keywords (`cp:keywords`), if present. */
+        get: function () {
+            return this.keywordsValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.keywordsValue = value;
+            this.dirty = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    CoreProperties.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    CoreProperties.prototype.markClean = function () {
+        this.dirty = false;
+    };
+    /**
+     * @private
+     */
+    CoreProperties.prototype.serialize = function () {
+        var children = [];
+        if (this.creatorValue !== undefined) {
+            children.push(dcElement('creator', this.creatorValue));
+        }
+        if (this.titleValue !== undefined) {
+            children.push(dcElement('title', this.titleValue));
+        }
+        if (this.subjectValue !== undefined) {
+            children.push(dcElement('subject', this.subjectValue));
+        }
+        if (this.descriptionValue !== undefined) {
+            children.push(dcElement('description', this.descriptionValue));
+        }
+        if (this.keywordsValue !== undefined) {
+            children.push(coreElement('keywords', this.keywordsValue));
+        }
+        children.push.apply(children, __spread(this.opaque));
+        var root = {
+            kind: 'element',
+            namespaceUri: CORE_NS,
+            localName: 'coreProperties',
+            prefix: '',
+            attributes: this.rootAttributes,
+            namespaceDeclarations: this.rootNamespaceDeclarations.length > 0
+                ? this.rootNamespaceDeclarations
+                : [
+                    { prefix: '', namespaceUri: CORE_NS },
+                    { prefix: 'dc', namespaceUri: DC_NS },
+                    { prefix: 'dcterms', namespaceUri: DCTERMS_NS },
+                    { prefix: 'xsi', namespaceUri: XSI_NS },
+                ],
+            children: children,
+        };
+        return utf8.encode(serializeXml(root));
+    };
+    return CoreProperties;
+}());
+export { CoreProperties };
+function parseCoreProperties(bytes) {
+    var e_2, _a;
+    if (bytes === undefined) {
+        return new CoreProperties([], [], [], undefined, undefined, undefined, undefined, undefined, false);
+    }
+    var root = parseXml(utf8Decoder.decode(bytes));
+    if (root.localName !== 'coreProperties' || root.namespaceUri !== CORE_NS) {
+        return new CoreProperties([], [], [], undefined, undefined, undefined, undefined, undefined, false);
+    }
+    var opaque = [];
+    var title;
+    var creator;
+    var subject;
+    var description;
+    var keywords;
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isDcElement(child, 'title') && title === undefined) {
+                title = textContent(child);
+                continue;
+            }
+            if (isDcElement(child, 'creator') && creator === undefined) {
+                creator = textContent(child);
+                continue;
+            }
+            if (isDcElement(child, 'subject') && subject === undefined) {
+                subject = textContent(child);
+                continue;
+            }
+            if (isDcElement(child, 'description') && description === undefined) {
+                description = textContent(child);
+                continue;
+            }
+            if (isCoreElement(child, 'keywords') && keywords === undefined) {
+                keywords = textContent(child);
+                continue;
+            }
+            if (isDcElement(child, 'title') ||
+                isDcElement(child, 'creator') ||
+                isDcElement(child, 'subject') ||
+                isDcElement(child, 'description') ||
+                isCoreElement(child, 'keywords')) {
+                continue;
+            }
+            opaque.push(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 new CoreProperties(root.attributes, root.namespaceDeclarations, opaque, title, creator, subject, description, keywords, false);
+}
+/**
+ * File properties parts for a document package.
+ *
+ * @private
+ */
+var PropertiesParts = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function PropertiesParts(core, corePartName, coreRelationshipId) {
+        this.coreValue = core;
+        this.corePartName = corePartName;
+        this.coreRelationshipId = coreRelationshipId;
+        this.corePendingRelationship = undefined;
+    }
+    Object.defineProperty(PropertiesParts.prototype, "core", {
+        /** Core Dublin Core properties. */
+        get: function () {
+            return this.coreValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PropertiesParts.prototype.isDirty = function () {
+        return this.coreValue.isDirty();
+    };
+    /**
+     * @private
+     */
+    PropertiesParts.prototype.ensureCorePart = function (pkg) {
+        if (this.coreRelationshipId !== undefined) {
+            return;
+        }
+        var usedRelIds = usedPackageRelationshipIds(pkg);
+        var relId = allocateRelationshipId(usedRelIds);
+        while (usedRelIds.has(relId)) {
+            relId = allocateRelationshipId(new Set(__spread(usedRelIds, [relId])));
+        }
+        this.corePartName = CORE_PROPERTIES_PART_NAME;
+        this.coreRelationshipId = relId;
+        this.corePendingRelationship = {
+            id: relId,
+            type: CORE_PROPERTIES_RELATIONSHIP_TYPE,
+            target: 'docProps/core.xml',
+            extraAttributes: [],
+            children: [],
+        };
+    };
+    /**
+     * @private
+     */
+    PropertiesParts.prototype.applyToPackage = function (pkg) {
+        var _this = this;
+        if (!this.coreValue.isDirty() && this.corePendingRelationship === undefined) {
+            return pkg;
+        }
+        var next = replaceOrAddPackageLevelPart(pkg, this.corePartName, CORE_PROPERTIES_CONTENT_TYPE, this.coreValue.serialize(), this.corePendingRelationship != null ? this.corePendingRelationship : (this.coreRelationshipId === undefined
+            ? undefined
+            : pkg.packageRelationships.items.find(function (item) { return item.id === _this.coreRelationshipId; })));
+        this.coreValue.markClean();
+        this.corePendingRelationship = undefined;
+        return next;
+    };
+    return PropertiesParts;
+}());
+export { PropertiesParts };
+function loadPropertiesParts(pkg) {
+    var coreRelated = findPackageRelatedPart(pkg, CORE_PROPERTIES_RELATIONSHIP_TYPE);
+    // Empty packages (Document.create) have no core-properties relationship yet.
+    // parseCoreProperties already accepts missing bytes and returns a clean shell.
+    var core = parseCoreProperties(coreRelated === undefined ? undefined : coreRelated.part.data);
+    var corePartName = coreRelated === undefined ? CORE_PROPERTIES_PART_NAME : coreRelated.part.name;
+    var coreRelationshipId = coreRelated === undefined ? undefined : coreRelated.relationship.id;
+    return new PropertiesParts(core, corePartName, coreRelationshipId);
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetPropertiesFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register the file properties package-part handler. Idempotent. */
+export function registerPropertiesFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: PROPERTIES });
+    registerFeaturePackagePartHandler({
+        featureId: PROPERTIES,
+        loadParts: function (pkg, ctx) {
+            void ctx;
+            return loadPropertiesParts(pkg);
+        },
+    });
+}
+/**
+ * File properties for a document. Requires {@link registerPropertiesFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered before load.
+ * @private
+ */
+export function propertiesFor(document) {
+    var part = document.featurePart(PROPERTIES);
+    if (part === undefined || !(part instanceof PropertiesParts)) {
+        throw new DocxError('feature/not-registered', 'Properties parts were not loaded; call registerPropertiesFeature() before WordDocument.open');
+    }
+    return part;
+}
+function mutateCore(document, apply) {
+    var properties = propertiesFor(document);
+    apply(properties.core);
+    properties.ensureCorePart(document.opcPackage());
+}
+/**
+ * WordDocument title (`dc:title`).
+ * @private
+ */
+export function documentTitle(document) {
+    return propertiesFor(document).core.title;
+}
+/**
+ * Set document title (`dc:title`).
+ * @private
+ */
+export function setDocumentTitle(document, title) {
+    mutateCore(document, function (core) {
+        core.title = title;
+    });
+}
+/**
+ * WordDocument creator (`dc:creator`).
+ * @private
+ */
+export function documentCreator(document) {
+    return propertiesFor(document).core.creator;
+}
+/**
+ * Set document creator (`dc:creator`).
+ * @private
+ */
+export function setDocumentCreator(document, creator) {
+    mutateCore(document, function (core) {
+        core.creator = creator;
+    });
+}
+/**
+ * WordDocument subject (`dc:subject`).
+ * @private
+ */
+export function documentSubject(document) {
+    return propertiesFor(document).core.subject;
+}
+/**
+ * Set document subject (`dc:subject`).
+ * @private
+ */
+export function setDocumentSubject(document, subject) {
+    mutateCore(document, function (core) {
+        core.subject = subject;
+    });
+}
+/**
+ * WordDocument description (`dc:description`).
+ * @private
+ */
+export function documentDescription(document) {
+    return propertiesFor(document).core.description;
+}
+/**
+ * Set document description (`dc:description`).
+ * @private
+ */
+export function setDocumentDescription(document, description) {
+    mutateCore(document, function (core) {
+        core.description = description;
+    });
+}
+/**
+ * WordDocument keywords (`keywords`).
+ * @private
+ */
+export function documentKeywords(document) {
+    return propertiesFor(document).core.keywords;
+}
+/**
+ * Set document keywords (`keywords`).
+ * @private
+ */
+export function setDocumentKeywords(document, keywords) {
+    mutateCore(document, function (core) {
+        core.keywords = keywords;
+    });
+}
+registerPropertiesFeature();