@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/drawing/index.d.ts

@@ -0,0 +1,13 @@
+export * from './authoring';
+export * from './body-pr';
+export * from './drawing-shape';
+export * from './encode-builders';
+export * from './fill-format';
+export * from './host-codec';
+export * from './line-format';
+export * from './parse-register';
+export * from './shape-types';
+export * from './sp-pr';
+export * from './text-frame';
+export { ANCHOR_DEFAULT_SIDE_DIST_EMU, CHART_GRAPHIC_DATA_URI, CHART_GRAPHIC_DATA_URI_STRICT, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_GRAPHIC_DATA_URI_STRICT, DRAWING, DrawingEncoding, DrawingExtent, DrawingPlacement, DrawingVariant, GroupOptions, ShapeBodyPrOptions, WORDPROCESSING_INK_URI, } from './types';
+export * from './wrap-format';

package/src/features/drawing/index.js

@@ -0,0 +1,33 @@
+export * from './authoring';
+export * from './body-pr';
+export * from './drawing-shape';
+export * from './encode-builders';
+export * from './fill-format';
+export * from './host-codec';
+export * from './line-format';
+export * from './parse-register';
+export * from './shape-types';
+export * from './sp-pr';
+export * from './text-frame';
+export { ANCHOR_DEFAULT_SIDE_DIST_EMU, CHART_GRAPHIC_DATA_URI, CHART_GRAPHIC_DATA_URI_STRICT, DIAGRAM_GRAPHIC_DATA_URI, DIAGRAM_GRAPHIC_DATA_URI_STRICT, DRAWING, DrawingVariant, WORDPROCESSING_INK_URI, } from './types';
+export * from './wrap-format';
+/**
+ * Drawing shapes foundation — preserve non-picture DrawingML/VML and author
+ * dual MC AlternateContent hosts (`wps` Choice + corpus-backed VML Fallback).
+ *
+ * @packageDocumentation
+ */
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { Paragraph } from '../document/paragraph';
+import { appendGroupToParagraph, appendShapeToParagraph } from './authoring';
+import { registerDrawingFeature } from './parse-register';
+Paragraph.prototype.appendShape = function (autoShapeType, width, height) {
+    return appendShapeToParagraph(this, autoShapeType, width, height);
+};
+Paragraph.prototype.appendGroup = function (options) {
+    return appendGroupToParagraph(this, options);
+};
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerDrawingFeature();
+});
+registerDrawingFeature();

package/src/features/drawing/line-format.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Public LineFormat owned by Shape (Shape.md §7).
+ * @packageDocumentation
+ */
+import { Color } from '../document/color';
+import { ArrowheadSize, ArrowheadStyle, LineCap, LineStyle, LineDashing, ShapeLine } from './sp-pr';
+/** Default line enabled for newly authored shapes. @public */
+export declare const DEFAULT_SHAPE_LINE_ENABLED: boolean;
+/** Default solid line color for newly authored shapes. @public */
+export declare const DEFAULT_SHAPE_LINE_COLOR: Color;
+/** Default line width in EMU (1 pt). @public */
+export declare const DEFAULT_SHAPE_LINE_WIDTH_EMU: number;
+/** Default line dash for newly authored shapes. @public */
+export declare const DEFAULT_SHAPE_LINE_DASH: LineDashing;
+/**
+ * Modeled default outline used when authoring new AutoShapes (solid black 1 pt).
+ * Parse paths must not invent this when residual `a:ln` is absent.
+ * @private
+ */
+export declare function defaultAuthoredShapeLine(): ShapeLine;
+/**
+ * Owner hooks for {@link LineFormat}.
+ * @private
+ */
+export interface LineFormatOwner {
+    /** @private */
+    readShapeLineState(): ShapeLine | undefined;
+    /** @private */
+    writeShapeLineState(value: ShapeLine | undefined): void;
+}
+/**
+ * Shape line formatting surface (`a:ln`).
+ * @public
+ */
+export declare class LineFormat {
+    private readonly owner;
+    /** @private */
+    constructor(owner: LineFormatOwner);
+    /**
+     * Whether an explicit line is present. `false` maps to `a:ln/a:noFill`.
+     * @public
+     */
+    line: boolean;
+    /**
+     * Solid line color. Unresolved theme returns {@link Color.Transparent}.
+     * @public
+     */
+    color: Color;
+    /** @public */
+    dashStyle: LineDashing;
+    /** @public */
+    capStyle: LineCap;
+    /**
+     * Compound line style. Currently only {@link LineStyle.Single} is modeled.
+     * @public
+     */
+    style: LineStyle;
+    /**
+     * Line weight in points (`a:ln/@w` EMU at the codec boundary).
+     * @public
+     */
+    weight: number | undefined;
+    /**
+     * Transparency percent 0–100 (0 = opaque).
+     * @public
+     */
+    transparency: number;
+    /** @public */
+    beginArrowheadStyle: ArrowheadStyle;
+    /** @public */
+    endArrowheadStyle: ArrowheadStyle;
+    /** @public */
+    beginArrowheadSize: ArrowheadSize | undefined;
+    /** @public */
+    endArrowheadSize: ArrowheadSize | undefined;
+}

