@trebco/treb 37.0.0 → 37.1.0

package/build/package.json

@@ -0,0 +1,119 @@
+{
+    "name": "@trebco/treb",
+    "version": "37.1.0",
+    "license": "LGPL-3.0-or-later",
+    "homepage": "https://treb.app",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/trebco/treb.git"
+    },
+    "main": "dist/treb-spreadsheet.mjs",
+    "types": "dist/treb.d.ts",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/treb.d.ts",
+            "import": "./dist/treb-spreadsheet.mjs",
+            "browser": "./dist/treb-spreadsheet.mjs"
+        },
+        "./treb-grid": {
+            "types": "./build/treb-grid/src/index.d.ts",
+            "import": "./build/treb-grid/src/index.js"
+        },
+        "./treb-grid/*": {
+            "types": "./build/treb-grid/*.d.ts",
+            "import": "./build/treb-grid/*.js"
+        },
+        "./treb-charts": {
+            "types": "./build/treb-charts/src/index.d.ts",
+            "import": "./build/treb-charts/src/index.js"
+        },
+        "./treb-charts/*": {
+            "types": "./build/treb-charts/*.d.ts",
+            "import": "./build/treb-charts/*.js"
+        },
+        "./treb-embed": {
+            "types": "./build/treb-embed/src/index.d.ts",
+            "import": "./build/treb-embed/src/index.js"
+        },
+        "./treb-embed/*": {
+            "types": "./build/treb-embed/*.d.ts",
+            "import": "./build/treb-embed/*.js"
+        },
+        "./treb-embed/*.html": {
+            "import": "./treb-embed/*.html"
+        },
+        "./treb-calculator": {
+            "types": "./build/treb-calculator/src/index.d.ts",
+            "import": "./build/treb-calculator/src/index.js"
+        },
+        "./treb-calculator/*": {
+            "types": "./build/treb-calculator/*.d.ts",
+            "import": "./build/treb-calculator/*.js"
+        },
+        "./treb-format": {
+            "types": "./build/treb-format/src/index.d.ts",
+            "import": "./build/treb-format/src/index.js"
+        },
+        "./treb-parser": {
+            "import": "./build/treb-parser/src/index.js",
+            "types": "./build/treb-parser/src/index.d.ts"
+        },
+        "./treb-utils": {
+            "import": "./build/treb-utils/src/index.js",
+            "types": "./build/treb-utils/src/index.d.ts"
+        },
+        "./treb-data-model": {
+            "import": "./build/treb-data-model/src/index.js",
+            "types": "./build/treb-data-model/src/index.d.ts"
+        },
+        "./treb-base-types": {
+            "import": "./build/treb-base-types/src/index.js",
+            "types": "./build/treb-base-types/src/index.d.ts"
+        },
+        "./esbuild-utils.mjs": "./esbuild-utils.mjs",
+        "./package.json": "./package.json"
+    },
+    "devDependencies": {
+        "@types/html-minifier": "^4.0.6",
+        "@types/node": "^25.5.0",
+        "@types/uzip": "^0.20201231.2",
+        "base64-js": "^1.5.1",
+        "cssnano": "^7.1.3",
+        "esbuild": "^0.27.4",
+        "eslint": "^10.1.0",
+        "fast-xml-parser": "^5.3.2",
+        "html-minifier-terser": "^7.2.0",
+        "ooxml-types": "file:ooxml-types",
+        "postcss": "^8.5.8",
+        "sass": "^1.98.0",
+        "treb-base-types": "file:treb-base-types",
+        "treb-calculator": "file:treb-calculator",
+        "treb-charts": "file:treb-charts",
+        "treb-data-model": "file:treb-data-model",
+        "treb-export": "file:treb-export",
+        "treb-format": "file:treb-format",
+        "treb-grid": "file:treb-grid",
+        "treb-parser": "file:treb-parser",
+        "treb-utils": "file:treb-utils",
+        "ts-node": "^10.9.2",
+        "tslib": "^2.8.1",
+        "tsx": "^4.20.6",
+        "typescript": "^6.0.2",
+        "typescript-eslint": "^8.57.2",
+        "uzip": "^0.20201231.0"
+    },
+    "scripts": {
+        "build": "node esbuild-composite.mjs",
+        "dev": "node esbuild-composite.mjs --dev",
+        "clean": "rm -fr build dist",
+        "watch": "node --watch esbuild-composite.mjs --watch --dev",
+        "watch-production": "node --watch esbuild-composite.mjs --watch",
+        "tsc": "tsc -b treb-embed/tsconfig.json",
+        "rebuild-tsc": "tsc -b --force treb-embed/tsconfig.json",
+        "watch-tsc": "tsc -b treb-embed/tsconfig.json -w",
+        "watch-api": "tsx --watch api-generator/api-generator.ts --config api-config.json",
+        "generate-api": "tsx api-generator/api-generator.ts --config api-config.json",
+        "release": "npm run clean && npm run rebuild-tsc && npm run build && npm run generate-api"
+    }
+}

