@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/excel/defined-names.js

@@ -0,0 +1,214 @@
+import { colCache } from "./utils/col-cache.js";
+import { CellMatrix } from "./utils/cell-matrix.js";
+import { Range } from "./range.js";
+const rangeRegexp = /[$](\w+)[$](\d+)(:[$](\w+)[$](\d+))?/;
+class DefinedNames {
+    constructor() {
+        this.matrixMap = {};
+    }
+    getMatrix(name) {
+        const matrix = this.matrixMap[name] || (this.matrixMap[name] = new CellMatrix());
+        return matrix;
+    }
+    // add a name to a cell. locStr in the form SheetName!$col$row or SheetName!$c1$r1:$c2:$r2
+    add(locStr, name) {
+        const location = colCache.decodeEx(locStr);
+        if ("error" in location) {
+            return; // Invalid reference, skip
+        }
+        this.addEx(location, name);
+    }
+    addEx(location, name) {
+        const matrix = this.getMatrix(name);
+        if ("top" in location) {
+            // It's a range (DecodedRange has top/left/bottom/right from Location)
+            for (let col = location.left; col <= location.right; col++) {
+                for (let row = location.top; row <= location.bottom; row++) {
+                    const address = {
+                        sheetName: location.sheetName,
+                        address: colCache.n2l(col) + row,
+                        row,
+                        col
+                    };
+                    matrix.addCellEx(address);
+                }
+            }
+        }
+        else {
+            // It's a single cell address
+            matrix.addCellEx(location);
+        }
+    }
+    remove(locStr, name) {
+        const location = colCache.decodeEx(locStr);
+        if ("error" in location) {
+            return; // Invalid reference, skip
+        }
+        this.removeEx(location, name);
+    }
+    removeEx(location, name) {
+        const matrix = this.getMatrix(name);
+        if ("top" in location) {
+            // Range - remove each cell
+            for (let col = location.left; col <= location.right; col++) {
+                for (let row = location.top; row <= location.bottom; row++) {
+                    matrix.removeCellEx({
+                        sheetName: location.sheetName,
+                        address: colCache.n2l(col) + row,
+                        row,
+                        col
+                    });
+                }
+            }
+        }
+        else {
+            matrix.removeCellEx(location);
+        }
+    }
+    removeAllNames(location) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            if ("top" in location) {
+                // Range - remove each cell
+                for (let col = location.left; col <= location.right; col++) {
+                    for (let row = location.top; row <= location.bottom; row++) {
+                        matrix.removeCellEx({
+                            sheetName: location.sheetName,
+                            address: colCache.n2l(col) + row,
+                            row,
+                            col
+                        });
+                    }
+                }
+            }
+            else {
+                matrix.removeCellEx(location);
+            }
+        });
+    }
+    forEach(callback) {
+        Object.entries(this.matrixMap).forEach(([name, matrix]) => {
+            matrix.forEach((cell) => {
+                callback(name, cell);
+            });
+        });
+    }
+    // get all the names of a cell
+    getNames(addressStr) {
+        const location = colCache.decodeEx(addressStr);
+        if ("error" in location || "top" in location) {
+            return []; // Invalid reference or range not supported
+        }
+        return this.getNamesEx(location);
+    }
+    getNamesEx(address) {
+        return Object.entries(this.matrixMap)
+            .map(([name, matrix]) => matrix.findCellEx(address, false) && name)
+            .filter((name) => Boolean(name));
+    }
+    _explore(matrix, cell) {
+        cell.mark = false;
+        const { sheetName } = cell;
+        const range = new Range(cell.row, cell.col, cell.row, cell.col, sheetName);
+        let x;
+        let y;
+        // Helper to get cell with proper type
+        const getCell = (row, col) => {
+            return matrix.findCellAt(sheetName, row, col);
+        };
+        // grow vertical - only one col to worry about
+        function vGrow(yy, edge) {
+            const c = getCell(yy, cell.col);
+            if (!c || !c.mark) {
+                return false;
+            }
+            range[edge] = yy;
+            c.mark = false;
+            return true;
+        }
+        for (y = cell.row - 1; vGrow(y, "top"); y--) { }
+        for (y = cell.row + 1; vGrow(y, "bottom"); y++) { }
+        // grow horizontal - ensure all rows can grow
+        function hGrow(xx, edge) {
+            const cells = [];
+            for (y = range.top; y <= range.bottom; y++) {
+                const c = getCell(y, xx);
+                if (c && c.mark) {
+                    cells.push(c);
+                }
+                else {
+                    return false;
+                }
+            }
+            range[edge] = xx;
+            for (let i = 0; i < cells.length; i++) {
+                cells[i].mark = false;
+            }
+            return true;
+        }
+        for (x = cell.col - 1; hGrow(x, "left"); x--) { }
+        for (x = cell.col + 1; hGrow(x, "right"); x++) { }
+        return range;
+    }
+    getRanges(name, matrix) {
+        matrix = matrix || this.matrixMap[name];
+        if (!matrix) {
+            return { name, ranges: [] };
+        }
+        // mark and sweep!
+        matrix.forEach((cell) => {
+            cell.mark = true;
+        });
+        const ranges = matrix
+            .map((cell) => cell.mark && this._explore(matrix, cell))
+            .filter(Boolean)
+            .map((range) => range.$shortRange);
+        return {
+            name,
+            ranges
+        };
+    }
+    normaliseMatrix(matrix, sheetName) {
+        // some of the cells might have shifted on specified sheet
+        // need to reassign rows, cols
+        matrix.forEachInSheet(sheetName, (cell, row, col) => {
+            if (cell) {
+                if (cell.row !== row || cell.col !== col) {
+                    cell.row = row;
+                    cell.col = col;
+                    cell.address = colCache.n2l(col) + row;
+                }
+            }
+        });
+    }
+    spliceRows(sheetName, start, numDelete, numInsert) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            matrix.spliceRows(sheetName, start, numDelete, numInsert);
+            this.normaliseMatrix(matrix, sheetName);
+        });
+    }
+    spliceColumns(sheetName, start, numDelete, numInsert) {
+        Object.values(this.matrixMap).forEach((matrix) => {
+            matrix.spliceColumns(sheetName, start, numDelete, numInsert);
+            this.normaliseMatrix(matrix, sheetName);
+        });
+    }
+    get model() {
+        // To get names per cell - just iterate over all names finding cells if they exist
+        return Object.entries(this.matrixMap)
+            .map(([name, matrix]) => this.getRanges(name, matrix))
+            .filter((definedName) => definedName.ranges.length);
+    }
+    set model(value) {
+        // value is [ { name, ranges }, ... ]
+        const matrixMap = (this.matrixMap = {});
+        value.forEach(definedName => {
+            const matrix = (matrixMap[definedName.name] = new CellMatrix());
+            definedName.ranges.forEach(rangeStr => {
+                if (rangeRegexp.test(rangeStr.split("!").pop() || "")) {
+                    matrix.addCell(rangeStr);
+                }
+            });
+        });
+    }
+}
+export { DefinedNames };

