logisheets-engine 1.0.0

package/dist/types/lib/worker/painter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Painter - handles canvas rendering operations.
+ */
+import type { CellView } from "./view_manager";
+import type { AppropriateHeight } from "./types";
+import { RenderCell } from "./render";
+export declare class Painter {
+    private _canvas?;
+    private _ctx?;
+    private _showWatermark;
+    setCanvas(canvas: OffscreenCanvas): void;
+    setShowWatermark(show: boolean): void;
+    render(resp: CellView, anchorX: number, anchorY: number): void;
+    getAppropriateHeights(resp: CellView, anchorX: number, anchorY: number): AppropriateHeight[];
+    renderContent(resp: CellView, anchorX: number, anchorY: number): void;
+    renderCell(renderCell: RenderCell, anchorX: number, anchorY: number, render?: boolean): number;
+    renderMergeCells(resp: CellView, anchorX: number, anchorY: number): void;
+    renderGrid(data: CellView, anchorX: number, anchorY: number): void;
+    private _borderLine;
+    private _fill;
+    private _text;
+    private renderWatermark;
+}

package/dist/types/lib/worker/pool.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Object Pool for managing reusable objects.
+ * This improves performance by avoiding frequent object creation/destruction.
+ */
+import type { CellView } from "./view_manager";
+import { RenderCell } from "./render";
+import { Range, StandardCell, StandardStyle, StandardValue } from "./standable";
+export declare class Pool {
+    getRenderCell(): RenderCell;
+    releaseRenderCell(c: RenderCell): void;
+    getRange(): Range;
+    releaseRange(r: Range): void;
+    getStandardValue(): StandardValue;
+    releaseStandardValue(v: StandardValue): void;
+    getStandardStyle(): StandardStyle;
+    releaseStandardStyle(s: StandardStyle): void;
+    getStandardCell(): StandardCell;
+    releaseStandardCell(c: StandardCell): void;
+    releaseCellView(v: CellView): void;
+    private _renderCells;
+    private _ranges;
+    private _standardCells;
+    private _standardValues;
+    private _standardStyles;
+    private _cellViews;
+}

package/dist/types/lib/worker/render.d.ts

@@ -0,0 +1,24 @@
+/**
+ * RenderCell - represents a cell with position and coordinate information for rendering.
+ */
+import type { CellInfo } from "logisheets-web";
+import { Range, StandardCell, StandardStyle, StandardValue } from "./standable";
+export declare class RenderCell {
+    get width(): number;
+    get height(): number;
+    setCoordinate(coordinate: Range): this;
+    setPosition(position: Range): this;
+    setInfo(info: CellInfo, getStandardCell: () => StandardCell, getStandardValue: () => StandardValue, getStandardStyle: () => StandardStyle): this;
+    setStandardCell(info?: StandardCell): this;
+    setSkipRender(skip: boolean): this;
+    reset(): void;
+    hidden: boolean;
+    /** start/end row/col index */
+    coordinate: Range;
+    /** start/end row/col pixel distance (position in the whole sheet) */
+    position: Range;
+    info?: StandardCell;
+    skipRender: boolean;
+    cover(cell: RenderCell): boolean;
+    equals(cell: RenderCell): boolean;
+}