package/build/treb-base-types/src/api_types.d.ts

@@ -0,0 +1,11 @@
+import type { ICellAddress, IArea } from './area';
+/**
+ * type represents a reference passed in to API functions. it can be an
+ * address object, or a string.
+ */
+export type AddressReference = string | ICellAddress;
+/**
+ * type represents a reference passed in to API functions. it can be an
+ * address object, an area (range) object, or a string.
+ */
+export type RangeReference = string | ICellAddress | IArea;

package/build/treb-base-types/src/api_types.js

@@ -0,0 +1,22 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+export {};
+//# sourceMappingURL=api_types.js.map

package/build/treb-base-types/src/api_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api_types.js","sourceRoot":"","sources":["../../../treb-base-types/src/api_types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/build/treb-base-types/src/area-utils.d.ts

@@ -0,0 +1,9 @@
+import type { IArea } from './area';
+import type { ICellAddress } from './area';
+/**
+ * area being a class is a mistake, but it will take a while
+ * to undo that (if we do it at all). for now we'll start creating
+ * utilities that can operate on the interface type, and maybe over
+ * time the class will wither.
+ */
+export declare function Iterate(area: IArea): Generator<ICellAddress>;

package/build/treb-base-types/src/area-utils.js

@@ -0,0 +1,50 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with TREB. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Copyright 2022-2026 trebco, llc.
+ * info@treb.app
+ *
+ */
+/**
+ * area being a class is a mistake, but it will take a while
+ * to undo that (if we do it at all). for now we'll start creating
+ * utilities that can operate on the interface type, and maybe over
+ * time the class will wither.
+ */
+export function* Iterate(area) {
+    /**
+     * this doesn't serialize. perhaps we should switch to -1,
+     * which is obviously invalid. although I think we may from
+     * time to time use that as a flag. which is bad, obviously.
+     * if we do that we'll need to define a new interface. which
+     * might be good.
+     */
+    if (area.start.row === Infinity || area.end.row === Infinity) {
+        throw new Error(`don't iterate infinite area`);
+    }
+    /*
+    if (area.entire_row || area.entire_column) {
+      throw new Error(`don't iterate infinite area`);
+    }
+    */
+    const sheet_id = area.start.sheet_id;
+    for (let row = area.start.row; row <= area.end.row; row++) {
+        for (let column = area.start.column; column <= area.end.column; column++) {
+            yield { row, column, sheet_id };
+        }
+    }
+}
+//# sourceMappingURL=area-utils.js.map

package/build/treb-base-types/src/area-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"area-utils.js","sourceRoot":"","sources":["../../../treb-base-types/src/area-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH;;;;;GAKG;AAEH,MAAM,SAAS,CAAC,CAAC,OAAO,CAAC,IAAW;IAElC;;;;;;OAMG;IACH,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,KAAK,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACjD,CAAC;IAED;;;;MAIE;IAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;IAErC,KAAK,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;QAC1D,KAAK,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;YACzE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QAClC,CAAC;IACH,CAAC;AAEH,CAAC"}

