@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/drawing/parse-register.js

@@ -0,0 +1,257 @@
+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 { FeatureRunParagraphItem } from '../document/text-range';
+import { isWml } from '../document/wml';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from '../../core/mc/index';
+import { registerFeature, registerFeatureRunLeafHandler, } from '../../core/registry/index';
+import { A_NS, attributeValue, findFirstElement, preferredDrawingElement, readDocPrIdentity, R_NS, WP_NS, } from './host-codec';
+import { CHART_GRAPHIC_DATA_URI, CHART_GRAPHIC_DATA_URI_STRICT, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_GRAPHIC_DATA_URI_STRICT, DRAWING, WORDML_2010_NAMESPACE, WORDPROCESSING_INK_URI, } from './types';
+import { createDrawingShape, DrawingShape } from './drawing-shape';
+export function isInlinePictureDrawing(element) {
+    if (!isWml(element, 'drawing')) {
+        return false;
+    }
+    var inline = findFirstElement(element, WP_NS, 'inline');
+    if (inline === undefined) {
+        return false;
+    }
+    var blip = findFirstElement(element, A_NS, 'blip');
+    if (blip === undefined) {
+        return false;
+    }
+    var embed = attributeValue(blip, R_NS, 'embed');
+    return embed !== undefined && embed.length > 0;
+}
+/**
+ * Ink hosts (`wordprocessingInk` graphicData, or group/canvas with `w14:contentPart`).
+ * No public ink API — decline so the host stays an opaque run leaf and its
+ * package parts are not rewritten ([MS-ODRAWXML] §2.2.7.6).
+ */
+function isInkOwnedDrawing(element) {
+    var graphicData = findFirstElement(element, A_NS, 'graphicData');
+    if (graphicData !== undefined) {
+        var uri = attributeValue(graphicData, '', 'uri');
+        if (uri === WORDPROCESSING_INK_URI) {
+            return true;
+        }
+    }
+    return findFirstElement(element, WORDML_2010_NAMESPACE, 'contentPart') !== undefined;
+}
+/**
+ * SmartArt / diagram hosts. No public diagrams API — always decline so drawing
+ * does not surface them as {@link DrawingShape} (which would rewrite the host).
+ */
+function isDiagramOwnedDrawing(element) {
+    var graphicData = findFirstElement(element, A_NS, 'graphicData');
+    if (graphicData === undefined) {
+        return false;
+    }
+    var uri = attributeValue(graphicData, '', 'uri');
+    return uri === DIAGRAM_GRAPHIC_DATA_URI || uri === DIAGRAM_GRAPHIC_DATA_URI_STRICT;
+}
+/**
+ * Chart hosts. No public charts API — decline chart graphicData so the host
+ * stays opaque and chart package parts are not rewritten.
+ */
+function isChartOwnedDrawing(element) {
+    var graphicData = findFirstElement(element, A_NS, 'graphicData');
+    if (graphicData === undefined) {
+        return false;
+    }
+    var uri = attributeValue(graphicData, '', 'uri');
+    return uri === CHART_GRAPHIC_DATA_URI || uri === CHART_GRAPHIC_DATA_URI_STRICT;
+}
+export function drawingIsOwnedByOtherFeature(drawing) {
+    return (isInlinePictureDrawing(drawing) ||
+        isInkOwnedDrawing(drawing) ||
+        isDiagramOwnedDrawing(drawing) ||
+        isChartOwnedDrawing(drawing));
+}
+export function parseDrawingShape(element) {
+    if (!isWml(element, 'drawing')) {
+        return undefined;
+    }
+    if (drawingIsOwnedByOtherFeature(element)) {
+        return undefined;
+    }
+    return createDrawingShape('drawingml', element);
+}
+export function parseVmlPict(element) {
+    if (!isWml(element, 'pict')) {
+        return undefined;
+    }
+    return createDrawingShape('vml', element);
+}
+/**
+ * Parse run-level `mc:AlternateContent` that hosts a non-picture drawing Choice.
+ * Residual root remains the full AC element for clean serialize (Policy B).
+ */
+export function parseAlternateContentDrawing(element) {
+    if (element.namespaceUri !== MARKUP_COMPATIBILITY_NAMESPACE ||
+        element.localName !== 'AlternateContent') {
+        return undefined;
+    }
+    var drawing = preferredDrawingElement(element);
+    if (drawing === undefined) {
+        return undefined;
+    }
+    if (drawingIsOwnedByOtherFeature(drawing)) {
+        return undefined;
+    }
+    return createDrawingShape('drawingml', element);
+}
+export function drawingShapesFromLeaves(items) {
+    var e_1, _a;
+    var found = [];
+    try {
+        for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
+            var item = items_1_1.value;
+            if (item instanceof DrawingShape) {
+                found.push(item);
+                continue;
+            }
+            if (item instanceof FeatureRunParagraphItem && item.featureId === DRAWING && item.value instanceof DrawingShape) {
+                found.push(item.value);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return found;
+}
+export function maxDocPrIdInDocument(document) {
+    var e_2, _a;
+    var max = 0;
+    try {
+        for (var _b = __values(drawingsInDocument(document)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var shape = _c.value;
+            var id = readDocPrIdentity(shape.toOpenXml()).docPrId;
+            if (id !== undefined && id > max) {
+                max = id;
+            }
+        }
+    }
+    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 max;
+}
+export function allocateDocPrId(paragraph) {
+    var document = paragraph.owningDocument();
+    return maxDocPrIdInDocument(document) + 1;
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetDrawingFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register non-picture DrawingML, VML, and MC drawing run-leaf handlers. Idempotent. */
+export function registerDrawingFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: DRAWING });
+    registerFeatureRunLeafHandler({
+        featureId: DRAWING,
+        wmlLocalName: 'drawing',
+        tryParse: parseDrawingShape,
+    });
+    registerFeatureRunLeafHandler({
+        featureId: DRAWING,
+        wmlLocalName: 'pict',
+        tryParse: parseVmlPict,
+    });
+    registerFeatureRunLeafHandler({
+        featureId: DRAWING,
+        wmlLocalName: 'AlternateContent',
+        namespaceUri: MARKUP_COMPATIBILITY_NAMESPACE,
+        tryParse: parseAlternateContentDrawing,
+    });
+}
+/**
+ * Whether a paragraph item is a modeled drawing shape (projected leaf or wrapper).
+ *
+ * @private
+ */
+export function isDrawingShapeLeaf(item) {
+    if (item instanceof DrawingShape) {
+        return true;
+    }
+    return item instanceof FeatureRunParagraphItem && item.featureId === DRAWING && item.value instanceof DrawingShape;
+}
+/**
+ * Drawing shapes in a paragraph, in document order.
+ *
+ * @private
+ */
+export function drawingsInParagraph(paragraph) {
+    return drawingShapesFromLeaves(paragraph.items.toArray());
+}
+/**
+ * Drawing shapes in the Main Document body, in document order.
+ *
+ * @private
+ */
+export function drawingsInDocument(document) {
+    var e_3, _a;
+    var found = [];
+    try {
+        for (var _b = __values(document.listBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var block = _c.value;
+            if (block.type !== 'paragraph') {
+                continue;
+            }
+            found.push.apply(found, __spread(drawingsInParagraph(block.paragraph)));
+        }
+    }
+    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 found;
+}

package/src/features/drawing/residual-utils.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Residual DOM utilities for DrawingML / VML detection and clone helpers.
+ *
+ * @private
+ */
+import { BlockContent } from '../document/paragraph';
+import { OpenXmlElement } from '../../core/xml/index';
+import { DrawingVariant } from './types';
+export declare function elementChildren(el: OpenXmlElement): ReadonlyArray<OpenXmlElement>;
+export declare function isElement(el: OpenXmlElement, namespaceUri: string, localName: string): boolean;
+export declare function emptyTxbxParagraphBlocks(): BlockContent[];
+/** Deep-clone a residual element for txbxContent patching (no shared state). */
+export declare function cloneResidualElement(el: OpenXmlElement): OpenXmlElement;
+/**
+ * Locate the nested-child host element for a group (`wpg:wgp` / nested
+ * `wpg:grpSp`) or canvas (`wpc:wpc`) residual tree (TASK-8051).
+ *
+ * Accepts top-level `w:drawing` / MC dual-AC roots, bare nested group residuals,
+ * or an already-resolved container. Returns undefined for leaf shapes.
+ */
+export declare function findNestedDrawingContainer(root: OpenXmlElement): OpenXmlElement | undefined;
+/**
+ * Detect the variant of a DML drawing (`w:drawing` element).
+ *
+ * Strategy: locate `a:graphic/a:graphicData` and inspect the `@uri` attribute.
+ * - WPS_NS → `wps:wsp` present → 'textBox' if `wps:txbx` child exists, else 'shape'
+ * - WPG_NS → 'group'  ([MS-ODRAWXML] §2.2.7.4, §2.16)
+ * - WPC_NS → 'canvas' ([MS-ODRAWXML] §2.2.7.5, §2.17)
+ * - anything else → 'unknown'
+ */
+export declare function detectDmlVariant(drawingEl: OpenXmlElement): DrawingVariant;
+/**
+ * True when residual is (or contains) MC AlternateContent with a Fallback
+ * branch that carries `w:pict` (Policy B dual AC VML Fallback — TASK-8050).
+ * Does not execute or interpret VML children.
+ *
+ * @private
+ */
+export declare function residualHasVmlFallback(root: OpenXmlElement): boolean;
+/**
+ * Detect drawing variant from a VML `w:pict` subtree.
+ *
+ * Source: ECMA-376-4 §14.3 VML elements; [MS-OI29500] Part 4.
+ */
+export declare function detectVmlVariant(pictEl: OpenXmlElement): DrawingVariant;
+export declare function collectRelationshipIds(root: OpenXmlElement): ReadonlyArray<string>;
+export declare function collectRelationshipIdsRecursive(element: OpenXmlElement, found: Set<string>): void;

package/src/features/drawing/residual-utils.js

@@ -0,0 +1,290 @@
+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 __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;
+};
+/**
+ * Residual DOM utilities for DrawingML / VML detection and clone helpers.
+ *
+ * @private
+ */
+import { Paragraph } from '../document/paragraph';
+import { isWml } from '../document/wml';
+import { MARKUP_COMPATIBILITY_NAMESPACE } from '../../core/mc/index';
+import { A_NS, attributeValue, findFirstElement, preferredDrawingElement, R_NS, VML_NS, WPC_NS, WPG_NS, WPS_NS, } from './host-codec';
+export function elementChildren(el) {
+    return el.children.filter(function (c) { return c.kind === 'element'; });
+}
+export function isElement(el, namespaceUri, localName) {
+    return el.namespaceUri === namespaceUri && el.localName === localName;
+}
+export function emptyTxbxParagraphBlocks() {
+    return [{ type: 'paragraph', paragraph: new Paragraph(undefined) }];
+}
+/** Deep-clone a residual element for txbxContent patching (no shared state). */
+export function cloneResidualElement(el) {
+    return {
+        kind: 'element',
+        namespaceUri: el.namespaceUri,
+        localName: el.localName,
+        prefix: el.prefix,
+        attributes: el.attributes.map(function (a) { return (__assign({}, a)); }),
+        namespaceDeclarations: el.namespaceDeclarations.map(function (n) { return (__assign({}, n)); }),
+        children: el.children.map(function (c) {
+            if (c.kind === 'element') {
+                return cloneResidualElement(c);
+            }
+            return { kind: 'text', value: c.value };
+        }),
+    };
+}
+/**
+ * Locate the nested-child host element for a group (`wpg:wgp` / nested
+ * `wpg:grpSp`) or canvas (`wpc:wpc`) residual tree (TASK-8051).
+ *
+ * Accepts top-level `w:drawing` / MC dual-AC roots, bare nested group residuals,
+ * or an already-resolved container. Returns undefined for leaf shapes.
+ */
+export function findNestedDrawingContainer(root) {
+    var e_1, _a;
+    var __ts33_0, __ts33_1, __ts33_2, __ts33_3;
+    if (root.namespaceUri === WPG_NS && (root.localName === 'wgp' || root.localName === 'grpSp')) {
+        return root;
+    }
+    if (root.namespaceUri === WPC_NS && root.localName === 'wpc') {
+        return root;
+    }
+    var drawing = ((__ts33_0 = preferredDrawingElement(root)), __ts33_0 != null ? __ts33_0 : (isWml(root, 'drawing') ? root : undefined));
+    if (drawing === undefined) {
+        // Residual may already be graphicData or an intermediate tree fragment.
+        var directWgp = ((__ts33_1 = findFirstElement(root, WPG_NS, 'wgp')), __ts33_1 != null ? __ts33_1 : findFirstElement(root, WPG_NS, 'grpSp'));
+        if (directWgp !== undefined) {
+            return directWgp;
+        }
+        return findFirstElement(root, WPC_NS, 'wpc');
+    }
+    var graphicData = findFirstElement(drawing, A_NS, 'graphicData');
+    if (graphicData !== undefined) {
+        try {
+            for (var _b = __values(elementChildren(graphicData)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if ((child.namespaceUri === WPG_NS && (child.localName === 'wgp' || child.localName === 'grpSp')) ||
+                    (child.namespaceUri === WPC_NS && child.localName === 'wpc')) {
+                    return 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 (((__ts33_3 = ((__ts33_2 = findFirstElement(drawing, WPG_NS, 'wgp')), __ts33_2 != null ? __ts33_2 : findFirstElement(drawing, WPG_NS, 'grpSp'))), __ts33_3 != null ? __ts33_3 : findFirstElement(drawing, WPC_NS, 'wpc')));
+}
+/**
+ * Detect the variant of a DML drawing (`w:drawing` element).
+ *
+ * Strategy: locate `a:graphic/a:graphicData` and inspect the `@uri` attribute.
+ * - WPS_NS → `wps:wsp` present → 'textBox' if `wps:txbx` child exists, else 'shape'
+ * - WPG_NS → 'group'  ([MS-ODRAWXML] §2.2.7.4, §2.16)
+ * - WPC_NS → 'canvas' ([MS-ODRAWXML] §2.2.7.5, §2.17)
+ * - anything else → 'unknown'
+ */
+export function detectDmlVariant(drawingEl) {
+    var graphicData = findFirstElement(drawingEl, A_NS, 'graphicData');
+    if (graphicData === undefined) {
+        return 'unknown';
+    }
+    var uri = attributeValue(graphicData, '', 'uri');
+    if (uri === WPS_NS) {
+        var wsp = findFirstElement(graphicData, WPS_NS, 'wsp');
+        if (wsp !== undefined) {
+            var hasTxbx = elementChildren(wsp).some(function (c) { return isElement(c, WPS_NS, 'txbx'); }) ||
+                elementChildren(wsp).some(function (c) { return isElement(c, WPS_NS, 'linkedTxbx'); });
+            return hasTxbx ? 'textBox' : 'shape';
+        }
+        return 'unknown';
+    }
+    if (uri === WPG_NS) {
+        return 'group';
+    }
+    if (uri === WPC_NS) {
+        return 'canvas';
+    }
+    return 'unknown';
+}
+/**
+ * True when residual is (or contains) MC AlternateContent with a Fallback
+ * branch that carries `w:pict` (Policy B dual AC VML Fallback — TASK-8050).
+ * Does not execute or interpret VML children.
+ *
+ * @private
+ */
+export function residualHasVmlFallback(root) {
+    var e_2, _a, e_3, _b, e_4, _c;
+    if (root.namespaceUri === MARKUP_COMPATIBILITY_NAMESPACE &&
+        root.localName === 'AlternateContent') {
+        try {
+            for (var _d = __values(elementChildren(root)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var child = _e.value;
+                if (child.namespaceUri !== MARKUP_COMPATIBILITY_NAMESPACE ||
+                    child.localName !== 'Fallback') {
+                    continue;
+                }
+                try {
+                    for (var _f = __values(elementChildren(child)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                        var nested = _g.value;
+                        if (isWml(nested, 'pict')) {
+                            return true;
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return false;
+    }
+    try {
+        // Authored dual AC is the residual root; residual may also nest AC under
+        // rare fixtures — shallow scan only (no deep walk of every descendant).
+        for (var _h = __values(elementChildren(root)), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var child = _j.value;
+            if (residualHasVmlFallback(child)) {
+                return true;
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return false;
+}
+/**
+ * Detect drawing variant from a VML `w:pict` subtree.
+ *
+ * Source: ECMA-376-4 §14.3 VML elements; [MS-OI29500] Part 4.
+ */
+export function detectVmlVariant(pictEl) {
+    var e_5, _a;
+    try {
+        for (var _b = __values(elementChildren(pictEl)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.namespaceUri !== VML_NS) {
+                continue;
+            }
+            if (child.localName === 'group') {
+                return 'group';
+            }
+            var isVmlShapeContainer = child.localName === 'shape' ||
+                child.localName === 'rect' ||
+                child.localName === 'oval' ||
+                child.localName === 'roundrect';
+            if (isVmlShapeContainer) {
+                var hasTextbox = elementChildren(child).some(function (c) { return isElement(c, VML_NS, 'textbox'); });
+                return hasTextbox ? 'textBox' : 'shape';
+            }
+        }
+    }
+    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 'unknown';
+}
+export function collectRelationshipIds(root) {
+    var found = new Set();
+    collectRelationshipIdsRecursive(root, found);
+    return __spread(found);
+}
+export function collectRelationshipIdsRecursive(element, found) {
+    var e_6, _a, e_7, _b;
+    try {
+        for (var _c = __values(element.attributes), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var attribute = _d.value;
+            if (attribute.namespaceUri === R_NS &&
+                (attribute.localName === 'embed' || attribute.localName === 'link') &&
+                attribute.value.length > 0) {
+                found.add(attribute.value);
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    try {
+        for (var _e = __values(elementChildren(element)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var child = _f.value;
+            collectRelationshipIdsRecursive(child, found);
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+}