package/dist/types/lib/worker/standable.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Standard data classes for the worker.
+ * These are simplified versions of the classes from the original codebase.
+ */
+import type { Value, Style, Font, RowInfo, ColInfo, Color, CtFontName, CtUnderlineProperty, Border, Fill, CtCellProtection, Alignment, MergeCell } from "logisheets-web";
+export declare function ptToPx(pt: number): number;
+export declare function pxToPt(px: number): number;
+export declare function widthToPx(w: number): number;
+export declare function pxToWidth(px: number): number;
+export declare function shallowCopy(curr: any, target: any): void;
+export declare class Range {
+    static fromMergeCell(mergeCell: MergeCell): Range;
+    get width(): number;
+    get height(): number;
+    get startRow(): number;
+    get startCol(): number;
+    get endRow(): number;
+    get endCol(): number;
+    setStartRow(startRow: number): this;
+    setStartCol(startCol: number): this;
+    setEndRow(endRow: number): this;
+    setEndCol(endCol: number): this;
+    reset(): void;
+    cover(range: Range): boolean;
+    equals(other: Range): boolean;
+    private _startRow;
+    private _startCol;
+    private _endRow;
+    private _endCol;
+}
+export declare class StandardColor {
+    static fromRgb(rgb: string): StandardColor;
+    static fromCtColor(color?: Color): StandardColor;
+    static from(r: number, g: number, b: number, a?: number): StandardColor;
+    css(): string;
+    rgb(): string;
+    setAlpha(alpha: number): void;
+    private _red?;
+    private _green?;
+    private _blue?;
+    private _alpha;
+    private _valid;
+}
+export type FontSizeUnit = "px" | "pt";
+export declare class StandardFont implements Font {
+    static from(font: Font): StandardFont;
+    get size(): number;
+    name: CtFontName;
+    underline?: CtUnderlineProperty;
+    fontSizeUnit: FontSizeUnit;
+    lineHeight: string;
+    standardColor: StandardColor;
+    bold: boolean;
+    sz: number;
+    condense: boolean;
+    italic: boolean;
+    outline: boolean;
+    shadow: boolean;
+    strike: boolean;
+    extend: boolean;
+    toCssFont(): string;
+}
+export declare class StandardStyle implements Style {
+    protection: CtCellProtection;
+    border: Border;
+    font: Font;
+    fill: Fill;
+    alignment: Alignment;
+    formatter: string;
+    from(style: Style): this;
+    getFont(): StandardFont;
+}
+export declare class StandardValue {
+    cellValueOneof?: {
+        $case: "str";
+        str: string;
+    } | {
+        $case: "number";
+        number: number;
+    } | {
+        $case: "bool";
+        bool: boolean;
+    } | {
+        $case: "error";
+        error: string;
+    };
+    get value(): string | number | boolean;
+    get valueStr(): string;
+    from(value: Value): this;
+}
+export declare class StandardCell {
+    style?: StandardStyle;
+    value?: StandardValue;
+    formula: string;
+    diyCellId?: number;
+    blockId?: number;
+    setStyle(style?: StandardStyle): void;
+    getFormattedText(): string;
+    getText(): string;
+    getNumber(): number | undefined;
+}
+export declare class StandardRowInfo implements RowInfo {
+    readonly idx: number;
+    constructor(idx: number);
+    height: number;
+    hidden: boolean;
+    get pt(): number;
+    get px(): number;
+    static from(rowInfo: RowInfo): StandardRowInfo;
+}
+export declare class StandardColInfo implements ColInfo {
+    readonly idx: number;
+    constructor(idx: number);
+    hidden: boolean;
+    width: number;
+    get px(): number;
+    get pt(): number;
+    static from(colInfo: ColInfo): StandardColInfo;
+}

