@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/sections/column-collection.d.ts

@@ -0,0 +1,119 @@
+import { OpenXmlElement } from '../../core/xml/index';
+import { Column } from './column';
+/**
+ * Ordered text columns for a section (`w:cols` / `CT_Columns`).
+ *
+ * Public surface is add-only: {@link count}, {@link add}, index properties, and iteration.
+ * Equal-width / separator / default spacing stay internal for OOXML round-trip.
+ *
+ * @public
+ */
+export declare class ColumnCollection {
+    private readonly items;
+    private equalWidthValue;
+    private separatorValue;
+    private spacingValue;
+    /** When equal-width, schema `w:num` may exceed authored `w:col` children. */
+    private equalWidthCount;
+    /**
+     * @private
+     */
+    constructor();
+    /**
+     * Number of columns in this section.
+     */
+    readonly count: number;
+    /**
+     * Append a column definition (switches the section to unequal widths).
+     *
+     * @param width - Column width in points
+     * @param space - Space after this column in points (default: half-inch)
+     */
+    add(width: number, space?: number): Column;
+    /**
+     * Column at zero-based index, or `undefined` when out of range.
+     */
+    item(index: number): Column | undefined;
+    [index: number]: Column;
+    /**
+     * Iterate authored column definitions (empty when equal-width with no `w:col` children).
+     */
+    [Symbol.iterator](): Iterator<Column>;
+    /**
+     * @private
+     */
+    readonly equalWidth: boolean;
+    /**
+     * @private
+     */
+    setEqualWidth(value: boolean): void;
+    /**
+     * @private
+     */
+    readonly separator: boolean;
+    /**
+     * @private
+     */
+    setSeparator(value: boolean): void;
+    /**
+     * @private
+     */
+    readonly spacing: number;
+    /**
+     * @private
+     */
+    setSpacing(value: number): void;
+    /**
+     * @private
+     */
+    setEqualWidthCount(count: number): void;
+    /**
+     * @private
+     * Replace contents from a parsed `w:cols` model (atomic).
+     */
+    replaceFromParsed(options: {
+        readonly equalWidth: boolean;
+        readonly separator: boolean;
+        readonly spacing: number;
+        readonly count: number;
+        readonly columns: ReadonlyArray<{
+            readonly width: number;
+            readonly space: number;
+        }>;
+    }): void;
+    /**
+     * @private
+     */
+    clearToDefault(): void;
+    /**
+     * @private
+     */
+    cloneDeep(): ColumnCollection;
+    /**
+     * @private
+     * `true` when serialization may omit `w:cols` (schema default single equal column).
+     */
+    isDefault(): boolean;
+    /**
+     * @private
+     */
+    isDefaultTextColumns(): boolean;
+    /**
+     * @private
+     */
+    toOpenXmlElement(): OpenXmlElement | undefined;
+}
+/**
+ * Factory: n equal-width columns.
+ *
+ * @private
+ */
+export declare function equalWidthColumns(count: number, spacing?: number): ColumnCollection;
+/**
+ * @private
+ */
+export declare function parseTextColumns(element: OpenXmlElement): ColumnCollection | undefined;
+/**
+ * @private
+ */
+export declare function serializeTextColumns(value: ColumnCollection): OpenXmlElement;

package/src/features/sections/column-collection.js

