@syncfusion/ej2-office-common 35.1.37

package/src/features/ink/ink-serializer.js

@@ -0,0 +1,281 @@
+/**
+ * {@link OfficeInk} → InkML element tree serializer ([MS-ODRAWXML] §2.1.4).
+ *
+ * Trace text is always {@link encodeTrace} from points — never stored XML text.
+ * Brush property order matches `docs/specs/ink-shared-codec.md` / TASK-9003.
+ */
+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 { isOfficeInk } from './ink-model';
+import { inkEffectColor } from './ink-effects';
+import { formatUnitValue, pointsToUnit } from './ink-units';
+import { attr, inkElement, inkmlNamespaceDecl, textNode, xmlIdAttr, } from './ink-xml';
+import { encodeTrace } from './trace-codec';
+var DEFAULT_CONTEXT_ID = 'ctx0';
+var DEFAULT_CONTEXT_REF = '#ctx0';
+var DEFAULT_INK_SOURCE_ID = 'inkSrc0';
+var CHANNEL_MIN = '-2.14748E9';
+var CHANNEL_MAX = '2.14748E9';
+var CHANNEL_UNITS = 'cm';
+/**
+ * Serialize an {@link OfficeInk} DOM to an InkML `ink` root element.
+ *
+ * Source: [MS-ODRAWXML] §2.1.4; `docs/specs/ink-shared-codec.md` Serializer behavior.
+ *
+ * @private
+ */
+export function serializeInkXml(ink) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    if (!isOfficeInk(ink)) {
+        throw new TypeError('serializeInkXml: expected OfficeInk from parseInkXml/createInk');
+    }
+    var children = [];
+    var definitionsChildren = [];
+    var needsContext = ink.traces.some(function (t) { return t.contextRef === DEFAULT_CONTEXT_REF || t.contextRef === '' || t.contextRef === "#" + DEFAULT_CONTEXT_ID; }) || ink.traces.length > 0;
+    var contexts = (ink.contexts != null ? ink.contexts : []);
+    // Emit each known context; ensure default #ctx0 when referenced/needed
+    var hasDefaultContext = false;
+    try {
+        for (var contexts_1 = __values(contexts), contexts_1_1 = contexts_1.next(); !contexts_1_1.done; contexts_1_1 = contexts_1.next()) {
+            var ctx = contexts_1_1.value;
+            definitionsChildren.push(serializeContext(ctx));
+            var bare = stripHash(ctx.id);
+            if (bare === DEFAULT_CONTEXT_ID) {
+                hasDefaultContext = true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (contexts_1_1 && !contexts_1_1.done && (_a = contexts_1.return)) _a.call(contexts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (needsContext && !hasDefaultContext) {
+        definitionsChildren.push(serializeContext(defaultContext()));
+    }
+    // Brushes sorted by id (string key order)
+    var sortedBrushes = __spread(ink.brushes).sort(function (a, b) { return (a.id < b.id ? -1 : a.id > b.id ? 1 : 0); });
+    try {
+        for (var sortedBrushes_1 = __values(sortedBrushes), sortedBrushes_1_1 = sortedBrushes_1.next(); !sortedBrushes_1_1.done; sortedBrushes_1_1 = sortedBrushes_1.next()) {
+            var brush = sortedBrushes_1_1.value;
+            definitionsChildren.push(serializeBrush(brush));
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (sortedBrushes_1_1 && !sortedBrushes_1_1.done && (_b = sortedBrushes_1.return)) _b.call(sortedBrushes_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (definitionsChildren.length > 0) {
+        children.push(inkElement('definitions', [], definitionsChildren));
+    }
+    // Traces / groups
+    if (ink.traceTree !== undefined && ink.traceTree.length > 0) {
+        try {
+            for (var _e = __values(ink.traceTree), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var node = _f.value;
+                children.push.apply(children, __spread(serializeTreeNode(node, ink.traces)));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    }
+    else {
+        try {
+            for (var _g = __values(ink.traces), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var trace = _h.value;
+                children.push(serializeTrace(trace));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_d = _g.return)) _d.call(_g);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    return inkElement('ink', [], children, [inkmlNamespaceDecl()]);
+}
+function defaultContext() {
+    return {
+        id: DEFAULT_CONTEXT_REF,
+        inkSourceId: DEFAULT_INK_SOURCE_ID,
+        channels: [
+            {
+                name: 'X',
+                type: 'integer',
+                min: CHANNEL_MIN,
+                max: CHANNEL_MAX,
+                units: CHANNEL_UNITS,
+            },
+            {
+                name: 'Y',
+                type: 'integer',
+                min: CHANNEL_MIN,
+                max: CHANNEL_MAX,
+                units: CHANNEL_UNITS,
+            },
+        ],
+    };
+}
+function serializeContext(ctx) {
+    var idBare = stripHash(ctx.id);
+    var inkSourceId = stripHash((ctx.inkSourceId != null ? ctx.inkSourceId : DEFAULT_INK_SOURCE_ID));
+    var channels = ctx.channels.length > 0
+        ? ctx.channels
+        : defaultContext().channels;
+    var channelEls = channels.map(function (ch) { return serializeChannel(ch); });
+    var traceFormat = inkElement('traceFormat', [], channelEls);
+    var inkSource = inkElement('inkSource', [xmlIdAttr(inkSourceId)], [traceFormat]);
+    return inkElement('context', [xmlIdAttr(idBare)], [inkSource]);
+}
+function serializeChannel(ch) {
+    var attrs = [attr('name', ch.name)];
+    if (ch.type !== undefined) {
+        attrs.push(attr('type', ch.type));
+    }
+    if (ch.min !== undefined) {
+        attrs.push(attr('min', ch.min));
+    }
+    if (ch.max !== undefined) {
+        attrs.push(attr('max', ch.max));
+    }
+    if (ch.units !== undefined) {
+        attrs.push(attr('units', ch.units));
+    }
+    return inkElement('channel', attrs, []);
+}
+function serializeBrush(brush) {
+    var idBare = stripHash(brush.id);
+    var props = [];
+    var units = brush.units.length > 0 ? brush.units : 'cm';
+    // Size is stored in points after parse; authoring may use pt units with pt values.
+    // ConvertPointsToUnit always treats size as points → target units.
+    var widthOut = pointsToUnit(brush.size.width, units);
+    var heightOut = pointsToUnit(brush.size.height, units);
+    props.push(brushProperty('width', formatUnitValue(widthOut), units), brushProperty('height', formatUnitValue(heightOut), units));
+    var color = resolveBrushColor(brush);
+    props.push(brushProperty('color', color.startsWith('#') ? color : "#" + color));
+    // Effect-specific series (TASK-9003 / shared-codec)
+    // Always emit ignorePressure. Non-none effects emit inkEffects so parse→serialize→parse
+    // preserves the effect token (including pencil, which has no color override).
+    var effect = brush.inkEffect;
+    props.push(brushProperty('ignorePressure', brush.ignorePressure ? '1' : '0'));
+    if (effect !== 'pencil' && brush.rasterOp !== undefined && brush.rasterOp.length > 0) {
+        props.push(brushProperty('tip', (brush.tip != null ? brush.tip : 'ellipse')));
+        props.push(brushProperty('rasterOp', brush.rasterOp));
+    }
+    if (effect !== 'none') {
+        props.push(brushProperty('inkEffects', effectToken(effect)));
+        if (effect !== 'pencil') {
+            props.push(brushProperty('anchorX', (brush.anchorX != null ? brush.anchorX : '0')));
+            props.push(brushProperty('anchorY', (brush.anchorY != null ? brush.anchorY : '0')));
+            props.push(brushProperty('scaleFactor', (brush.scaleFactor != null ? brush.scaleFactor : '0.5')));
+        }
+    }
+    return inkElement('brush', [xmlIdAttr(idBare)], props);
+}
+function brushProperty(name, value, units) {
+    var attrs = [attr('name', name), attr('value', value)];
+    if (units !== undefined) {
+        attrs.push(attr('units', units));
+    }
+    return inkElement('brushProperty', attrs, []);
+}
+function resolveBrushColor(brush) {
+    var effectHex = inkEffectColor(brush.inkEffect);
+    if (effectHex !== undefined) {
+        return effectHex.toUpperCase();
+    }
+    return brush.color.toUpperCase();
+}
+function effectToken(effect) {
+    // Prefer camelCase for roseGold (spec token); others lowercase
+    if (effect === 'roseGold') {
+        return 'roseGold';
+    }
+    return effect;
+}
+function serializeTreeNode(node, traces) {
+    var e_5, _a;
+    if (node.kind === 'trace') {
+        var t = traces[node.traceIndex];
+        if (t === undefined) {
+            return [];
+        }
+        return [serializeTrace(t)];
+    }
+    var kids = [];
+    try {
+        for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            kids.push.apply(kids, __spread(serializeTreeNode(child, traces)));
+        }
+    }
+    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 [inkElement('traceGroup', [], kids)];
+}
+function serializeTrace(trace) {
+    var attrs = [];
+    var contextRef = trace.contextRef.length > 0 ? ensureHash(trace.contextRef) : DEFAULT_CONTEXT_REF;
+    attrs.push(attr('contextRef', contextRef));
+    if (trace.brushRef.length > 0) {
+        attrs.push(attr('brushRef', ensureHash(trace.brushRef)));
+    }
+    if (trace.timeOffset !== undefined) {
+        attrs.push(attr('timeOffset', trace.timeOffset));
+    }
+    var text = encodeTrace(trace.points);
+    var children = text.length > 0 ? [textNode(text)] : [];
+    return inkElement('trace', attrs, children);
+}
+function stripHash(id) {
+    return id.startsWith('#') ? id.slice(1) : id;
+}
+function ensureHash(id) {
+    return id.startsWith('#') ? id : "#" + id;
+}

package/src/features/ink/ink-units.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Length unit conversion for ink brush width/height.
+ *
+ * Formulas match Compression.Base `OfficeParser.GetPointValue` (unit→pt) and
+ * `OfficeSerializer.ConvertPointsToUnit` (pt→unit). EMU factor: 12700 EMU/pt
+ * (DrawingML).
+ */
+/**
+ * DrawingML EMUs per point (OfficeParser / OfficeSerializer).
+ *
+ * @public
+ */
+export declare const EMUS_PER_POINT = 12700;
+/**
+ * Convert a numeric length in `units` to points.
+ * Result is rounded to 2 decimal places (GetPointValue parity).
+ *
+ * @public
+ */
+export declare function unitValueToPoints(value: number, units: string | undefined): number;
+/**
+ * Convert points to the target unit (ConvertPointsToUnit).
+ * Default / unknown unit → cm.
+ *
+ * @public
+ */
+export declare function pointsToUnit(points: number, units: string | undefined): number;
+/**
+ * Format a unit magnitude with invariant 3-decimal style (`"0.###"`).
+ *
+ * @public
+ */
+export declare function formatUnitValue(value: number): string;

package/src/features/ink/ink-units.js

@@ -0,0 +1,92 @@
+/**
+ * Length unit conversion for ink brush width/height.
+ *
+ * Formulas match Compression.Base `OfficeParser.GetPointValue` (unit→pt) and
+ * `OfficeSerializer.ConvertPointsToUnit` (pt→unit). EMU factor: 12700 EMU/pt
+ * (DrawingML).
+ */
+/**
+ * DrawingML EMUs per point (OfficeParser / OfficeSerializer).
+ *
+ * @public
+ */
+export var EMUS_PER_POINT = 12700;
+/**
+ * Convert a numeric length in `units` to points.
+ * Result is rounded to 2 decimal places (GetPointValue parity).
+ *
+ * @public
+ */
+export function unitValueToPoints(value, units) {
+    var u = ((units != null ? units : 'cm')).trim().toLowerCase();
+    var points;
+    switch (u) {
+        case 'pt':
+            points = value;
+            break;
+        case 'mm':
+            points = (value / 25.4) * 72;
+            break;
+        case 'px':
+            points = (value / 4) * 3;
+            break;
+        case 'in':
+            points = value * 72;
+            break;
+        case 'cm':
+            points = (value / 2.54) * 72;
+            break;
+        case 'emu':
+            points = value / EMUS_PER_POINT;
+            break;
+        default:
+            // Unknown unit: treat as EMU-less raw → cm (GetPointValue else branch uses EMU)
+            points = value / EMUS_PER_POINT;
+            break;
+    }
+    return round2(points);
+}
+/**
+ * Convert points to the target unit (ConvertPointsToUnit).
+ * Default / unknown unit → cm.
+ *
+ * @public
+ */
+export function pointsToUnit(points, units) {
+    var u = ((units != null ? units : 'cm')).trim().toLowerCase();
+    switch (u) {
+        case 'pt':
+            return points;
+        case 'mm':
+            return (points * 25.4) / 72;
+        case 'px':
+            return (points * 96) / 72;
+        case 'in':
+            return points / 72;
+        case 'cm':
+            return (points * 2.54) / 72;
+        case 'emu':
+            return points * EMUS_PER_POINT;
+        default:
+            return (points * 2.54) / 72;
+    }
+}
+/**
+ * Format a unit magnitude with invariant 3-decimal style (`"0.###"`).
+ *
+ * @public
+ */
+export function formatUnitValue(value) {
+    if (!Number.isFinite(value)) {
+        return '0';
+    }
+    // Trim trailing zeros after up to 3 decimal places (InvariantCulture "0.###").
+    var fixed = value.toFixed(3);
+    if (!(fixed.indexOf('.') !== -1)) {
+        return fixed;
+    }
+    return fixed.replace(/\.?0+$/, '');
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}

package/src/features/ink/ink-xml.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Small OpenXml element helpers scoped to InkML serialization.
+ */
+import { NamespaceDeclaration, OpenXmlAttribute, OpenXmlChild, OpenXmlElement, OpenXmlText } from '../../core/xml/model';
+import { XML_NAMESPACE, XMLNS_NAMESPACE } from '../../core/xml/model';
+import { INKML_NAMESPACE } from './constants';
+declare const INK_PREFIX = "inkml";
+/** Build an InkML-namespaced element. */
+export declare function inkElement(localName: string, attributes?: ReadonlyArray<OpenXmlAttribute>, children?: ReadonlyArray<OpenXmlChild>, namespaceDeclarations?: ReadonlyArray<NamespaceDeclaration>): OpenXmlElement;
+/** Plain attribute (no namespace). */
+export declare function attr(localName: string, value: string): OpenXmlAttribute;
+/** `xml:id` attribute. */
+export declare function xmlIdAttr(id: string): OpenXmlAttribute;
+/** Text node. */
+export declare function textNode(value: string): OpenXmlText;
+/** `xmlns:inkml` declaration for the ink root. */
+export declare function inkmlNamespaceDecl(): NamespaceDeclaration;
+/** Read attribute by local name (optional namespace filter). */
+export declare function getAttr(el: OpenXmlElement, localName: string, namespaceUri?: string): string | undefined;
+/** Concatenate descendant text of an element. */
+export declare function elementText(el: OpenXmlElement): string;
+/** Direct element children in document order (optional namespace filter). */
+export declare function elementChildren(el: OpenXmlElement, localName?: string, namespaceUri?: string): OpenXmlElement[];
+/** Whether an element is in the InkML namespace (or un-namespaced fixture). */
+export declare function isInkMlElement(el: OpenXmlElement): boolean;
+export { XML_NAMESPACE, XMLNS_NAMESPACE, INKML_NAMESPACE, INK_PREFIX };

package/src/features/ink/ink-xml.js

@@ -0,0 +1,165 @@
+/**
+ * Small OpenXml element helpers scoped to InkML serialization.
+ */
+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 { XML_NAMESPACE, XMLNS_NAMESPACE } from '../../core/xml/model';
+import { INKML_NAMESPACE } from './constants';
+var INK_PREFIX = 'inkml';
+/** Build an InkML-namespaced element. */
+export function inkElement(localName, attributes, children, namespaceDeclarations) {
+    if (attributes === void 0) { attributes = []; }
+    if (children === void 0) { children = []; }
+    if (namespaceDeclarations === void 0) { namespaceDeclarations = []; }
+    return { kind: 'element',
+        namespaceUri: INKML_NAMESPACE,
+        localName: localName,
+        prefix: INK_PREFIX,
+        attributes: attributes,
+        namespaceDeclarations: namespaceDeclarations,
+        children: children,
+    };
+}
+/** Plain attribute (no namespace). */
+export function attr(localName, value) {
+    return { namespaceUri: '', localName: localName, prefix: '', value: value };
+}
+/** `xml:id` attribute. */
+export function xmlIdAttr(id) {
+    return {
+        namespaceUri: XML_NAMESPACE,
+        localName: 'id',
+        prefix: 'xml',
+        value: id,
+    };
+}
+/** Text node. */
+export function textNode(value) {
+    return { kind: 'text', value: value };
+}
+/** `xmlns:inkml` declaration for the ink root. */
+export function inkmlNamespaceDecl() {
+    return { prefix: INK_PREFIX, namespaceUri: INKML_NAMESPACE };
+}
+/** Read attribute by local name (optional namespace filter). */
+export function getAttr(el, localName, namespaceUri) {
+    var e_1, _a, e_2, _b;
+    try {
+        for (var _c = __values(el.attributes), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var a = _d.value;
+            if (a.localName !== localName) {
+                continue;
+            }
+            if (namespaceUri !== undefined && a.namespaceUri !== namespaceUri) {
+                continue;
+            }
+            return a.value;
+        }
+    }
+    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; }
+    }
+    // xml:id may appear as prefixed without namespace resolution in hand-built trees
+    if (localName === 'id') {
+        try {
+            for (var _e = __values(el.attributes), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var a = _f.value;
+                if (a.localName === 'id' && (a.prefix === 'xml' || a.namespaceUri === XML_NAMESPACE)) {
+                    return a.value;
+                }
+            }
+        }
+        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; }
+        }
+    }
+    return undefined;
+}
+/** Concatenate descendant text of an element. */
+export function elementText(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 += elementText(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;
+}
+/** Direct element children in document order (optional namespace filter). */
+export function elementChildren(el, localName, namespaceUri) {
+    if (namespaceUri === void 0) { namespaceUri = INKML_NAMESPACE; }
+    var e_4, _a;
+    var result = [];
+    try {
+        for (var _b = __values(el.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (child.kind !== 'element') {
+                continue;
+            }
+            if (namespaceUri !== '' && child.namespaceUri !== namespaceUri && child.namespaceUri !== '') {
+                // Allow empty namespaceUri for hand-built / defaulted fixtures when local names match InkML.
+                if (child.namespaceUri !== INKML_NAMESPACE && namespaceUri === INKML_NAMESPACE) {
+                    // still accept un-namespaced ink fixtures if localName matches
+                    if (localName !== undefined && child.localName !== localName) {
+                        continue;
+                    }
+                    if (localName === undefined) {
+                        // only accept if it looks like ink content (caller filters)
+                    }
+                }
+            }
+            if (localName !== undefined && child.localName !== localName) {
+                continue;
+            }
+            if (namespaceUri === INKML_NAMESPACE &&
+                child.namespaceUri !== INKML_NAMESPACE &&
+                child.namespaceUri !== '') {
+                continue;
+            }
+            result.push(child);
+        }
+    }
+    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; }
+    }
+    return result;
+}
+/** Whether an element is in the InkML namespace (or un-namespaced fixture). */
+export function isInkMlElement(el) {
+    return el.namespaceUri === INKML_NAMESPACE || el.namespaceUri === '';
+}
+export { XML_NAMESPACE, XMLNS_NAMESPACE, INKML_NAMESPACE, INK_PREFIX };