package/dist/types/lib/worker/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Worker types and constants used for communication between main thread and workers.
+ */
+import type { BlockInfo, CellInfo, CellPosition, DisplayWindowWithStartPoint, ErrorMessage, SheetDimension, SheetInfo, ReproducibleCell, Value, FormulaDisplayInfo } from "logisheets-web";
+import type { Grid, AppropriateHeight } from "$types/index";
+export type { AppropriateHeight } from "$types/index";
+export declare const enum WorkerUpdate {
+    Cell = 0,
+    Sheet = 1,
+    CellAndSheet = 2,
+    Ready = 3,
+    CellValueChanged = 4,
+    CellRemoved = 5,
+    HeaderUpdated = 6
+}
+export declare enum MethodName {
+    GetSheetDimension = "getSheetDimension",
+    GetAllSheetInfo = "getAllSheetInfo",
+    GetDisplayWindow = "getDisplayWindow",
+    GetBlockDisplayWindow = "getBlockDisplayWindow",
+    GetCell = "getCell",
+    GetCells = "getCells",
+    GetCellsExceptWindow = "getCellsExceptWindow",
+    GetBlockInfo = "getBlockInfo",
+    GetCellPosition = "getCellPosition",
+    Undo = "undo",
+    Redo = "redo",
+    HandleTransaction = "handleTransaction",
+    HandleTransactionWithoutEvents = "handleTransactionWithoutEvents",
+    LoadWorkbook = "loadWorkbook",
+    IsReady = "isReady",
+    GetMergedCells = "getMergedCells",
+    CalcCondition = "calcCondition",
+    GetCellIdByBlockRef = "getCellIdByBlockRef",
+    GetTempStatusChanges = "getTempStatusChanges",
+    CheckFormula = "checkFormula",
+    Save = "save",
+    CleanupTempStatus = "cleanupTempStatus",
+    ToggleStatus = "toggleStatus",
+    CommitTempStatus = "commitTempStatus",
+    BatchGetCellInfoById = "batchGetCellInfoById",
+    BatchGetCellCoordinateWithSheetById = "batchGetCellCoordinateWithSheetById",
+    GetSheetNameByIdx = "getSheetNameByIdx",
+    LookupAppendixUpward = "lookupAppendixUpward",
+    GetBlockRowId = "getBlockRowId",
+    GetBlockColId = "getBlockColId",
+    GetSheetIdx = "getSheetIdx",
+    GetSheetId = "getSheetId",
+    GetBlockValues = "getBlockValues",
+    GetAvailableBlockId = "getAvailableBlockId",
+    GetDiyCellIdWithBlockId = "getDiyCellIdWithBlockId",
+    GetReproducibleCell = "getReproducibleCell",
+    GetReproducibleCells = "getReproducibleCells",
+    GetCellValue = "getCellValue",
+    GetShadowCellId = "getShadowCellId",
+    GetShadowCellIds = "getShadowCellIds",
+    GetShadowInfoById = "getShadowInfoById",
+    GetCellId = "getCellId",
+    GetDisplayUnitsOfFormula = "getDisplayUnitsOfFormula",
+    GetNextVisibleCell = "getNextVisibleCell",
+    GetAllBlockFields = "getAllBlockFields",
+    GetAppData = "getAppData",
+    GetFullyCoveredBlocks = "getFullyCoveredBlocks"
+}
+export declare enum OffscreenRenderName {
+    Render = "render",
+    Resize = "resize",
+    Init = "init",
+    GetAppropriateHeights = "getAppropriateHeights",
+    SetLicense = "setLicense",
+    ClearLicense = "clearLicense"
+}
+export type Result<T> = T | ErrorMessage;
+export interface IWorkbookWorker {
+    isReady(): Result<boolean>;
+    getAllSheetInfo(): Result<readonly SheetInfo[]>;
+    getDisplayWindow(params: any): Result<DisplayWindowWithStartPoint>;
+    getCell(params: any): Result<CellInfo>;
+    getCells(params: any): Result<readonly CellInfo[]>;
+    getReproducibleCell(params: any): Result<ReproducibleCell>;
+    getReproducibleCells(params: any): Result<readonly ReproducibleCell[]>;
+    getValue(params: any): Result<Value>;
+    getBlockInfo(params: any): Result<BlockInfo>;
+    getCellPosition(params: any): Result<CellPosition>;
+    getSheetDimension(sheetIdx: number): Result<SheetDimension>;
+    undo(): Result<void>;
+    redo(): Result<void>;
+    handleTransaction(params: any): Result<void>;
+    loadWorkbook(params: any): Result<void>;
+    getSheetIdx(params: any): Result<number>;
+    getBlockValues(params: any): Result<readonly string[]>;
+    getAvailableBlockId(params: any): Result<number>;
+    getSheetId(params: any): Result<number>;
+    getDisplayUnitsOfFormula(f: string): Result<FormulaDisplayInfo>;
+    getWorkbook(): any;
+}
+export interface IOffscreenWorker {
+    render(sheetId: number, anchorX: number, anchorY: number): Result<Grid>;
+    resize(width: number, height: number, dpr: number): Result<Grid>;
+    init(canvas: OffscreenCanvas, dpr: number): void;
+    getAppropriateHeights(sheetId: number, anchorX: number, anchorY: number): Result<AppropriateHeight[]>;
+}
+export interface WorkerRequest {
+    id: number;
+    m: string;
+    args?: any;
+}
+export interface WorkerResponse {
+    id: number;
+    result?: any;
+    error?: any;
+}
+export interface OffscreenRequest {
+    rid: number;
+    m: string;
+    args?: any;
+}
+export interface OffscreenResponse {
+    rid: number;
+    result?: any;
+    error?: any;
+}