package/dist/browser/modules/excel/enums.d.ts

@@ -0,0 +1,62 @@
+export declare enum ValueType {
+    Null = 0,
+    Merge = 1,
+    Number = 2,
+    String = 3,
+    Date = 4,
+    Hyperlink = 5,
+    Formula = 6,
+    SharedString = 7,
+    RichText = 8,
+    Boolean = 9,
+    Error = 10,
+    JSON = 11
+}
+export declare enum FormulaType {
+    None = 0,
+    Master = 1,
+    Shared = 2
+}
+export declare enum RelationshipType {
+    None = 0,
+    OfficeDocument = 1,
+    Worksheet = 2,
+    CalcChain = 3,
+    SharedStrings = 4,
+    Styles = 5,
+    Theme = 6,
+    Hyperlink = 7
+}
+export declare enum DocumentType {
+    Xlsx = 1
+}
+export declare enum ReadingOrder {
+    LeftToRight = 1,
+    RightToLeft = 2
+}
+export declare const ErrorValue: {
+    readonly NotApplicable: "#N/A";
+    readonly Ref: "#REF!";
+    readonly Name: "#NAME?";
+    readonly DivZero: "#DIV/0!";
+    readonly Null: "#NULL!";
+    readonly Value: "#VALUE!";
+    readonly Num: "#NUM!";
+};
+export type ErrorValueType = (typeof ErrorValue)[keyof typeof ErrorValue];
+export declare const Enums: {
+    ValueType: typeof ValueType;
+    FormulaType: typeof FormulaType;
+    RelationshipType: typeof RelationshipType;
+    DocumentType: typeof DocumentType;
+    ReadingOrder: typeof ReadingOrder;
+    ErrorValue: {
+        readonly NotApplicable: "#N/A";
+        readonly Ref: "#REF!";
+        readonly Name: "#NAME?";
+        readonly DivZero: "#DIV/0!";
+        readonly Null: "#NULL!";
+        readonly Value: "#VALUE!";
+        readonly Num: "#NUM!";
+    };
+};

package/dist/browser/modules/excel/enums.js