package/src/features/drawing/line-format.js

@@ -0,0 +1,343 @@
+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);
+};
+/**
+ * Public LineFormat owned by Shape (Shape.md §7).
+ * @packageDocumentation
+ */
+import { Color, colorFromWire, colorToHexWire } from '../document/color';
+import { emuToPoint, pointToEmus } from '../document/length';
+import { DocxError } from '../../core/errors/docx-error';
+import { alphaToTransparency, ArrowheadStyle, isLineCap, isLineEndSize, isLineEndType, isLineDashing, LineCap, LineStyle, LineDashing, ShapeLineKind, transparencyToAlpha, } from './sp-pr';
+/** Default line enabled for newly authored shapes. @public */
+export var DEFAULT_SHAPE_LINE_ENABLED = true;
+/** Default solid line color for newly authored shapes. @public */
+export var DEFAULT_SHAPE_LINE_COLOR = Color.Black;
+/** Default line width in EMU (1 pt). @public */
+export var DEFAULT_SHAPE_LINE_WIDTH_EMU = 12700;
+/** Default line dash for newly authored shapes. @public */
+export var DEFAULT_SHAPE_LINE_DASH = LineDashing.Solid;
+/**
+ * Modeled default outline used when authoring new AutoShapes (solid black 1 pt).
+ * Parse paths must not invent this when residual `a:ln` is absent.
+ * @private
+ */
+export function defaultAuthoredShapeLine() {
+    var srgb = colorToHexWire(DEFAULT_SHAPE_LINE_COLOR);
+    return {
+        kind: ShapeLineKind.Solid,
+        widthEmu: DEFAULT_SHAPE_LINE_WIDTH_EMU,
+        srgbColor: srgb.length > 0 ? srgb : '000000',
+        alpha: undefined,
+        dash: DEFAULT_SHAPE_LINE_DASH,
+        cap: undefined,
+        beginArrowType: undefined,
+        beginArrowSize: undefined,
+        endArrowType: undefined,
+        endArrowSize: undefined,
+        residual: false,
+    };
+}
+function emptySolidLine(partial) {
+    var defaults = defaultAuthoredShapeLine();
+    return {
+        kind: ShapeLineKind.Solid,
+        widthEmu: partial !== undefined && partial.widthEmu !== undefined ? partial.widthEmu : defaults.widthEmu,
+        srgbColor: partial !== undefined && partial.srgbColor !== undefined ? partial.srgbColor : defaults.srgbColor,
+        alpha: partial !== undefined ? partial.alpha : undefined,
+        dash: partial !== undefined && partial.dash !== undefined ? partial.dash : defaults.dash,
+        cap: partial !== undefined ? partial.cap : undefined,
+        beginArrowType: partial !== undefined ? partial.beginArrowType : undefined,
+        beginArrowSize: partial !== undefined ? partial.beginArrowSize : undefined,
+        endArrowType: partial !== undefined ? partial.endArrowType : undefined,
+        endArrowSize: partial !== undefined ? partial.endArrowSize : undefined,
+        residual: false,
+    };
+}
+function noneLine() {
+    return {
+        kind: ShapeLineKind.None,
+        widthEmu: undefined,
+        srgbColor: undefined,
+        alpha: undefined,
+        dash: undefined,
+        cap: undefined,
+        beginArrowType: undefined,
+        beginArrowSize: undefined,
+        endArrowType: undefined,
+        endArrowSize: undefined,
+        residual: false,
+    };
+}
+function ensureSolid(state) {
+    if (state !== undefined && state.kind === ShapeLineKind.Solid) {
+        return state;
+    }
+    return emptySolidLine(state);
+}
+/**
+ * Shape line formatting surface (`a:ln`).
+ * @public
+ */
+var LineFormat = /** @class */ (function () {
+    /** @private */
+    function LineFormat(owner) {
+        this.owner = owner;
+    }
+    Object.defineProperty(LineFormat.prototype, "line", {
+        /**
+         * Whether an explicit line is present. `false` maps to `a:ln/a:noFill`.
+         * @public
+         */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined) {
+                return false;
+            }
+            return state.kind !== ShapeLineKind.None;
+        },
+        set: function (value) {
+            if (value !== true && value !== false) {
+                throw new RangeError('LineFormat.line must be a boolean');
+            }
+            if (!value) {
+                this.owner.writeShapeLineState(noneLine());
+                return;
+            }
+            this.owner.writeShapeLineState(ensureSolid(this.owner.readShapeLineState()));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "color", {
+        /**
+         * Solid line color. Unresolved theme returns {@link Color.Transparent}.
+         * @public
+         */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined || state.kind !== ShapeLineKind.Solid || state.srgbColor === undefined) {
+                return Color.Transparent;
+            }
+            var mapped = colorFromWire(state.srgbColor);
+            return mapped !== undefined ? mapped : Color.Transparent;
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new RangeError('LineFormat.color must be a Color enum member');
+            }
+            if (value === Color.Transparent) {
+                this.owner.writeShapeLineState(noneLine());
+                return;
+            }
+            var hex = colorToHexWire(value);
+            if (hex.length === 0) {
+                throw new RangeError('LineFormat.color could not be serialized to sRGB');
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, srgbColor: hex, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "dashStyle", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined || state.dash === undefined) {
+                return LineDashing.Solid;
+            }
+            return isLineDashing(state.dash) ? state.dash : LineDashing.Unknown;
+        },
+        set: function (value) {
+            if (!isLineDashing(value)) {
+                throw new RangeError("Invalid LineFormat.dashStyle \"" + String(value) + "\"");
+            }
+            if (value === LineDashing.Unknown) {
+                throw new RangeError('LineFormat.dashStyle cannot be set to LineDashing.Unknown');
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, dash: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "capStyle", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined || state.cap === undefined) {
+                return LineCap.Flat;
+            }
+            return state.cap;
+        },
+        set: function (value) {
+            if (!isLineCap(value)) {
+                throw new RangeError("Invalid LineFormat.capStyle \"" + String(value) + "\"");
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, cap: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "style", {
+        /**
+         * Compound line style. Currently only {@link LineStyle.Single} is modeled.
+         * @public
+         */
+        get: function () {
+            return LineStyle.Single;
+        },
+        set: function (value) {
+            if (value !== LineStyle.Single) {
+                throw new RangeError("Invalid LineFormat.style \"" + String(value) + "\"; only LineStyle.Single is supported");
+            }
+            this.owner.writeShapeLineState(ensureSolid(this.owner.readShapeLineState()));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "weight", {
+        /**
+         * Line weight in points (`a:ln/@w` EMU at the codec boundary).
+         * @public
+         */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined || state.widthEmu === undefined) {
+                return undefined;
+            }
+            return emuToPoint(state.widthEmu);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                var base_1 = ensureSolid(this.owner.readShapeLineState());
+                this.owner.writeShapeLineState(__assign({}, base_1, { kind: ShapeLineKind.Solid, widthEmu: undefined, residual: false }));
+                return;
+            }
+            if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+                throw new RangeError('LineFormat.weight must be a finite non-negative number of points');
+            }
+            var widthEmu;
+            try {
+                widthEmu = pointToEmus(value === 0 ? 0.0001 : value);
+                if (value === 0) {
+                    widthEmu = 0;
+                }
+            }
+            catch (error) {
+                if (error instanceof RangeError) {
+                    throw new RangeError('LineFormat.weight must be a finite non-negative number of points');
+                }
+                throw error;
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, widthEmu: widthEmu, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "transparency", {
+        /**
+         * Transparency percent 0–100 (0 = opaque).
+         * @public
+         */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            if (state === undefined || state.kind !== ShapeLineKind.Solid) {
+                return 0;
+            }
+            return alphaToTransparency(state.alpha);
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100) {
+                throw new RangeError('LineFormat.transparency must be a finite number from 0 through 100');
+            }
+            var current = this.owner.readShapeLineState();
+            if (current === undefined || current.kind !== ShapeLineKind.Solid) {
+                throw new DocxError('content/invalid-shape', 'LineFormat.transparency requires an explicit solid line; set color or line first');
+            }
+            var alpha = transparencyToAlpha(value);
+            this.owner.writeShapeLineState(__assign({}, current, { alpha: alpha >= 100000 ? undefined : alpha, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "beginArrowheadStyle", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            var t = state !== undefined ? state.beginArrowType : undefined;
+            return t !== undefined ? t : ArrowheadStyle.None;
+        },
+        set: function (value) {
+            if (!isLineEndType(value)) {
+                throw new RangeError("Invalid LineFormat.beginArrowheadStyle \"" + String(value) + "\"");
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, beginArrowType: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "endArrowheadStyle", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            var t = state !== undefined ? state.endArrowType : undefined;
+            return t !== undefined ? t : ArrowheadStyle.None;
+        },
+        set: function (value) {
+            if (!isLineEndType(value)) {
+                throw new RangeError("Invalid LineFormat.endArrowheadStyle \"" + String(value) + "\"");
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, endArrowType: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "beginArrowheadSize", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            return state !== undefined ? state.beginArrowSize : undefined;
+        },
+        set: function (value) {
+            if (value !== undefined && !isLineEndSize(value)) {
+                throw new RangeError("Invalid LineFormat.beginArrowheadSize \"" + String(value) + "\"");
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, beginArrowSize: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LineFormat.prototype, "endArrowheadSize", {
+        /** @public */
+        get: function () {
+            var state = this.owner.readShapeLineState();
+            return state !== undefined ? state.endArrowSize : undefined;
+        },
+        set: function (value) {
+            if (value !== undefined && !isLineEndSize(value)) {
+                throw new RangeError("Invalid LineFormat.endArrowheadSize \"" + String(value) + "\"");
+            }
+            var base = ensureSolid(this.owner.readShapeLineState());
+            this.owner.writeShapeLineState(__assign({}, base, { kind: ShapeLineKind.Solid, endArrowSize: value, residual: false }));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return LineFormat;
+}());
+export { LineFormat };

package/src/features/drawing/parse-register.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Drawing feature registration, parse handlers, and document/paragraph queries.
+ *
+ * @private
+ */
+import { WordDocument } from '../document/document';
+import { Paragraph } from '../document/paragraph';
+import { FeatureRunParagraphItem, ParagraphItem } from '../document/text-range';
+import { OpenXmlElement } from '../../core/xml/index';
+import { DrawingShape } from './drawing-shape';
+export declare function isInlinePictureDrawing(element: OpenXmlElement): boolean;
+export declare function drawingIsOwnedByOtherFeature(drawing: OpenXmlElement): boolean;
+export declare function parseDrawingShape(element: OpenXmlElement): DrawingShape | undefined;
+export declare function parseVmlPict(element: OpenXmlElement): DrawingShape | undefined;
+/**
+ * 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 declare function parseAlternateContentDrawing(element: OpenXmlElement): DrawingShape | undefined;
+export declare function drawingShapesFromLeaves(items: ReadonlyArray<ParagraphItem>): DrawingShape[];
+export declare function maxDocPrIdInDocument(document: WordDocument): number;
+export declare function allocateDocPrId(paragraph: Paragraph): number;
+/**
+ * @private
+ * Test hook */
+export declare function resetDrawingFeatureForTests(): void;
+/**
+ * @private
+ * Register non-picture DrawingML, VML, and MC drawing run-leaf handlers. Idempotent. */
+export declare function registerDrawingFeature(): void;
+/**
+ * Whether a paragraph item is a modeled drawing shape (projected leaf or wrapper).
+ *
+ * @private
+ */
+export declare function isDrawingShapeLeaf(item: ParagraphItem | DrawingShape): item is (FeatureRunParagraphItem & {
+    value: DrawingShape;
+}) | DrawingShape;
+/**
+ * Drawing shapes in a paragraph, in document order.
+ *
+ * @private
+ */
+export declare function drawingsInParagraph(paragraph: Paragraph): ReadonlyArray<DrawingShape>;
+/**
+ * Drawing shapes in the Main Document body, in document order.
+ *
+ * @private
+ */
+export declare function drawingsInDocument(document: WordDocument): ReadonlyArray<DrawingShape>;