package/dist/types/lib/worker/view_manager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ViewManager - responsible for efficiently generating CellViewData for rendering.
+ */
+import type { BlockDisplayInfo, Comment } from "logisheets-web";
+import type { IWorkbookWorker, Result } from "./types";
+import type { Pool } from "./pool";
+import { RenderCell } from "./render";
+export declare class CellView {
+    readonly data: CellViewData[];
+    constructor(data: CellViewData[]);
+    get fromRow(): number;
+    get toRow(): number;
+    get fromCol(): number;
+    get toCol(): number;
+    get rows(): readonly RenderCell[];
+    get cols(): readonly RenderCell[];
+    get cells(): readonly RenderCell[];
+    get mergeCells(): readonly RenderCell[];
+    get blocks(): readonly BlockDisplayInfo[];
+}
+export declare class CellViewData {
+    rows: readonly RenderCell[];
+    cols: readonly RenderCell[];
+    cells: readonly RenderCell[];
+    mergeCells: readonly RenderCell[];
+    comments: readonly Comment[];
+    blocks: readonly BlockDisplayInfo[];
+    fromRow: number;
+    toRow: number;
+    fromCol: number;
+    toCol: number;
+    constructor(rows: readonly RenderCell[], cols: readonly RenderCell[], cells: readonly RenderCell[], mergeCells: readonly RenderCell[], comments: readonly Comment[], blocks: readonly BlockDisplayInfo[]);
+}
+export interface CellViewRequest {
+    readonly startX: number;
+    readonly startY: number;
+    readonly height: number;
+    readonly width: number;
+}
+export interface CellViewResponse {
+    readonly type: CellViewRespType;
+    readonly data: CellView;
+    readonly request: CellViewRequest;
+    readonly anchorX: number;
+    readonly anchorY: number;
+}
+export declare enum CellViewRespType {
+    Existed = 0,
+    Incremental = 1,
+    New = 2
+}
+export declare class ViewManager {
+    private _workbook;
+    private _sheetIdx;
+    private _pool;
+    constructor(_workbook: IWorkbookWorker, _sheetIdx: number, _pool: Pool);
+    dataChunks: CellViewData[];
+    getViewResponse(startX: number, startY: number, height: number, width: number): Result<CellViewResponse>;
+}