@@ -0,0 +1,58 @@
+export var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Null"] = 0] = "Null";
+    ValueType[ValueType["Merge"] = 1] = "Merge";
+    ValueType[ValueType["Number"] = 2] = "Number";
+    ValueType[ValueType["String"] = 3] = "String";
+    ValueType[ValueType["Date"] = 4] = "Date";
+    ValueType[ValueType["Hyperlink"] = 5] = "Hyperlink";
+    ValueType[ValueType["Formula"] = 6] = "Formula";
+    ValueType[ValueType["SharedString"] = 7] = "SharedString";
+    ValueType[ValueType["RichText"] = 8] = "RichText";
+    ValueType[ValueType["Boolean"] = 9] = "Boolean";
+    ValueType[ValueType["Error"] = 10] = "Error";
+    ValueType[ValueType["JSON"] = 11] = "JSON"; // Internal type for JSON values that serialize as String
+})(ValueType || (ValueType = {}));
+export var FormulaType;
+(function (FormulaType) {
+    FormulaType[FormulaType["None"] = 0] = "None";
+    FormulaType[FormulaType["Master"] = 1] = "Master";
+    FormulaType[FormulaType["Shared"] = 2] = "Shared";
+})(FormulaType || (FormulaType = {}));
+export var RelationshipType;
+(function (RelationshipType) {
+    RelationshipType[RelationshipType["None"] = 0] = "None";
+    RelationshipType[RelationshipType["OfficeDocument"] = 1] = "OfficeDocument";
+    RelationshipType[RelationshipType["Worksheet"] = 2] = "Worksheet";
+    RelationshipType[RelationshipType["CalcChain"] = 3] = "CalcChain";
+    RelationshipType[RelationshipType["SharedStrings"] = 4] = "SharedStrings";
+    RelationshipType[RelationshipType["Styles"] = 5] = "Styles";
+    RelationshipType[RelationshipType["Theme"] = 6] = "Theme";
+    RelationshipType[RelationshipType["Hyperlink"] = 7] = "Hyperlink";
+})(RelationshipType || (RelationshipType = {}));
+export var DocumentType;
+(function (DocumentType) {
+    DocumentType[DocumentType["Xlsx"] = 1] = "Xlsx";
+})(DocumentType || (DocumentType = {}));
+export var ReadingOrder;
+(function (ReadingOrder) {
+    ReadingOrder[ReadingOrder["LeftToRight"] = 1] = "LeftToRight";
+    ReadingOrder[ReadingOrder["RightToLeft"] = 2] = "RightToLeft";
+})(ReadingOrder || (ReadingOrder = {}));
+export const ErrorValue = {
+    NotApplicable: "#N/A",
+    Ref: "#REF!",
+    Name: "#NAME?",
+    DivZero: "#DIV/0!",
+    Null: "#NULL!",
+    Value: "#VALUE!",
+    Num: "#NUM!"
+};
+export const Enums = {
+    ValueType,
+    FormulaType,
+    RelationshipType,
+    DocumentType,
+    ReadingOrder,
+    ErrorValue
+};

package/dist/browser/modules/excel/image.d.ts

@@ -0,0 +1,64 @@
+import { Anchor, type AnchorModel } from "@excel/anchor";
+import type { Worksheet } from "@excel/worksheet";
+interface ImageHyperlinks {
+    hyperlink?: string;
+    tooltip?: string;
+}
+interface ImageExt {
+    width?: number;
+    height?: number;
+}
+interface ImageRange {
+    tl: Anchor;
+    br?: Anchor;
+    ext?: ImageExt;
+    editAs?: string;
+    hyperlinks?: ImageHyperlinks;
+}
+interface BackgroundModel {
+    type: "background";
+    imageId: string;
+}
+interface ImageRangeModel {
+    tl: AnchorModel;
+    br?: AnchorModel;
+    ext?: ImageExt;
+    editAs?: string;
+}
+interface ImageModel {
+    type: "image";
+    imageId: string;
+    hyperlinks?: ImageHyperlinks;
+    range: ImageRangeModel;
+}
+type Model = BackgroundModel | ImageModel;
+type ImageModelInput = ModelInput;
+interface RangeInput {
+    tl?: AnchorModel | {
+        col: number;
+        row: number;
+    } | string;
+    br?: AnchorModel | {
+        col: number;
+        row: number;
+    } | string;
+    ext?: ImageExt;
+    editAs?: string;
+    hyperlinks?: ImageHyperlinks;
+}
+interface ModelInput {
+    type: string;
+    imageId: string;
+    range?: string | RangeInput | ImageRangeModel;
+    hyperlinks?: ImageHyperlinks;
+}
+declare class Image {
+    worksheet: Worksheet;
+    type?: string;
+    imageId?: string;
+    range?: ImageRange;
+    constructor(worksheet: Worksheet, model?: ModelInput);
+    get model(): Model;
+    set model({ type, imageId, range, hyperlinks }: ModelInput);
+}
+export { Image, type Model as ImageModel, type ImageModelInput };