@@ -0,0 +1,478 @@
+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 { pointToTwips, twipsToPoint } from '../document/length';
+import { elementChildren, isWml, wmlAttr, wmlElement, WML } from '../document/wml';
+import { Column } from './column';
+import { DEFAULT_COLUMN_SPACE, TEXT_COLUMNS_MAX, sectionsError, validateColumnCount, validateSectionLength, } from './section-validation';
+/**
+ * Ordered text columns for a section (`w:cols` / `CT_Columns`).
+ *
+ * Public surface is add-only: {@link count}, {@link add}, index properties, and iteration.
+ * Equal-width / separator / default spacing stay internal for OOXML round-trip.
+ *
+ * @public
+ */
+var ColumnCollection = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ColumnCollection() {
+        this.items = [];
+        this.equalWidthValue = true;
+        this.separatorValue = false;
+        this.spacingValue = DEFAULT_COLUMN_SPACE;
+        /** When equal-width, schema `w:num` may exceed authored `w:col` children. */
+        this.equalWidthCount = 1;
+        // Default: one equal-width column (omit `w:cols` on serialize).
+    }
+    Object.defineProperty(ColumnCollection.prototype, "count", {
+        /**
+         * Number of columns in this section.
+         */
+        get: function () {
+            if (this.equalWidthValue) {
+                return this.equalWidthCount;
+            }
+            return this.items.length === 0 ? 1 : this.items.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Append a column definition (switches the section to unequal widths).
+     *
+     * @param width - Column width in points
+     * @param space - Space after this column in points (default: half-inch)
+     */
+    ColumnCollection.prototype.add = function (width, space) {
+        if (space === void 0) { space = DEFAULT_COLUMN_SPACE; }
+        validateSectionLength(width, 'Column.width');
+        validateSectionLength(space, 'Column.space');
+        if (this.items.length >= TEXT_COLUMNS_MAX) {
+            throw sectionsError("text columns cannot exceed " + String(TEXT_COLUMNS_MAX));
+        }
+        if (this.equalWidthValue) {
+            // Transition: freeze equal-width into explicit columns when first unequal add occurs.
+            this.equalWidthValue = false;
+            if (this.items.length === 0 && this.equalWidthCount > 1) {
+                // No prior authored cols — start fresh with the added column only.
+                this.equalWidthCount = 1;
+            }
+        }
+        var column = new Column(width, space);
+        this.items.push(column);
+        return column;
+    };
+    /**
+     * Column at zero-based index, or `undefined` when out of range.
+     */
+    ColumnCollection.prototype.item = function (index) {
+        if (!Number.isInteger(index) || index < 0) {
+            return undefined;
+        }
+        if (this.equalWidthValue) {
+            // Equal-width mode has no stable per-column objects unless previously materialized.
+            return this.items[index];
+        }
+        return this.items[index];
+    };
+    /**
+     * Iterate authored column definitions (empty when equal-width with no `w:col` children).
+     */
+    ColumnCollection.prototype[Symbol.iterator] = function () {
+        var snapshot = this.items.slice();
+        var i = 0;
+        return {
+            next: function () {
+                if (i >= snapshot.length) {
+                    return { done: true, value: undefined };
+                }
+                var value = snapshot[i];
+                i += 1;
+                return { done: false, value: value };
+            },
+        };
+    };
+    Object.defineProperty(ColumnCollection.prototype, "equalWidth", {
+        // —— internal OOXML state (not public API) ——
+        /**
+         * @private
+         */
+        get: function () {
+            return this.equalWidthValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.setEqualWidth = function (value) {
+        this.equalWidthValue = value === true;
+        if (this.equalWidthValue && this.equalWidthCount < 1) {
+            this.equalWidthCount = 1;
+        }
+    };
+    Object.defineProperty(ColumnCollection.prototype, "separator", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.separatorValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.setSeparator = function (value) {
+        this.separatorValue = value === true;
+    };
+    Object.defineProperty(ColumnCollection.prototype, "spacing", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.spacingValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.setSpacing = function (value) {
+        validateSectionLength(value, 'ColumnCollection.spacing');
+        this.spacingValue = value;
+    };
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.setEqualWidthCount = function (count) {
+        validateColumnCount(count);
+        this.equalWidthCount = count;
+        this.equalWidthValue = true;
+    };
+    /**
+     * @private
+     * Replace contents from a parsed `w:cols` model (atomic).
+     */
+    ColumnCollection.prototype.replaceFromParsed = function (options) {
+        this.equalWidthValue = options.equalWidth;
+        this.separatorValue = options.separator;
+        this.spacingValue = options.spacing;
+        this.equalWidthCount = options.count;
+        this.items.length = 0;
+        for (var i = 0; i < options.columns.length; i++) {
+            var c = options.columns[i];
+            if (c === undefined) {
+                continue;
+            }
+            this.items.push(new Column(c.width, c.space));
+        }
+        if (!this.equalWidthValue && this.items.length > 0) {
+            this.equalWidthCount = this.items.length;
+        }
+    };
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.clearToDefault = function () {
+        this.items.length = 0;
+        this.equalWidthValue = true;
+        this.separatorValue = false;
+        this.spacingValue = DEFAULT_COLUMN_SPACE;
+        this.equalWidthCount = 1;
+    };
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.cloneDeep = function () {
+        var copy = new ColumnCollection();
+        copy.replaceFromParsed({
+            equalWidth: this.equalWidthValue,
+            separator: this.separatorValue,
+            spacing: this.spacingValue,
+            count: this.equalWidthCount,
+            columns: this.items.map(function (c) { return ({ width: c.width, space: c.spacing }); }),
+        });
+        return copy;
+    };
+    /**
+     * @private
+     * `true` when serialization may omit `w:cols` (schema default single equal column).
+     */
+    ColumnCollection.prototype.isDefault = function () {
+        return (this.isDefaultTextColumns());
+    };
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.isDefaultTextColumns = function () {
+        if (!this.equalWidthValue) {
+            return false;
+        }
+        if (this.separatorValue) {
+            return false;
+        }
+        if (this.equalWidthCount !== 1) {
+            return false;
+        }
+        if (this.spacingValue !== DEFAULT_COLUMN_SPACE) {
+            return false;
+        }
+        return this.items.length === 0;
+    };
+    /**
+     * @private
+     */
+    ColumnCollection.prototype.toOpenXmlElement = function () {
+        if (this.isDefaultTextColumns()) {
+            return undefined;
+        }
+        return serializeTextColumns(this);
+    };
+    return ColumnCollection;
+}());
+export { ColumnCollection };
+// Indexer implementation for `columns[i]` — assign on prototype for ES5 emit.
+function defineColumnIndexAccessors() {
+    var proto = ColumnCollection.prototype;
+    var _loop_1 = function (i) {
+        var index = i;
+        Object.defineProperty(proto, index, {
+            configurable: true,
+            enumerable: false,
+            get: function () {
+                return this.item(index);
+            },
+        });
+    };
+    for (var i = 0; i < TEXT_COLUMNS_MAX; i++) {
+        _loop_1(i);
+    }
+}
+defineColumnIndexAccessors();
+/**
+ * Factory: n equal-width columns.
+ *
+ * @private
+ */
+export function equalWidthColumns(count, spacing) {
+    if (spacing === void 0) { spacing = DEFAULT_COLUMN_SPACE; }
+    validateColumnCount(count);
+    validateSectionLength(spacing, 'spacing');
+    var cols = new ColumnCollection();
+    cols.setSpacing(spacing);
+    cols.setEqualWidthCount(count);
+    cols.setSeparator(false);
+    return cols;
+}
+/**
+ * @private
+ */
+export function parseTextColumns(element) {
+    var e_1, _a;
+    var equalWidthRaw = wmlAttributeLocal(element, 'equalWidth');
+    // Schema default equalWidth=true when attribute omitted.
+    var equalWidth = true;
+    if (equalWidthRaw !== undefined) {
+        var parsed = parseOnOffAttributeLocal(equalWidthRaw);
+        if (parsed === undefined) {
+            return undefined;
+        }
+        equalWidth = parsed;
+    }
+    var sepRaw = wmlAttributeLocal(element, 'sep');
+    var separator = false;
+    if (sepRaw !== undefined) {
+        var parsed = parseOnOffAttributeLocal(sepRaw);
+        if (parsed === undefined) {
+            return undefined;
+        }
+        separator = parsed;
+    }
+    var spacing = DEFAULT_COLUMN_SPACE;
+    var spaceRaw = wmlAttributeLocal(element, 'space');
+    if (spaceRaw !== undefined) {
+        var tw = parseTwipsLocal(spaceRaw);
+        if (tw === undefined) {
+            return undefined;
+        }
+        spacing = twipsToPoint(tw);
+    }
+    var count = 1;
+    var numRaw = wmlAttributeLocal(element, 'num');
+    if (numRaw !== undefined) {
+        if (!/^\d+$/.test(numRaw)) {
+            return undefined;
+        }
+        count = Number.parseInt(numRaw, 10);
+        if (count < 1 || count > TEXT_COLUMNS_MAX) {
+            return undefined;
+        }
+    }
+    var columns = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, 'col')) {
+                // Unmodeled child → keep whole cols opaque at caller.
+                return undefined;
+            }
+            var wRaw = wmlAttributeLocal(child, 'w');
+            if (wRaw === undefined) {
+                return undefined;
+            }
+            var wTw = parseTwipsLocal(wRaw);
+            if (wTw === undefined) {
+                return undefined;
+            }
+            var colSpace = DEFAULT_COLUMN_SPACE;
+            var colSpaceRaw = wmlAttributeLocal(child, 'space');
+            if (colSpaceRaw !== undefined) {
+                var sTw = parseTwipsLocal(colSpaceRaw);
+                if (sTw === undefined) {
+                    return undefined;
+                }
+                colSpace = twipsToPoint(sTw);
+            }
+            columns.push({ width: twipsToPoint(wTw), space: colSpace });
+            if (columns.length > TEXT_COLUMNS_MAX) {
+                return undefined;
+            }
+        }
+    }
+    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; }
+    }
+    // When unequal and authored cols present, prefer list length as count.
+    if (!equalWidth && columns.length > 0) {
+        count = columns.length;
+    }
+    else if (equalWidth && columns.length === 0 && numRaw === undefined) {
+        count = 1;
+    }
+    var result = new ColumnCollection();
+    result.replaceFromParsed({
+        equalWidth: equalWidth,
+        separator: separator,
+        spacing: spacing,
+        count: count,
+        columns: columns,
+    });
+    return result;
+}
+/**
+ * @private
+ */
+export function serializeTextColumns(value) {
+    var e_2, _a, e_3, _b;
+    var attrs = [];
+    var equalWidth = value.equalWidth;
+    var count = value.count;
+    var spacing = value.spacing;
+    var separator = value.separator;
+    if (!equalWidth) {
+        attrs.push(wmlAttr('equalWidth', '0'));
+    }
+    // Emit num when not the default single column.
+    if (count !== 1) {
+        attrs.push(wmlAttr('num', String(count)));
+    }
+    if (spacing !== DEFAULT_COLUMN_SPACE) {
+        attrs.push(wmlAttr('space', String(pointToTwips(spacing))));
+    }
+    if (separator) {
+        attrs.push(wmlAttr('sep', '1'));
+    }
+    var children = [];
+    if (!equalWidth) {
+        try {
+            for (var value_1 = __values(value), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
+                var col = value_1_1.value;
+                var colAttrs = [
+                    wmlAttr('w', String(pointToTwips(col.width))),
+                ];
+                if (col.spacing !== DEFAULT_COLUMN_SPACE) {
+                    colAttrs.push(wmlAttr('space', String(pointToTwips(col.spacing))));
+                }
+                children.push(wmlElement('col', { attributes: colAttrs }));
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (value_1_1 && !value_1_1.done && (_a = value_1.return)) _a.call(value_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    else {
+        try {
+            // Equal-width may still carry residual authored `w:col` children for preservation.
+            for (var value_2 = __values(value), value_2_1 = value_2.next(); !value_2_1.done; value_2_1 = value_2.next()) {
+                var col = value_2_1.value;
+                var colAttrs = [
+                    wmlAttr('w', String(pointToTwips(col.width))),
+                ];
+                if (col.spacing !== DEFAULT_COLUMN_SPACE) {
+                    colAttrs.push(wmlAttr('space', String(pointToTwips(col.spacing))));
+                }
+                children.push(wmlElement('col', { attributes: colAttrs }));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (value_2_1 && !value_2_1.done && (_b = value_2.return)) _b.call(value_2);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    }
+    return wmlElement('cols', {
+        attributes: attrs,
+        children: children.length === 0 ? undefined : children,
+    });
+}
+function wmlAttributeLocal(el, localName) {
+    var found = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === WML || a.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function parseTwipsLocal(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    var n = Number.parseInt(raw, 10);
+    // Imported bound matches section-validation TWIPS_MAX via page size path; keep local for cols.
+    if (n < 0 || n > 31680) {
+        return undefined;
+    }
+    return n;
+}
+function parseOnOffAttributeLocal(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return true;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}

package/src/features/sections/column.d.ts

@@ -0,0 +1,15 @@
+/**
+ * One explicit text column (`CT_Column`).
+ *
+ * @public
+ */
+export declare class Column {
+    private widthValue;
+    private spacingValue;
+    /**
+     * @private
+     */
+    constructor(width: number, spacing: number);
+    width: number;
+    spacing: number;
+}

package/src/features/sections/column.js

@@ -0,0 +1,37 @@
+import { validateSectionLength } from './section-validation';
+/**
+ * One explicit text column (`CT_Column`).
+ *
+ * @public
+ */
+var Column = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Column(width, spacing) {
+        this.widthValue = validateSectionLength(width, 'column.width');
+        this.spacingValue = validateSectionLength(spacing, 'column.spacing');
+    }
+    Object.defineProperty(Column.prototype, "width", {
+        get: function () {
+            return this.widthValue;
+        },
+        set: function (value) {
+            this.widthValue = validateSectionLength(value, 'column.width');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Column.prototype, "spacing", {
+        get: function () {
+            return this.spacingValue;
+        },
+        set: function (value) {
+            this.spacingValue = validateSectionLength(value, 'column.spacing');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Column;
+}());
+export { Column };