package/dist/types/lib/worker/workbook.worker.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Workbook worker service - handles all workbook-related operations in a Web Worker.
+ */
+import { Workbook } from "logisheets-web";
+import type { BlockInfo, CellInfo, CellPosition, DisplayWindowWithStartPoint, MergeCell, SheetDimension, SheetInfo, CellCoordinate, FormulaDisplayInfo, ActionEffect, Value, ReproducibleCell, AppendixWithCell, SheetCellId, ShadowCellInfo, BlockField, AppData, CellCoordinateWithSheet, TempStatusDiff } from "logisheets-web";
+import type { Result, IWorkbookWorker } from "./types";
+export declare class WorkbookWorkerService implements IWorkbookWorker {
+    private _ctx;
+    constructor(_ctx: Worker);
+    private _workbookImpl;
+    init(): Promise<void>;
+    get workbook(): Workbook;
+    getWorkbook(): Workbook;
+    isReady(): Result<boolean>;
+    loadWorkbook(params: {
+        content: Uint8Array;
+        name: string;
+    }): Result<void>;
+    save(params: any): Result<any>;
+    getAllSheetInfo(): Result<readonly SheetInfo[]>;
+    getSheetDimension(sheetIdx: number): Result<SheetDimension>;
+    getSheetIdx(params: {
+        sheetId: number;
+    }): Result<number>;
+    getSheetId(params: {
+        sheetIdx: number;
+    }): Result<number>;
+    getSheetNameByIdx(idx: number): Result<string>;
+    private getSheet;
+    getCell(params: {
+        sheetIdx: number;
+        row: number;
+        col: number;
+    }): Result<CellInfo>;
+    getCells(params: {
+        sheetIdx: number;
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }): Result<readonly CellInfo[]>;
+    getCellPosition(params: {
+        sheetIdx: number;
+        row: number;
+        col: number;
+    }): Result<CellPosition>;
+    getCellId(params: any): Result<SheetCellId>;
+    getValue(params: {
+        sheetId: number;
+        row: number;
+        col: number;
+    }): Result<Value>;
+    getReproducibleCell(params: {
+        sheetIdx: number;
+        row: number;
+        col: number;
+    }): Result<ReproducibleCell>;
+    getReproducibleCells(params: {
+        sheetIdx: number;
+        coordinates: any;
+    }): Result<readonly ReproducibleCell[]>;
+    batchGetCellInfoById(params: {
+        ids: readonly SheetCellId[];
+    }): Result<readonly CellInfo[]>;
+    batchGetCellCoordinateWithSheetById(ids: readonly SheetCellId[]): Result<readonly CellCoordinateWithSheet[]>;
+    getNextVisibleCell(args: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+        direction: "up" | "down" | "left" | "right";
+    }): Result<CellCoordinate>;
+    getDisplayWindow(params: {
+        sheetIdx: number;
+        startX: number;
+        startY: number;
+        height: number;
+        width: number;
+    }): Result<DisplayWindowWithStartPoint>;
+    getMergedCells(params: {
+        sheetIdx: number;
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }): Result<readonly MergeCell[]>;
+    getBlockInfo(params: {
+        sheetId: number;
+        blockId: number;
+    }): Result<BlockInfo>;
+    getBlockValues(params: {
+        sheetId: number;
+        blockId: number;
+        rowIds: any;
+        colIds: any;
+    }): Result<readonly string[]>;
+    getAvailableBlockId(params: {
+        sheetIdx: number;
+    }): Result<number>;
+    getDiyCellIdWithBlockId(params: {
+        sheetId: number;
+        blockId: number;
+        row: number;
+        col: number;
+    }): Result<number>;
+    lookupAppendixUpward(params: {
+        sheetId: number;
+        blockId: number;
+        row: number;
+        col: number;
+        craftId: string;
+        tag: number;
+    }): Result<AppendixWithCell>;
+    getAllBlockFields(): Result<readonly BlockField[]>;
+    getFullyCoveredBlocks(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+        rowCnt: number;
+        colCnt: number;
+    }): Result<readonly BlockInfo[]>;
+    getShadowCellId(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+    }): Result<number>;
+    getShadowCellIds(params: any): Result<readonly number[]>;
+    getShadowInfoById(params: {
+        shadowId: number;
+    }): Result<ShadowCellInfo>;
+    handleTransaction(params: {
+        transaction: any;
+        temp: boolean;
+    }): Result<void>;
+    handleTransactionWithoutEvents(params: {
+        transaction: any;
+        temp: boolean;
+    }): Result<ActionEffect>;
+    undo(): Result<void>;
+    redo(): Result<void>;
+    commitTempStatus(): Result<void>;
+    cleanupTempStatus(): Result<void>;
+    toggleStatus(useTemp: boolean): Result<void>;
+    getDisplayUnitsOfFormula(f: string): Result<FormulaDisplayInfo>;
+    calcCondition(params: {
+        sheetIdx: number;
+        condition: any;
+    }): Result<boolean>;
+    getCellIdByBlockRef(params: {
+        refName: string;
+        key: string;
+        field: string;
+    }): Result<SheetCellId>;
+    getTempStatusChanges(): Result<TempStatusDiff>;
+    checkFormula(params: {
+        formula: string;
+    }): boolean;
+    getAppData(): Result<readonly AppData[]>;
+    handleRequest(request: {
+        m: string;
+        args: any;
+        id: number;
+    }): Promise<void>;
+}

package/dist/types/lib/worker/worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main worker entry point.
+ * Handles both workbook operations and offscreen rendering.
+ */
+export {};