package/dist/browser/modules/excel/image.js

@@ -0,0 +1,60 @@
+import { colCache } from "./utils/col-cache.js";
+import { Anchor } from "./anchor.js";
+class Image {
+    constructor(worksheet, model) {
+        this.worksheet = worksheet;
+        if (model) {
+            this.model = model;
+        }
+    }
+    get model() {
+        switch (this.type) {
+            case "background":
+                return {
+                    type: this.type,
+                    imageId: this.imageId
+                };
+            case "image":
+                return {
+                    type: this.type,
+                    imageId: this.imageId,
+                    hyperlinks: this.range.hyperlinks,
+                    range: {
+                        tl: this.range.tl.model,
+                        br: this.range.br && this.range.br.model,
+                        ext: this.range.ext,
+                        editAs: this.range.editAs
+                    }
+                };
+            default:
+                throw new Error("Invalid Image Type");
+        }
+    }
+    set model({ type, imageId, range, hyperlinks }) {
+        this.type = type;
+        this.imageId = imageId;
+        if (type === "image") {
+            if (typeof range === "string") {
+                const decoded = colCache.decode(range);
+                if ("top" in decoded) {
+                    // It's a Location (range like "A1:C3")
+                    this.range = {
+                        tl: new Anchor(this.worksheet, { col: decoded.left, row: decoded.top }, -1),
+                        br: new Anchor(this.worksheet, { col: decoded.right, row: decoded.bottom }, 0),
+                        editAs: "oneCell"
+                    };
+                }
+            }
+            else if (range) {
+                this.range = {
+                    tl: new Anchor(this.worksheet, range.tl, 0),
+                    br: range.br ? new Anchor(this.worksheet, range.br, 0) : undefined,
+                    ext: range.ext,
+                    editAs: range.editAs,
+                    hyperlinks: hyperlinks || ("hyperlinks" in range ? range.hyperlinks : undefined)
+                };
+            }
+        }
+    }
+}
+export { Image };

package/dist/browser/modules/excel/note.d.ts

@@ -0,0 +1,29 @@
+interface NoteText {
+    text: string;
+    [key: string]: any;
+}
+interface NoteConfig {
+    margins?: {
+        insetmode?: string;
+        inset?: number[];
+    };
+    protection?: {
+        locked?: string;
+        lockText?: string;
+    };
+    editAs?: string;
+    texts?: NoteText[];
+}
+interface NoteModel {
+    type: string;
+    note: NoteConfig;
+}
+declare class Note {
+    note: string | NoteConfig;
+    static DEFAULT_CONFIGS: NoteModel;
+    constructor(note?: string | NoteConfig);
+    get model(): NoteModel;
+    set model(value: NoteModel);
+    static fromModel(model: NoteModel): Note;
+}
+export { Note };

package/dist/browser/modules/excel/note.js

@@ -0,0 +1,61 @@
+import { deepMerge } from "./utils/under-dash.js";
+class Note {
+    constructor(note) {
+        this.note = note;
+    }
+    get model() {
+        let value = null;
+        switch (typeof this.note) {
+            case "string":
+                value = {
+                    type: "note",
+                    note: {
+                        texts: [
+                            {
+                                text: this.note
+                            }
+                        ]
+                    }
+                };
+                break;
+            default:
+                value = {
+                    type: "note",
+                    note: this.note
+                };
+                break;
+        }
+        // Suitable for all cell comments
+        return deepMerge({}, Note.DEFAULT_CONFIGS, value);
+    }
+    set model(value) {
+        const { note } = value;
+        const { texts } = note;
+        if (texts && texts.length === 1 && Object.keys(texts[0]).length === 1) {
+            this.note = texts[0].text;
+        }
+        else {
+            this.note = note;
+        }
+    }
+    static fromModel(model) {
+        const note = new Note();
+        note.model = model;
+        return note;
+    }
+}
+Note.DEFAULT_CONFIGS = {
+    note: {
+        margins: {
+            insetmode: "auto",
+            inset: [0.13, 0.13, 0.25, 0.25]
+        },
+        protection: {
+            locked: "True",
+            lockText: "True"
+        },
+        editAs: "absolute"
+    },
+    type: "note"
+};
+export { Note };