@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/document/alignment.js

@@ -0,0 +1,36 @@
+/**
+ * Semantic paragraph alignment mapped from `ST_Jc`.
+ *
+ * New writes use `start`/`center`/`end`/`justify`. Loaded `left` reads as `Start`
+ * and `both` reads as `Justify` without rewriting the stored value on a no-op save.
+ *
+ * @public
+ */
+export var ParagraphAlignment = {
+    Left: 'start',
+    Center: 'center',
+    Right: 'end',
+    Justify: 'justify',
+};
+/** ST_Jc `left`/`start` read as Start; `both` reads as Justify (spec). */
+export function alignmentFromJc(val) {
+    if (val === 'left' || val === 'start') {
+        return ParagraphAlignment.Left;
+    }
+    if (val === 'right' || val === 'end') {
+        return ParagraphAlignment.Right;
+    }
+    if (val === 'center') {
+        return ParagraphAlignment.Center;
+    }
+    if (val === 'both' || val === 'justify') {
+        return ParagraphAlignment.Justify;
+    }
+    return undefined;
+}
+export function jcForNewAlignment(alignment) {
+    if (alignment === ParagraphAlignment.Justify) {
+        return 'both';
+    }
+    return alignment;
+}

package/src/features/document/alt-chunk.d.ts

@@ -0,0 +1,103 @@
+import { FeatureBlock } from './feature-block';
+import { BlockContent } from './paragraph';
+import { OpcPackage } from '../../core/opc/index';
+import { PartName } from '../../core/opc/part-name';
+import { OpenXmlElement } from '../../core/xml/index';
+declare const ALT_CHUNK: import("../../core/registry").FeatureId;
+/** @public WordDocument surface for altChunk binding. */
+declare type AltChunkDocument = {
+    listBlocks(): ReadonlyArray<BlockContent>;
+    opcPackage(): OpcPackage;
+};
+/**
+ * Transitional aFChunk relationship (ECMA-376-4 §9.2.1).
+ *
+ * @public
+ */
+export declare const AFCHUNK_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk";
+/**
+ * Strict aFChunk relationship (ECMA-376-1 §11.3.1).
+ *
+ * @public
+ */
+export declare const STRICT_AFCHUNK_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/aFChunk";
+/**
+ * Resolved Alternative Format Import part metadata.
+ *
+ * @public
+ */
+export declare type AltChunkTarget = {
+    readonly partName: PartName;
+    readonly contentType: string;
+};
+/**
+ * Body-level anchor for imported external content (`w:altChunk`).
+ *
+ * @private
+ */
+export declare class AltChunkAnchor implements FeatureBlock {
+    private readonly element;
+    private documentOwner;
+    /**
+     * @private
+     */
+    constructor(element: OpenXmlElement);
+    /**
+     * @private
+    */
+    bindDocument(document: AltChunkDocument): void;
+    /**
+     * `r:id` referencing the Alternative Format Import part, or `undefined` when absent.
+     *
+     * @public
+     */
+    readonly relationshipId: string | undefined;
+    /**
+     * Resolved import part metadata when this anchor is bound to a document.
+     *
+     * @public
+     */
+    readonly target: AltChunkTarget | undefined;
+    /**
+     * @private
+    */
+    toOpenXml(): OpenXmlElement;
+}
+/**
+ * @private
+  * Ensure core body block handlers are registered before parse. */
+export declare function ensureCoreBlockHandlers(): void;
+/**
+ * @private
+  * Test hook */
+export declare function resetCoreBlockHandlersForTests(): void;
+/**
+ * Whether a body block is a modeled `w:altChunk` anchor.
+ *
+ * @private
+ */
+export declare function isAltChunkBlock(block: BlockContent): block is {
+    type: 'feature';
+    featureId: typeof ALT_CHUNK;
+    value: AltChunkAnchor;
+};
+/**
+ * Modeled `w:altChunk` anchors in a block list, in document order.
+ *
+ * @private
+ */
+export declare function altChunksInBlocks(blocks: ReadonlyArray<BlockContent>): ReadonlyArray<AltChunkAnchor>;
+/**
+ * Modeled `w:altChunk` anchors in the Main Document body.
+ *
+ * @deprecated Use {@link WordDocument.altChunks} instead.
+ * @private
+ */
+export declare function altChunks(document: {
+    listBlocks(): ReadonlyArray<BlockContent>;
+}): ReadonlyArray<AltChunkAnchor>;
+/**
+ * @private
+  * Bind altChunk anchors to their owning document after load or append. */
+export declare function bindAltChunkDocument(blocks: ReadonlyArray<BlockContent>, document: AltChunkDocument): void;
+export {};

package/src/features/document/alt-chunk.js

