@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/glossary/index.js

@@ -0,0 +1,286 @@
+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 { elementChildren, isWml } from '../document/wml';
+import { partName } from '../../core/opc/part-name';
+import { featureId, registerFeature, registerFeaturePartHandler, } from '../../core/registry/index';
+import { parseXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+var GLOSSARY = featureId('glossary');
+/**
+ * @private
+ * Transitional glossary document relationship (ECMA-376-4 §9.2.8). */
+export var GLOSSARY_DOCUMENT_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/glossaryDocument';
+/**
+ * @private
+ * Strict glossary document relationship (ECMA-376-1 §11.3.8). */
+export var STRICT_GLOSSARY_DOCUMENT_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/glossaryDocument';
+/**
+ * @private
+ * ECMA-376-1 §11.3.8 Glossary WordDocument content type. */
+export var GLOSSARY_DOCUMENT_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml';
+/**
+ * @private
+ */
+export var GLOSSARY_DOCUMENT_PART_NAME = partName('/glossary/document.xml');
+var utf8Decoder = new TextDecoder('utf-8');
+var EMPTY_METADATA = { docParts: [] };
+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 parseDocPartProperties(docPartPr) {
+    var e_1, _a, e_2, _b;
+    var name;
+    var category;
+    var gallery;
+    try {
+        for (var _c = __values(elementChildren(docPartPr)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (isWml(child, 'name')) {
+                name = wmlAttribute(child, 'val');
+                continue;
+            }
+            if (!isWml(child, 'category')) {
+                continue;
+            }
+            try {
+                for (var _e = __values(elementChildren(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var categoryChild = _f.value;
+                    if (isWml(categoryChild, 'name')) {
+                        category = wmlAttribute(categoryChild, 'val');
+                    }
+                    else if (isWml(categoryChild, 'gallery')) {
+                        gallery = wmlAttribute(categoryChild, 'val');
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (name === undefined || name.length === 0) {
+        return undefined;
+    }
+    return { name: name, category: category, gallery: gallery };
+}
+function parseDocPart(docPart) {
+    var e_3, _a;
+    try {
+        for (var _b = __values(elementChildren(docPart)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'docPartPr')) {
+                return parseDocPartProperties(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 undefined;
+}
+function parseGlossaryMetadata(root) {
+    var e_4, _a, e_5, _b;
+    if (!isWml(root, 'glossaryDocument')) {
+        return undefined;
+    }
+    var docParts = [];
+    try {
+        for (var _c = __values(elementChildren(root)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var child = _d.value;
+            if (!isWml(child, 'docParts')) {
+                continue;
+            }
+            try {
+                for (var _e = __values(elementChildren(child)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var docPart = _f.value;
+                    if (!isWml(docPart, 'docPart')) {
+                        continue;
+                    }
+                    var summary = parseDocPart(docPart);
+                    if (summary !== undefined) {
+                        docParts.push(summary);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return { docParts: docParts };
+}
+function parseGlossaryMetadataFromBytes(bytes) {
+    if (bytes.byteLength === 0) {
+        return undefined;
+    }
+    try {
+        var root = parseXml(utf8Decoder.decode(bytes));
+        return parseGlossaryMetadata(root);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+/**
+ * Preserve-only Glossary WordDocument part (`glossary/document.xml`).
+ * Building-block body content is opaque; name/category/gallery metadata is
+ * read-only catalog access. No building-block editor or mutation API is provided.
+ *
+ * @private
+ */
+var GlossaryDocumentPart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function GlossaryDocumentPart(bytes, metadata, dirty) {
+        this.bytes = bytes;
+        this.metadata = metadata;
+        this.dirty = dirty;
+    }
+    /**
+     * Whether the glossary part was present in the package.
+     *
+     * @public
+     */
+    GlossaryDocumentPart.prototype.present = function () {
+        return this.bytes !== undefined;
+    };
+    /**
+     * Count of `w:docParts/w:docPart` entries with a readable `w:name`.
+     *
+     * @public
+     */
+    GlossaryDocumentPart.prototype.docPartCount = function () {
+        return this.metadata.docParts.length;
+    };
+    /**
+     * `w:docPartPr/w:name/@w:val` values in document order.
+     *
+     * @public
+     */
+    GlossaryDocumentPart.prototype.docPartNames = function () {
+        return this.metadata.docParts.map(function (entry) { return entry.name; });
+    };
+    /**
+     * `w:category/w:name/@w:val` for a doc part name, or `undefined` when absent.
+     *
+     * @public
+     */
+    GlossaryDocumentPart.prototype.docPartCategory = function (name) {
+        var __ts33_0;
+        return ((__ts33_0 = this.metadata.docParts.find(function (entry) { return entry.name === name; })), __ts33_0 == null ? undefined : __ts33_0.category);
+    };
+    /**
+     * `w:category/w:gallery/@w:val` for a doc part name, or `undefined` when absent.
+     *
+     * @public
+     */
+    GlossaryDocumentPart.prototype.docPartGallery = function (name) {
+        var __ts33_1;
+        return ((__ts33_1 = this.metadata.docParts.find(function (entry) { return entry.name === name; })), __ts33_1 == null ? undefined : __ts33_1.gallery);
+    };
+    /**
+     * @private
+     */
+    GlossaryDocumentPart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    GlossaryDocumentPart.prototype.serialize = function () {
+        if (this.bytes !== undefined) {
+            return this.bytes;
+        }
+        return new Uint8Array(0);
+    };
+    return GlossaryDocumentPart;
+}());
+export { GlossaryDocumentPart };
+function loadGlossaryDocumentPart(part) {
+    var __ts33_2;
+    if (part === undefined) {
+        return new GlossaryDocumentPart(undefined, EMPTY_METADATA, false);
+    }
+    var metadata = ((__ts33_2 = parseGlossaryMetadataFromBytes(part.data)), __ts33_2 != null ? __ts33_2 : EMPTY_METADATA);
+    return new GlossaryDocumentPart(part.data, metadata, false);
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetGlossaryFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register the glossary document package-part handler. Idempotent. */
+export function registerGlossaryFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: GLOSSARY });
+    registerFeaturePartHandler({
+        featureId: GLOSSARY,
+        relationshipTypes: [GLOSSARY_DOCUMENT_RELATIONSHIP_TYPE, STRICT_GLOSSARY_DOCUMENT_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'glossary/document.xml',
+        partName: GLOSSARY_DOCUMENT_PART_NAME,
+        contentType: GLOSSARY_DOCUMENT_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadGlossaryDocumentPart(part);
+        },
+    });
+}
+/**
+ * Glossary document catalog for a package. Requires {@link registerGlossaryFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered before load.
+ *
+ * @private
+ */
+export function glossaryFor(document) {
+    var part = document.featurePart(GLOSSARY);
+    if (part === undefined || !(part instanceof GlossaryDocumentPart)) {
+        throw new DocxError('feature/not-registered', 'Glossary document part was not loaded; call registerGlossaryFeature() before WordDocument.open');
+    }
+    return part;
+}
+registerGlossaryFeature();