package/build/treb-base-types/src/area.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Structure represents a cell address. Note that row and column are 0-based.
+ */
+export interface ICellAddress {
+    /** 0-based row */
+    row: number;
+    /** 0-based column */
+    column: number;
+    absolute_row?: boolean;
+    absolute_column?: boolean;
+    sheet_id?: number;
+    /** spill reference */
+    spill?: boolean;
+}
+/**
+ * this version of the interface requires a sheet ID
+ */
+export interface ICellAddress2 extends ICellAddress {
+    sheet_id: number;
+}
+/**
+ * Structure represents a 2d range of cells.
+ *
+ * @privateRemarks
+ *
+ * FIXME: should be just Partial<Area>? (...) OTOH, this at least
+ * enforces two addresses, which seems useful
+ */
+export interface IArea {
+    start: ICellAddress;
+    end: ICellAddress;
+}
+export type SerializedArea = IArea & {
+    start: ICellAddress & {
+        sheet: string;
+    };
+};
+export interface PatchOptions {
+    before_column: number;
+    column_count: number;
+    before_row: number;
+    row_count: number;
+}
+/**
+ * type guard function
+ * FIXME: is there a naming convention for these?
+ *
+ * @internal
+ */
+export declare const IsCellAddress: (obj: unknown) => obj is ICellAddress;
+/** @internal */
+export declare const IsArea: (obj: unknown) => obj is IArea;
+export interface Dimensions {
+    rows: number;
+    columns: number;
+}
+/**
+ * class represents a rectangular area on a sheet. can be a range,
+ * single cell, entire row/column, or entire sheet.
+ *
+ * "entire" row/column/sheet is represented with an infinity in the
+ * start/end value for row/column/both, so watch out on loops. the
+ * sheet class has a method for reducing infinite ranges to actual
+ * populated ranges.
+ *
+ * infinitiy is turning into a headache because it doesn't serialize
+ * to json properly. should we switch to a flag, or -1, or something?
+ */
+export declare class Area implements IArea {
+    private start_;
+    private end_;
+    /**
+     *
+     * @param start
+     * @param end
+     * @param normalize: calls the normalize function
+     */
+    constructor(start: ICellAddress, end?: ICellAddress, normalize?: boolean);
+    static FromColumn(column: number): Area;
+    static FromRow(row: number): Area;
+    static ColumnToLabel(c: number): string;
+    static CellAddressToLabel(address: ICellAddress, sheet_id?: boolean): string;
+    /**
+     * merge two areas and return a new area.
+     * UPDATE to support arbitrary arguments
+     */
+    static Join(base: IArea, ...args: Array<IArea | undefined>): Area;
+    /**
+     * creates an area that expands the original area in all directions
+     * (except at the top/left edges)
+     */
+    static Bleed(area: IArea, length?: number): Area;
+    /**
+     * adjust an area in response to an insert/delete operation.
+     * I noticed we were doing this in several places. moved here to unify.
+     *
+     * @param source - the starting area. we'll create a new object to return
+     * (we will not mutate in place)
+     */
+    static PatchArea(source: IArea, options: PatchOptions): Area | false;
+    /** accessor returns a _copy_ of the start address */
+    get start(): ICellAddress;
+    /** accessor */
+    set start(value: ICellAddress);
+    /** accessor returns a _copy_ of the end address */
+    get end(): ICellAddress;
+    /** accessor */
+    set end(value: ICellAddress);
+    /** returns number of rows, possibly infinity */
+    get rows(): number;
+    /** returns number of columns, possibly infinity */
+    get columns(): number;
+    /** returns number of cells, possibly infinity */
+    get count(): number;
+    /** returns flag indicating this is the entire sheet, usually after "select all" */
+    get entire_sheet(): boolean;
+    /** returns flag indicating this range includes infinite rows */
+    get entire_column(): boolean;
+    /** returns flag indicating this range includes infinite columns */
+    get entire_row(): boolean;
+    PatchNull(address: ICellAddress): ICellAddress;
+    SetSheetID(id: number): void;
+    Normalize(): void;
+    /** returns the top-left cell in the area */
+    TopLeft(): ICellAddress;
+    /** returns the bottom-right cell in the area */
+    BottomRight(): ICellAddress;
+    ContainsRow(row: number): boolean;
+    ContainsColumn(column: number): boolean;
+    Contains(address: ICellAddress): boolean;
+    /**
+     * returns true if this area completely contains the argument area
+     * (also if areas are ===, as a side effect). note that this returns
+     * true if A contains B, but not vice-versa
+     */
+    ContainsArea(area: Area): boolean;
+    /**
+     * returns true if there's an intersection. note that this won't work
+     * if there are infinities -- needs real area ?
+     */
+    Intersects(area: Area): boolean;
+    Equals(area: Area): boolean;
+    Equals2(area: IArea): boolean;
+    Clone(): Area;
+    get left(): Area;
+    get right(): Area;
+    get top(): Area;
+    get bottom(): Area;
+    /** shifts range in place */
+    Shift(rows: number, columns: number): Area;
+    /** Resizes range in place so that it includes the given address */
+    ConsumeAddress(addr: ICellAddress): void;
+    /** Resizes range in place to be the requested shape */
+    Reshape(rows: number, columns: number): Area;
+    /** Resizes range in place so that it includes the given area (merge) */
+    ConsumeArea(area: IArea): void;
+    /** resizes range in place (updates end) */
+    Resize(rows: number, columns: number): Area;
+    /**
+     * modernizing. this is a proper iterator. generators are prettier
+     * but there's at least some performance cost -- I'm not sure how
+     * much, but it's non-zero.
+     */
+    [Symbol.iterator](): Iterator<ICellAddress>;
+    /**
+     * returns the range in A1-style spreadsheet addressing. if the
+     * entire sheet is selected, returns nothing (there's no way to
+     * express that in A1 notation). returns the row numbers for entire
+     * columns and vice-versa for rows.
+     */
+    get spreadsheet_label(): string;
+    /**
+     * FIXME: is this different than what would be returned if
+     * we just used the default json serializer? (...)
+     *
+     * NOTE: we could return just the start if size === 1. if
+     * you pass an undefined to the Area class ctor it will reuse
+     * the start.
+     *
+     */
+    toJSON(): IArea;
+}