@syncfusion/ej2-office-common 35.1.37

package/src/features/smart-art/point-text.js

@@ -0,0 +1,424 @@
+/**
+ * Common plain-text and structure query APIs for DrawingML diagram points.
+ *
+ * @remarks
+ * Text lives under `dgm:pt/dgm:t` as DrawingML `a:CT_TextBody` (`dml-main.xsd`:
+ * required `bodyPr`, optional `lstStyle`, one or more `p`). Plain text is the
+ * concatenation of `a:t` under each paragraph, with paragraphs joined by `\n`.
+ * Write rebuilds a minimal schema-valid text body while preserving other `pt`
+ * children and any existing `bodyPr` / `lstStyle`. Citations: `dml-diagram.xsd`
+ * `CT_Pt`; `dml-main.xsd` `CT_TextBody` / `CT_TextParagraph`; ECMA-376 Part 1
+ * §14.2.4. Structure add/remove of points and connections is deferred (no
+ * schema-valid factory beyond enumerate in this task).
+ *
+ * @public
+ */
+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;
+};
+import { cloneElement, elementChildren, findChild, getAttribute } from './diagram-xml';
+import { DiagramPartError } from './errors';
+import { DIAGRAM_NAMESPACE, DRAWINGML_MAIN_NAMESPACE } from './namespaces';
+import { parseDiagramData } from './parse-data';
+import { serializeDiagramData } from './serialize';
+/**
+ * Returns the points of a Diagram Data part (structure enumerate).
+ *
+ * @param data - Parsed {@link DiagramDataPart}.
+ * @returns The part's `points` array (same reference; treat as read-only).
+ *
+ * @public
+ */
+export function listDiagramPoints(data) {
+    return data.points;
+}
+/**
+ * Returns the connections of a Diagram Data part (structure enumerate).
+ *
+ * @param data - Parsed {@link DiagramDataPart}.
+ * @returns The part's `connections` array (same reference; treat as read-only).
+ *
+ * @public
+ */
+export function listDiagramConnections(data) {
+    return data.connections;
+}
+/**
+ * Finds a point by `modelId`.
+ *
+ * @param data - Parsed {@link DiagramDataPart}.
+ * @param modelId - `dgm:pt@modelId` value.
+ * @returns The matching {@link DiagramPoint}, or `undefined` when absent.
+ *
+ * @public
+ */
+export function diagramPoint(data, modelId) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(data.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var point = _c.value;
+            if (point.modelId === modelId) {
+                return point;
+            }
+        }
+    }
+    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;
+}
+/**
+ * Reads plain text from a diagram point's `dgm:t` DrawingML text body.
+ *
+ * @remarks
+ * Walks `a:p` paragraphs in document order. Within each paragraph, concatenates
+ * text from `a:t` descendants (including under `a:r` and `a:fld`). Paragraphs
+ * are joined with `\n`. Missing `dgm:t` yields an empty string.
+ *
+ * @param point - Modeled point (from parse or {@link listDiagramPoints}).
+ * @returns Plain text; empty string when the point has no text body or no `a:t`.
+ *
+ * @public
+ */
+export function diagramPointText(point) {
+    var textBody = point.textBody != null ? point.textBody : findChild(point.element, 't', DIAGRAM_NAMESPACE);
+    if (textBody === undefined) {
+        return '';
+    }
+    return plainTextFromTextBody(textBody);
+}
+/**
+ * Returns a new {@link DiagramDataPart} with plain text written to the named point.
+ *
+ * @remarks
+ * Does not mutate `data`. Rebuilds `dgm:t` as a minimal valid `a:CT_TextBody`
+ * (`bodyPr` + one `p`/`r`/`t` per line). When a text body already exists,
+ * `bodyPr` and `lstStyle` (if present) are preserved; paragraph children are
+ * replaced. Other `dgm:pt` siblings and package root extensions are preserved
+ * via root rewrite + reparse. Unknown `modelId` throws.
+ *
+ * Prefer this name over a `set*` verb (API-RULES R1.1 content-mutation ban on
+ * `set*` / free-function `set*` patterns).
+ *
+ * @param data - Source data part (immutable).
+ * @param modelId - Target `dgm:pt@modelId`.
+ * @param text - Plain text; `\n` splits paragraphs.
+ * @returns New data part with updated point text and synced root.
+ * @throws {DiagramPartError} When no point matches `modelId`.
+ *
+ * @public
+ */
+export function withDiagramPointText(data, modelId, text) {
+    var target = diagramPoint(data, modelId);
+    if (target === undefined) {
+        throw new DiagramPartError("Unknown diagram point modelId \"" + modelId + "\"");
+    }
+    var newRoot = replacePointTextOnRoot(data.root, modelId, text);
+    // Reparse so points[].textBody / element stay consistent with root.
+    return parseDiagramData(serializeDiagramData(__assign({}, data, { root: newRoot })));
+}
+function plainTextFromTextBody(textBody) {
+    var paragraphs = elementChildren(textBody).filter(function (el) { return el.localName === 'p' && el.namespaceUri === DRAWINGML_MAIN_NAMESPACE; });
+    if (paragraphs.length === 0) {
+        // Fallback: collect any a:t under the body (malformed-but-present text).
+        return collectDrawingMlText(textBody);
+    }
+    return paragraphs.map(function (p) { return collectDrawingMlText(p); }).join('\n');
+}
+function collectDrawingMlText(el) {
+    var e_2, _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') {
+                continue;
+            }
+            if (child.localName === 't' && child.namespaceUri === DRAWINGML_MAIN_NAMESPACE) {
+                out += textContent(child);
+                continue;
+            }
+            out += collectDrawingMlText(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 out;
+}
+function textContent(el) {
+    var e_3, _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;
+            }
+            else {
+                out += textContent(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 out;
+}
+function replacePointTextOnRoot(root, modelId, text) {
+    return mapTree(root, function (el) {
+        if (el.localName === 'pt' && el.namespaceUri === DIAGRAM_NAMESPACE && getAttribute(el, 'modelId') === modelId) {
+            return withPointTextElement(el, text);
+        }
+        return undefined;
+    });
+}
+/**
+ * Deep-maps an element tree. When `visitor` returns an element, that subtree is
+ * replaced as-is (no further recursion into the replacement). Otherwise children
+ * are mapped recursively.
+ */
+function mapTree(el, visitor) {
+    var e_4, _a;
+    var replaced = visitor(el);
+    if (replaced !== undefined) {
+        return replaced;
+    }
+    var changed = false;
+    var children = [];
+    try {
+        for (var _b = __values(el.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind === 'text') {
+                children.push({
+                    kind: 'text',
+                    value: child.value
+                });
+                continue;
+            }
+            var next = mapTree(child, visitor);
+            if (next !== child) {
+                changed = true;
+            }
+            children.push(next);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    if (!changed) {
+        return el;
+    }
+    return { kind: 'element',
+        prefix: el.prefix,
+        localName: el.localName,
+        namespaceUri: el.namespaceUri,
+        qName: el.qName,
+        attributes: el.attributes.map(function (a) { return (__assign({}, a)); }),
+        children: children
+    };
+}
+function withPointTextElement(pt, text) {
+    var e_5, _a;
+    var existingT = findChild(pt, 't', DIAGRAM_NAMESPACE);
+    var newT = buildTextBodyElement(existingT, text);
+    var children = [];
+    var replaced = false;
+    try {
+        for (var _b = __values(pt.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!replaced && child.kind === 'element' && child.localName === 't' && child.namespaceUri === DIAGRAM_NAMESPACE) {
+                children.push(newT);
+                replaced = true;
+                continue;
+            }
+            if (child.kind === 'text') {
+                children.push({
+                    kind: 'text',
+                    value: child.value
+                });
+            }
+            else {
+                children.push(cloneElement(child));
+            }
+        }
+    }
+    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; }
+    }
+    if (!replaced) {
+        children.push(newT);
+    }
+    return { kind: 'element',
+        prefix: pt.prefix,
+        localName: pt.localName,
+        namespaceUri: pt.namespaceUri,
+        qName: pt.qName,
+        attributes: pt.attributes.map(function (a) { return (__assign({}, a)); }),
+        children: children
+    };
+}
+/**
+ * Builds `dgm:t` with DrawingML `a:CT_TextBody` children.
+ *
+ * Order per XSD: bodyPr (required), lstStyle (optional), p+ (required ≥1).
+ */
+function buildTextBodyElement(existing, text) {
+    var e_6, _a;
+    var aPrefix = existing !== undefined ? drawingMlPrefix(existing) : 'a';
+    var dgmPrefix = (existing == null ? void 0 : existing.prefix) && existing.prefix.length > 0 ? existing.prefix : 'dgm';
+    var bodyPr = existing !== undefined ? findChild(existing, 'bodyPr', DRAWINGML_MAIN_NAMESPACE) : undefined;
+    var lstStyle = existing !== undefined ? findChild(existing, 'lstStyle', DRAWINGML_MAIN_NAMESPACE) : undefined;
+    var lines = splitPlainTextLines(text);
+    var paragraphs = lines.map(function (line) { return aElement(aPrefix, 'p', [aElement(aPrefix, 'r', [aTextElement(aPrefix, line)])]); });
+    var children = [];
+    if (bodyPr !== undefined) {
+        children.push(cloneElement(bodyPr));
+    }
+    else {
+        children.push(aElement(aPrefix, 'bodyPr', []));
+    }
+    if (lstStyle !== undefined) {
+        children.push(cloneElement(lstStyle));
+    }
+    try {
+        for (var paragraphs_1 = __values(paragraphs), paragraphs_1_1 = paragraphs_1.next(); !paragraphs_1_1.done; paragraphs_1_1 = paragraphs_1.next()) {
+            var p = paragraphs_1_1.value;
+            children.push(p);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (paragraphs_1_1 && !paragraphs_1_1.done && (_a = paragraphs_1.return)) _a.call(paragraphs_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    // Ensure xmlns:a is in scope on dgm:t when the root may not declare it yet
+    // (e.g. blank points from minimal samples that only declare dgm).
+    var attributes = existing !== undefined ? existing.attributes.map(function (a) { return (__assign({}, a)); }) : [{
+            prefix: 'xmlns',
+            localName: 'a',
+            namespaceUri: 'http://www.w3.org/2000/xmlns/',
+            value: DRAWINGML_MAIN_NAMESPACE,
+            qName: 'xmlns:a'
+        }];
+    // If existing t lacked xmlns:a and ancestors also might miss it after rewrite,
+    // ensure declaration when we detect no a attributes already present.
+    var hasANs = attributes.some(function (a) { return a.prefix === 'xmlns' && a.localName === 'a' || a.prefix === '' && a.localName === 'xmlns' && a.value === DRAWINGML_MAIN_NAMESPACE; });
+    var finalAttributes = hasANs ? attributes : __spread(attributes, [{
+            prefix: 'xmlns',
+            localName: 'a',
+            namespaceUri: 'http://www.w3.org/2000/xmlns/',
+            value: DRAWINGML_MAIN_NAMESPACE,
+            qName: 'xmlns:a'
+        }]);
+    return { kind: 'element',
+        prefix: dgmPrefix,
+        localName: 't',
+        namespaceUri: DIAGRAM_NAMESPACE,
+        qName: dgmPrefix.length > 0 ? dgmPrefix + ":t" : 't',
+        attributes: finalAttributes,
+        children: children
+    };
+}
+function splitPlainTextLines(text) {
+    if (text.length === 0) {
+        return [''];
+    }
+    return text.split('\n');
+}
+function aElement(prefix, localName, children) {
+    var p = prefix.length > 0 ? prefix : 'a';
+    return { kind: 'element',
+        prefix: p,
+        localName: localName,
+        namespaceUri: DRAWINGML_MAIN_NAMESPACE,
+        qName: p + ":" + localName,
+        attributes: [],
+        children: __spread(children)
+    };
+}
+function aTextElement(prefix, value) {
+    return aElement(prefix, 't', [{
+            kind: 'text',
+            value: value
+        }]);
+}
+function drawingMlPrefix(textBody) {
+    var e_7, _a;
+    try {
+        for (var _b = __values(elementChildren(textBody)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.namespaceUri === DRAWINGML_MAIN_NAMESPACE && child.prefix.length > 0) {
+                return child.prefix;
+            }
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return 'a';
+}

package/src/features/smart-art/register.d.ts

@@ -0,0 +1,33 @@
+/**
+ * SmartArt feature registration — in-module content-type handler table.
+ *
+ * @remarks
+ * This encryption-base tree has no shared FeatureRegistry. Handlers for the four
+ * Transitional diagram content types live in a module-local map installed by
+ * {@link registerSmartArtFeature}. Safe to call multiple times (idempotent).
+ *
+ * Citations: ECMA-376 Part 1 §14.2.3–14.2.6 content types.
+ *
+ * @public
+ */
+import { DiagramPartHandler } from './types';
+/**
+ * Registers SmartArt (DrawingML diagram) parse/serialize handlers for the four
+ * Transitional diagram content types.
+ *
+ * @remarks
+ * Idempotent: subsequent calls leave the installed table unchanged.
+ * Does not accept or return PowerPoint, Word, or Excel product types.
+ *
+ * @public
+ */
+export declare function registerSmartArtFeature(): void;
+/**
+ * Looks up a registered diagram part handler by content type.
+ *
+ * @param contentType - One of the four Transitional diagram content types.
+ * @returns The handler, or `undefined` if registration has not run or the type is unknown.
+ *
+ * @public
+ */
+export declare function getDiagramPartHandler(contentType: string): DiagramPartHandler | undefined;

package/src/features/smart-art/register.js

@@ -0,0 +1,95 @@
+/**
+ * SmartArt feature registration — in-module content-type handler table.
+ *
+ * @remarks
+ * This encryption-base tree has no shared FeatureRegistry. Handlers for the four
+ * Transitional diagram content types live in a module-local map installed by
+ * {@link registerSmartArtFeature}. Safe to call multiple times (idempotent).
+ *
+ * Citations: ECMA-376 Part 1 §14.2.3–14.2.6 content types.
+ *
+ * @public
+ */
+import { DiagramPartError } from './errors';
+import { DIAGRAM_COLORS_CONTENT_TYPE, DIAGRAM_DATA_CONTENT_TYPE, DIAGRAM_LAYOUT_CONTENT_TYPE, DIAGRAM_STYLE_CONTENT_TYPE, } from './namespaces';
+import { parseDiagramColors } from './parse-colors';
+import { parseDiagramData } from './parse-data';
+import { parseDiagramLayout } from './parse-layout';
+import { parseDiagramStyle } from './parse-style';
+import { serializeDiagramColors, serializeDiagramData, serializeDiagramLayout, serializeDiagramStyle, } from './serialize';
+var handlers = new Map();
+var installed = false;
+function installHandlers() {
+    if (installed) {
+        return;
+    }
+    var dataHandler = {
+        contentType: DIAGRAM_DATA_CONTENT_TYPE,
+        parse: function (xml) { return parseDiagramData(xml); },
+        serialize: function (part) {
+            if (part.kind !== 'diagramData') {
+                throw new DiagramPartError('Handler serialize kind mismatch for diagramData');
+            }
+            return serializeDiagramData(part);
+        },
+    };
+    var colorsHandler = {
+        contentType: DIAGRAM_COLORS_CONTENT_TYPE,
+        parse: function (xml) { return parseDiagramColors(xml); },
+        serialize: function (part) {
+            if (part.kind !== 'diagramColors') {
+                throw new DiagramPartError('Handler serialize kind mismatch for diagramColors');
+            }
+            return serializeDiagramColors(part);
+        },
+    };
+    var layoutHandler = {
+        contentType: DIAGRAM_LAYOUT_CONTENT_TYPE,
+        parse: function (xml) { return parseDiagramLayout(xml); },
+        serialize: function (part) {
+            if (part.kind !== 'diagramLayout') {
+                throw new DiagramPartError('Handler serialize kind mismatch for diagramLayout');
+            }
+            return serializeDiagramLayout(part);
+        },
+    };
+    var styleHandler = {
+        contentType: DIAGRAM_STYLE_CONTENT_TYPE,
+        parse: function (xml) { return parseDiagramStyle(xml); },
+        serialize: function (part) {
+            if (part.kind !== 'diagramStyle') {
+                throw new DiagramPartError('Handler serialize kind mismatch for diagramStyle');
+            }
+            return serializeDiagramStyle(part);
+        },
+    };
+    handlers.set(DIAGRAM_DATA_CONTENT_TYPE, dataHandler);
+    handlers.set(DIAGRAM_COLORS_CONTENT_TYPE, colorsHandler);
+    handlers.set(DIAGRAM_LAYOUT_CONTENT_TYPE, layoutHandler);
+    handlers.set(DIAGRAM_STYLE_CONTENT_TYPE, styleHandler);
+    installed = true;
+}
+/**
+ * Registers SmartArt (DrawingML diagram) parse/serialize handlers for the four
+ * Transitional diagram content types.
+ *
+ * @remarks
+ * Idempotent: subsequent calls leave the installed table unchanged.
+ * Does not accept or return PowerPoint, Word, or Excel product types.
+ *
+ * @public
+ */
+export function registerSmartArtFeature() {
+    installHandlers();
+}
+/**
+ * Looks up a registered diagram part handler by content type.
+ *
+ * @param contentType - One of the four Transitional diagram content types.
+ * @returns The handler, or `undefined` if registration has not run or the type is unknown.
+ *
+ * @public
+ */
+export function getDiagramPartHandler(contentType) {
+    return handlers.get(contentType);
+}

package/src/features/smart-art/serialize.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Serialize DrawingML diagram parts from preserved root elements.
+ *
+ * @remarks
+ * v1 serialize is root-identity: write the cloned `root` captured at parse time
+ * so unknown children, attributes, and MC content round-trip. Citations:
+ * ECMA-376 Part 1 §14.2.3–14.2.6; preserve policy in `docs/ooxml-mapping/smart-art.md`.
+ *
+ * @public
+ */
+import { DiagramColorsPart, DiagramDataPart, DiagramLayoutPart, DiagramStylePart } from './types';
+/**
+ * Serializes a {@link DiagramDataPart} to a Diagram Data part XML document.
+ *
+ * @remarks
+ * Root-identity serialize of the cloned `root` captured at parse time. Kind is
+ * enforced by the TypeScript parameter type; runtime kind mismatch checks live
+ * on content-type handlers in `register.ts`.
+ *
+ * @public
+ */
+export declare function serializeDiagramData(part: DiagramDataPart): string;
+/**
+ * Serializes a {@link DiagramColorsPart} to a Diagram Colors part XML document.
+ *
+ * @public
+ */
+export declare function serializeDiagramColors(part: DiagramColorsPart): string;
+/**
+ * Serializes a {@link DiagramLayoutPart} to a Diagram Layout Definition part XML document.
+ *
+ * @public
+ */
+export declare function serializeDiagramLayout(part: DiagramLayoutPart): string;
+/**
+ * Serializes a {@link DiagramStylePart} to a Diagram Style part XML document.
+ *
+ * @public
+ */
+export declare function serializeDiagramStyle(part: DiagramStylePart): string;

package/src/features/smart-art/serialize.js

@@ -0,0 +1,48 @@
+/**
+ * Serialize DrawingML diagram parts from preserved root elements.
+ *
+ * @remarks
+ * v1 serialize is root-identity: write the cloned `root` captured at parse time
+ * so unknown children, attributes, and MC content round-trip. Citations:
+ * ECMA-376 Part 1 §14.2.3–14.2.6; preserve policy in `docs/ooxml-mapping/smart-art.md`.
+ *
+ * @public
+ */
+import { serializeDiagramXml } from './diagram-xml';
+/**
+ * Serializes a {@link DiagramDataPart} to a Diagram Data part XML document.
+ *
+ * @remarks
+ * Root-identity serialize of the cloned `root` captured at parse time. Kind is
+ * enforced by the TypeScript parameter type; runtime kind mismatch checks live
+ * on content-type handlers in `register.ts`.
+ *
+ * @public
+ */
+export function serializeDiagramData(part) {
+    return serializeDiagramXml(part.root);
+}
+/**
+ * Serializes a {@link DiagramColorsPart} to a Diagram Colors part XML document.
+ *
+ * @public
+ */
+export function serializeDiagramColors(part) {
+    return serializeDiagramXml(part.root);
+}
+/**
+ * Serializes a {@link DiagramLayoutPart} to a Diagram Layout Definition part XML document.
+ *
+ * @public
+ */
+export function serializeDiagramLayout(part) {
+    return serializeDiagramXml(part.root);
+}
+/**
+ * Serializes a {@link DiagramStylePart} to a Diagram Style part XML document.
+ *
+ * @public
+ */
+export function serializeDiagramStyle(part) {
+    return serializeDiagramXml(part.root);
+}