package/dist/types/types/index.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Core types for the LogiSheets engine.
+ * This file contains all the interfaces that the engine interacts with externally.
+ */
+import type { BlockDisplayInfo, CellInfo, MergeCell, SelectedData, SheetInfo, CellLayout } from "logisheets-web";
+export interface Row {
+    height: number;
+    idx: number;
+}
+export interface Column {
+    width: number;
+    idx: number;
+}
+export interface Grid {
+    anchorX: number;
+    anchorY: number;
+    /**
+     * Pixels by which the first visible row/column is scrolled past the canvas
+     * top/left. `anchorY - firstVisibleRow.position.startRow`. Overlay helpers
+     * subtract these so positions stay in canvas-pixel space.
+     */
+    subOffsetX: number;
+    subOffsetY: number;
+    rows: readonly Row[];
+    columns: readonly Column[];
+    mergeCells?: readonly MergeCell[];
+    blockInfos?: readonly BlockDisplayInfo[];
+    preRowHeight?: number;
+    preColWidth?: number;
+    nextRowHeight?: number;
+    nextColWidth?: number;
+}
+export interface AppropriateHeight {
+    height: number;
+    row: number;
+    col: number;
+}
+export interface SelectorStyle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    borderTopWidth: number;
+    borderBottomWidth: number;
+    borderLeftWidth: number;
+    borderRightWidth: number;
+}
+export declare class Range {
+    static fromMergeCell(mergeCell: MergeCell): Range;
+    get width(): number;
+    get height(): number;
+    get startRow(): number;
+    get startCol(): number;
+    get endRow(): number;
+    get endCol(): number;
+    setStartRow(startRow: number): this;
+    setStartCol(startCol: number): this;
+    setEndRow(endRow: number): this;
+    setEndCol(endCol: number): this;
+    setStartEndRow(row: number): this;
+    setStartEndCol(col: number): this;
+    reset(): void;
+    cover(range: Range): boolean;
+    equals(other: Range): boolean;
+    private _startRow;
+    private _startCol;
+    private _endRow;
+    private _endCol;
+}
+export type CellType = "Cell" | "LeftTop" | "FixedLeftHeader" | "FixedTopHeader" | "unknown";
+export declare class Cell {
+    type: CellType;
+    constructor(type: CellType);
+    get width(): number;
+    get height(): number;
+    setCoordinate(coordinate: Range): this;
+    setPosition(position: Range): this;
+    equals(cell: Cell): boolean;
+    coordinate: Range;
+    position: Range;
+    info?: CellInfo;
+}
+export interface CanvasProps {
+    selectedData: SelectedData;
+    onSelectedDataChange: (e: SelectedData) => void;
+    activeSheet: number;
+    onActiveSheetChange: (s: number) => void;
+    onSelectedDataContentChanged: (e: object) => void;
+    grid: Grid | null;
+    onGridChange: (grid: Grid | null) => void;
+    cellLayouts: CellLayout[];
+}
+export interface EngineEvents {
+    onSheetChange: (sheets: readonly SheetInfo[]) => void;
+    onCellUpdate: () => void;
+    onError: (error: Error) => void;
+}
+export interface EngineConfig {
+    /** Width of the left header panel in pixels */
+    leftTopWidth: number;
+    /** Height of the top header panel in pixels */
+    leftTopHeight: number;
+    /** Show horizontal grid lines */
+    showHorizontalGridLines: boolean;
+    /** Show vertical grid lines */
+    showVerticalGridLines: boolean;
+    /** Default cell width in pt */
+    defaultCellWidth: number;
+    /** Default cell height in pt */
+    defaultCellHeight: number;
+    /** Scrollbar size in pixels */
+    scrollbarSize: number;
+}
+export declare const DEFAULT_ENGINE_CONFIG: EngineConfig;
+export type { SelectedData, SelectedCellRange, SelectedLines, SheetInfo, CellInfo, CellRef, FormulaDisplayInfo, MergeCell, BlockDisplayInfo, CellLayout, Transaction, Payload, } from "logisheets-web";