@@ -0,0 +1,221 @@
+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 './wml';
+import { partByName, relationshipsForPart, officeDocumentPartName } from '../../core/opc/index';
+import { resolveInternalTarget } from '../../core/opc/part-name';
+import { TargetMode } from '../../core/opc/relationships';
+import { featureId, registerFeature, registerFeatureBlockHandler, } from '../../core/registry/index';
+var ALT_CHUNK = featureId('alt-chunk');
+/**
+ * Transitional aFChunk relationship (ECMA-376-4 §9.2.1).
+ *
+ * @public
+ */
+export var AFCHUNK_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk';
+/**
+ * Strict aFChunk relationship (ECMA-376-1 §11.3.1).
+ *
+ * @public
+ */
+export var STRICT_AFCHUNK_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/aFChunk';
+var AFCHUNK_RELATIONSHIP_TYPES = [
+    AFCHUNK_RELATIONSHIP_TYPE,
+    STRICT_AFCHUNK_RELATIONSHIP_TYPE,
+];
+/** Office WordDocument relationships namespace for `r:id` on `CT_Rel`. */
+var OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+function relationshipIdAttribute(element) {
+    var found = element.attributes.find(function (attribute) { return attribute.localName === 'id' &&
+        (attribute.namespaceUri === OFFICE_RELATIONSHIPS_NAMESPACE ||
+            attribute.prefix === 'r' ||
+            attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function resolveAltChunkTarget(pkg, mainPartName, relationshipId) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(relationshipsForPart(pkg, mainPartName).items), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var rel = _c.value;
+            if (rel.id !== relationshipId) {
+                continue;
+            }
+            if (AFCHUNK_RELATIONSHIP_TYPES.indexOf(rel.type) === -1 ||
+                rel.targetMode === TargetMode.External) {
+                return undefined;
+            }
+            var target = resolveInternalTarget(rel.target, mainPartName);
+            var part = partByName(pkg, target);
+            if (part === undefined) {
+                return undefined;
+            }
+            return { partName: part.name, contentType: part.contentType };
+        }
+    }
+    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 undefined;
+}
+/**
+ * Body-level anchor for imported external content (`w:altChunk`).
+ *
+ * @private
+ */
+var AltChunkAnchor = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function AltChunkAnchor(element) {
+        this.element = element;
+    }
+    /**
+     * @private
+    */
+    AltChunkAnchor.prototype.bindDocument = function (document) {
+        this.documentOwner = document;
+    };
+    Object.defineProperty(AltChunkAnchor.prototype, "relationshipId", {
+        /**
+         * `r:id` referencing the Alternative Format Import part, or `undefined` when absent.
+         *
+         * @public
+         */
+        get: function () {
+            return relationshipIdAttribute(this.element);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AltChunkAnchor.prototype, "target", {
+        /**
+         * Resolved import part metadata when this anchor is bound to a document.
+         *
+         * @public
+         */
+        get: function () {
+            var id = this.relationshipId;
+            if (id === undefined || this.documentOwner === undefined) {
+                return undefined;
+            }
+            var pkg = this.documentOwner.opcPackage();
+            var main = officeDocumentPartName(pkg);
+            return resolveAltChunkTarget(pkg, main, id);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+    */
+    AltChunkAnchor.prototype.toOpenXml = function () {
+        return this.element;
+    };
+    return AltChunkAnchor;
+}());
+export { AltChunkAnchor };
+function parseAltChunk(element) {
+    if (!isWml(element, 'altChunk')) {
+        return undefined;
+    }
+    void elementChildren(element);
+    return new AltChunkAnchor(element);
+}
+var coreHandlersRegistered = false;
+/**
+ * @private
+  * Ensure core body block handlers are registered before parse. */
+export function ensureCoreBlockHandlers() {
+    if (coreHandlersRegistered) {
+        return;
+    }
+    coreHandlersRegistered = true;
+    registerFeature({ id: ALT_CHUNK });
+    registerFeatureBlockHandler({
+        featureId: ALT_CHUNK,
+        wmlLocalName: 'altChunk',
+        tryParse: function (element) {
+            return parseAltChunk(element);
+        },
+    });
+}
+/**
+ * @private
+  * Test hook */
+export function resetCoreBlockHandlersForTests() {
+    coreHandlersRegistered = false;
+}
+/**
+ * Whether a body block is a modeled `w:altChunk` anchor.
+ *
+ * @private
+ */
+export function isAltChunkBlock(block) {
+    return block.type === 'feature' && block.featureId === ALT_CHUNK && block.value instanceof AltChunkAnchor;
+}
+/**
+ * Modeled `w:altChunk` anchors in a block list, in document order.
+ *
+ * @private
+ */
+export function altChunksInBlocks(blocks) {
+    var e_2, _a;
+    var found = [];
+    try {
+        for (var blocks_1 = __values(blocks), blocks_1_1 = blocks_1.next(); !blocks_1_1.done; blocks_1_1 = blocks_1.next()) {
+            var block = blocks_1_1.value;
+            if (isAltChunkBlock(block)) {
+                found.push(block.value);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (blocks_1_1 && !blocks_1_1.done && (_a = blocks_1.return)) _a.call(blocks_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return found;
+}
+/**
+ * Modeled `w:altChunk` anchors in the Main Document body.
+ *
+ * @deprecated Use {@link WordDocument.altChunks} instead.
+ * @private
+ */
+export function altChunks(document) {
+    return altChunksInBlocks(document.listBlocks());
+}
+/**
+ * @private
+  * Bind altChunk anchors to their owning document after load or append. */
+export function bindAltChunkDocument(blocks, document) {
+    var e_3, _a;
+    try {
+        for (var blocks_2 = __values(blocks), blocks_2_1 = blocks_2.next(); !blocks_2_1.done; blocks_2_1 = blocks_2.next()) {
+            var block = blocks_2_1.value;
+            if (isAltChunkBlock(block)) {
+                block.value.bindDocument(document);
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (blocks_2_1 && !blocks_2_1.done && (_a = blocks_2.return)) _a.call(blocks_2);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+}

package/src/features/document/assert-never.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(value: never, what: string): never;

package/src/features/document/assert-never.js

@@ -0,0 +1,4 @@
+import { UnsupportedContentError } from '../../core/errors/docx-error';
+export function assertNever(value, what) {
+    throw new UnsupportedContentError("Unhandled " + what + ": " + JSON.stringify(value));
+}