logisheets-engine 1.0.0

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

@@ -0,0 +1,184 @@
+/**
+ * Workbook Client - communicates with the worker for workbook operations.
+ */
+import type { SheetInfo, CellInfo, CellPosition, SheetDimension, MergeCell, BlockInfo, FormulaDisplayInfo, CellCoordinate, SheetCellId, Callback, CellIdCallback, ErrorMessage, AppData, BlockField, TempStatusDiff, ShadowCellInfo } from "logisheets-web";
+type Resp<T> = Promise<T | ErrorMessage>;
+export declare class WorkbookClient {
+    private _worker;
+    private _resolvers;
+    private _id;
+    private _ready;
+    private _cellUpdatedCallbacks;
+    private _sheetUpdatedCallbacks;
+    private _headerUpdatedCallbacks;
+    private _cellValueChangedCallbacks;
+    private _cellRemovedCallbacks;
+    constructor(worker: Worker);
+    getAllSheetInfo(): Resp<readonly SheetInfo[]>;
+    getSheetDimension(sheetIdx: number): Resp<SheetDimension>;
+    getSheetIdx(params: {
+        sheetId: number;
+    }): Resp<number>;
+    getSheetId(params: {
+        sheetIdx: number;
+    }): Resp<number>;
+    getSheetNameByIdx(idx: number): Resp<string>;
+    getCell(params: {
+        sheetIdx: number;
+        row: number;
+        col: number;
+    }): Resp<CellInfo>;
+    getCells(params: {
+        sheetIdx: number;
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }): Resp<readonly CellInfo[]>;
+    getCellPosition(params: {
+        sheetIdx: number;
+        row: number;
+        col: number;
+    }): Resp<CellPosition>;
+    getCellId(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+    }): Resp<SheetCellId>;
+    batchGetCellInfoById(params: {
+        ids: readonly SheetCellId[];
+    }): Resp<readonly CellInfo[]>;
+    getNextVisibleCell(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+        direction: "up" | "down" | "left" | "right";
+    }): Resp<CellCoordinate>;
+    getBlockInfo(params: {
+        sheetId: number;
+        blockId: number;
+    }): Resp<BlockInfo>;
+    getAvailableBlockId(params: {
+        sheetIdx: number;
+    }): Resp<number>;
+    /**
+     * Enumerate blocks fully contained in a row/col range. Use a large
+     * range (e.g. derived from `getSheetDimension`) to enumerate every
+     * block on the sheet — useful for "jump to" lookups that need block
+     * schemas before any rendering has populated them into a Grid.
+     */
+    getFullyCoveredBlocks(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+        rowCnt: number;
+        colCnt: number;
+    }): Resp<readonly BlockInfo[]>;
+    /**
+     * Resolve a (refName, key, field) triple to a concrete cell id — same
+     * lookup the BLOCKREF formula does at evaluation time. Pair with
+     * `registerCellValueChangedCallback` to subscribe by block ref instead
+     * of (sheet, row, col).
+     */
+    getCellIdByBlockRef(params: {
+        refName: string;
+        key: string;
+        field: string;
+    }): Resp<SheetCellId>;
+    /**
+     * Snapshot of all cell-value differences between the active temp
+     * branch and the committed (fork) status. Used by the diff layer.
+     */
+    getTempStatusChanges(): Resp<TempStatusDiff>;
+    getMergedCells(params: {
+        sheetIdx: number;
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }): Resp<readonly MergeCell[]>;
+    /**
+     * Host-side observers that get every payload flowing through
+     * {@link handleTransaction} (or its no-events sibling). Used so the
+     * host can react to schema-shaping payloads — e.g. auto-stamping
+     * `bindFormSchema.refName` onto FieldManager — without crafts having
+     * to call a second API.
+     *
+     * Observers run synchronously *before* the payload is forwarded to the
+     * worker. They must not throw (errors are caught & logged) and should
+     * stay fast — they sit on the critical path of every transaction.
+     */
+    private _payloadObservers;
+    registerPayloadObserver(fn: (payload: any) => void): () => void;
+    private _notifyPayloadObservers;
+    handleTransaction(params: {
+        transaction: any;
+        temp: boolean;
+    }): Resp<void>;
+    handleTransactionWithoutEvents(params: {
+        transaction: any;
+        temp: boolean;
+    }): Resp<any>;
+    undo(): Resp<void>;
+    redo(): Resp<void>;
+    commitTempStatus(): Resp<void>;
+    cleanTempStatus(): Resp<void>;
+    loadWorkbook(params: {
+        content: Uint8Array;
+        name: string;
+    }): Resp<void>;
+    save(params: {
+        appData?: string;
+    }): Resp<any>;
+    getDisplayUnitsOfFormula(f: string): Resp<FormulaDisplayInfo>;
+    checkFormula(params: {
+        formula: string;
+    }): Resp<boolean>;
+    getAppData(): Resp<readonly AppData[]>;
+    getAllBlockFields(): Resp<readonly BlockField[]>;
+    getShadowCellId(params: {
+        sheetIdx: number;
+        rowIdx: number;
+        colIdx: number;
+        /**
+         * Which derived computation this shadow represents. Optional for
+         * backward compatibility — omitting it defaults to the
+         * long-standing Validation kind. Other kinds (e.g. `'userEditable'`)
+         * let widgets request their own per-cell shadow without colliding
+         * with validation's slot.
+         */
+        kind?: "validation" | "userEditable";
+    }): Resp<SheetCellId>;
+    /**
+     * Read the current value of a shadow ephemeral cell by its id.
+     * Used by widgets that install a per-cell formula (validation /
+     * userEditable / future kinds) and need to read the computed bool
+     * back. Subscribe to changes via
+     * {@link registerCellValueChangedByCellId} against the shadow's
+     * `SheetCellId`.
+     *
+     * Param shape matches the autogenerated `Client` interface from
+     * `logisheets-web` (params object, not raw `number`) — divergence
+     * here used to crash crafts that imported `Client` but ran against
+     * a `WorkbookClient` instance: the raw-number form re-wrapped the
+     * passed object into another `{shadowId}` envelope, serde failed
+     * to populate `GetShadowInfoByIdParams { shadow_id: u32 }`, and
+     * the call returned `undefined` silently.
+     */
+    getShadowInfoById(params: {
+        shadowId: number;
+    }): Resp<ShadowCellInfo>;
+    registerCellUpdatedCallback(f: Callback, _callbackId?: number): void;
+    registerSheetUpdatedCallback(f: Callback): void;
+    registerHeaderUpdatedCallback(f: (sheetIdxes: readonly number[]) => void): void;
+    registerCellValueChangedCallback(sheetIdx: number, rowIdx: number, colIdx: number, callback: CellIdCallback): Resp<void>;
+    /**
+     * Like {@link registerCellValueChangedCallback} but takes a pre-resolved
+     * `SheetCellId` — useful when paired with {@link getCellIdByBlockRef}
+     * (subscribing by block ref) or other id-producing lookups, since it
+     * skips the redundant (sheet,row,col) → id round-trip.
+     */
+    registerCellValueChangedByCellId(cellId: SheetCellId, callback: CellIdCallback): void;
+    private _call;
+}
+export {};

package/dist/types/lib/components/contextMenuTypes.d.ts

@@ -0,0 +1,39 @@
+import type { SelectedData } from "logisheets-web";
+/**
+ * Context menu item definition
+ */
+export interface ContextMenuItem {
+    /** Unique identifier for the menu item */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional icon (emoji or text) */
+    icon?: string;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Whether to show a separator after this item */
+    separator?: boolean;
+    /** Keyboard shortcut hint (display only) */
+    shortcut?: string;
+    /** Sub-menu items (if any) */
+    children?: ContextMenuItem[];
+}
+/**
+ * The target type where context menu was triggered
+ */
+export type ContextMenuTarget = "cell" | "row" | "column";
+/**
+ * Context passed to menu item click handlers
+ */
+export interface ContextMenuContext {
+    /** The selected data when menu was triggered */
+    selectedData: SelectedData;
+    /** What was clicked - cell, row header, or column header */
+    target: ContextMenuTarget;
+    /** Row index if a specific row was clicked */
+    row?: number;
+    /** Column index if a specific column was clicked */
+    col?: number;
+    /** The original mouse event */
+    event: MouseEvent;
+}

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

@@ -0,0 +1,8 @@
+export { default as Spreadsheet } from "./Spreadsheet.svelte";
+export { default as ColumnHeaders } from "./ColumnHeaders.svelte";
+export { default as RowHeaders } from "./RowHeaders.svelte";
+export { default as Selector } from "./Selector.svelte";
+export { default as SheetTabs } from "./SheetTabs.svelte";
+export { default as Scrollbar } from "./Scrollbar.svelte";
+export { default as ContextMenu } from "./ContextMenu.svelte";
+export { match, xForColStart, xForColEnd, yForRowStart, yForRowEnd, getPosition, getSelectedCellRange, getSelectedRows, getSelectedColumns, getSelectedLines, findVisibleRowIdxRange, findVisibleColIdxRange, buildSelectedDataFromCell, buildSelectedDataFromCellRange, ptToPx, pxToPt, pxToWidth, simpleUuid, } from "./utils";

package/dist/types/lib/components/utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Utility functions for the canvas component.
+ */
+import type { Grid } from "$types/index";
+import { Cell } from "$types/index";
+export declare const xForColStart: (colIdx: number, grid: Grid) => number;
+export declare const xForColEnd: (colIdx: number, grid: Grid) => number;
+export declare const yForRowStart: (rowIdx: number, grid: Grid) => number;
+export declare const yForRowEnd: (rowIdx: number, grid: Grid) => number;
+export declare const getPosition: (rowIdx: number, colIdx: number, grid: Grid) => {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+};
+export declare const findVisibleRowIdxRange: (anchor: number, height: number, grid: Grid) => [number, number];
+export declare const findVisibleColIdxRange: (anchor: number, width: number, grid: Grid) => [number, number];
+export declare function match(canvasX: number, canvasY: number, anchorX: number, anchorY: number, data: Grid): Cell;
+import type { SelectedData, SelectedCellRange, SelectedLines } from "logisheets-web";
+export declare function getSelectedCellRange(v: SelectedData): SelectedCellRange | undefined;
+export declare function getSelectedLines(v: SelectedData): SelectedLines | undefined;
+export declare function buildSelectedDataFromCell(row: number, col: number, source: "editbar" | "none"): SelectedData;
+export declare function buildSelectedDataFromCellRange(startRow: number, startCol: number, endRow: number, endCol: number, source: "editbar" | "none"): SelectedData;
+export declare function buildSelectedDataFromLines(start: number, end: number, type: "row" | "col", source: "editbar" | "none"): SelectedData;
+export declare function getSelectedRows(v: SelectedData): number[];
+export declare function getSelectedColumns(v: SelectedData): number[];
+export declare function toA1notation(col: number): string;
+export declare function getReferenceString(v: SelectedData): string;
+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 simpleUuid(): string;

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

@@ -0,0 +1,242 @@
+/**
+ * LogiSheets Engine - Core engine class providing UI mounting and workbook access.
+ * This is the main entry point for using the spreadsheet engine in any framework.
+ *
+ * The Engine does NOT re-invent the workbook API. Instead, it:
+ * 1. Creates and manages the Worker and DataService
+ * 2. Provides mount()/unmount() for UI rendering
+ * 3. Exposes getWorkbook() to access the original logisheets-web API
+ */
+import type { SheetInfo, SelectedData, CellLayout } from "logisheets-web";
+import { DataService } from "./clients/service";
+import { WorkbookClient } from "./clients/workbook";
+import { BlockManager } from "./block";
+import type { Grid, EngineConfig } from "$types/index";
+import type { ContextMenuItem } from "./components/contextMenuTypes";
+export type EngineEventType = "ready" | "sheetChange" | "cellChange" | "selectionChange" | "error" | "gridChange" | "activeSheetChange" | "startEdit" | "invalidFormula";
+export interface EngineEventMap {
+    ready: void;
+    sheetChange: readonly SheetInfo[];
+    cellChange: void;
+    selectionChange: SelectedData;
+    error: Error;
+    gridChange: Grid | null;
+    activeSheetChange: number;
+    startEdit: {
+        row: number;
+        col: number;
+        initialText: string;
+    };
+    invalidFormula: void;
+}
+type EventCallback<T extends EngineEventType> = (data: EngineEventMap[T]) => void;
+export interface EngineMountOptions {
+    /** Show sheet tabs at bottom */
+    showSheetTabs?: boolean;
+    /** Show scrollbars */
+    showScrollbars?: boolean;
+    /** Custom context menu items */
+    contextMenuItems?: ContextMenuItem[];
+    /** Cell layouts for custom rendering */
+    cellLayouts?: CellLayout[];
+    /** Getter for whether a formula is being edited (prevents canvas from taking focus) */
+    getIsEditingFormula?: () => boolean;
+    /** Callback when an invalid formula is entered */
+    onInvalidFormula?: () => void;
+}
+/**
+ * LogiSheets Engine - The main interface for the spreadsheet.
+ *
+ * Usage:
+ * ```javascript
+ * import { Engine } from 'logisheets-engine';
+ *
+ * // Create engine instance
+ * const engine = new Engine();
+ *
+ * // Wait for ready
+ * engine.on('ready', async () => {
+ *   // Mount the UI to a container
+ *   engine.mount(document.getElementById('spreadsheet'));
+ *
+ *   // Access the workbook API (same as logisheets-web)
+ *   const workbook = engine.getWorkbook();
+ *
+ *   // Load a file
+ *   await workbook.loadWorkbook({ content: buffer, name: 'file.xlsx' });
+ *
+ *   // Use original logisheets-web API
+ *   const sheets = await workbook.getAllSheetInfo();
+ *   const cell = await workbook.getCell({ sheetIdx: 0, row: 0, col: 0 });
+ *
+ *   // Execute transactions
+ *   await workbook.handleTransaction({ transaction: tx, temp: false });
+ * });
+ * ```
+ */
+export declare class Engine {
+    private _dataService;
+    private _worker;
+    private _blockManager;
+    private _config;
+    private _ready;
+    private _currentSheetIdx;
+    private _grid;
+    private _selectedData;
+    private _sheets;
+    private _mountedComponent;
+    private _mountContainer;
+    private _listeners;
+    constructor(config?: Partial<EngineConfig>);
+    /**
+     * Mount the spreadsheet UI to a container element.
+     * @param container - The HTML element to mount the spreadsheet into
+     * @param options - Mount options
+     */
+    mount(container: HTMLElement, options?: EngineMountOptions): void;
+    /**
+     * Unmount the spreadsheet UI.
+     */
+    unmount(): void;
+    /**
+     * Check if the UI is mounted.
+     */
+    isMounted(): boolean;
+    /**
+     * Get the mount container element.
+     */
+    getMountContainer(): HTMLElement | null;
+    /**
+     * Initialize offscreen canvas for headless rendering.
+     * Only needed if you want to render without mounting UI.
+     * @param canvas - The canvas element for offscreen rendering
+     */
+    initOffscreen(canvas: HTMLCanvasElement): Promise<void>;
+    /**
+     * Destroy the engine and release all resources.
+     */
+    destroy(): void;
+    /**
+     * Subscribe to an event.
+     */
+    on<T extends EngineEventType>(type: T, callback: EventCallback<T>): void;
+    /**
+     * Unsubscribe from an event.
+     */
+    off<T extends EngineEventType>(type: T, callback: EventCallback<T>): void;
+    private _emit;
+    /**
+     * Get the workbook client for all workbook operations.
+     * This provides access to the original logisheets-web API.
+     *
+     * @example
+     * ```javascript
+     * const workbook = engine.getWorkbook();
+     *
+     * // Load file
+     * await workbook.loadWorkbook({ content: buffer, name: 'file.xlsx' });
+     *
+     * // Get sheets
+     * const sheets = await workbook.getAllSheetInfo();
+     *
+     * // Get cell
+     * const cell = await workbook.getCell({ sheetIdx: 0, row: 0, col: 0 });
+     *
+     * // Execute transaction
+     * await workbook.handleTransaction({ transaction: tx, temp: false });
+     *
+     * // Undo/Redo
+     * await workbook.undo();
+     * await workbook.redo();
+     *
+     * // Save
+     * const result = await workbook.save({});
+     * ```
+     */
+    getWorkbook(): WorkbookClient;
+    /**
+     * Get the data service for rendering operations.
+     * Use this for render(), resize(), and other display-related operations.
+     */
+    getDataService(): DataService;
+    /**
+     * Get the block manager for field/enum management.
+     */
+    getBlockManager(): BlockManager;
+    /**
+     * Load a workbook from a file buffer.
+     * Convenience wrapper for getWorkbook().loadWorkbook()
+     */
+    loadFile(buffer: Uint8Array, filename: string): Promise<Grid | null>;
+    /**
+     * Render the spreadsheet.
+     * Note: When UI is mounted, rendering is handled automatically.
+     */
+    render(anchorX?: number, anchorY?: number): Promise<Grid | null>;
+    /**
+     * Resize the canvas.
+     * Note: When UI is mounted, resizing is handled automatically.
+     */
+    resize(width: number, height: number): Promise<Grid | null>;
+    /**
+     * Get the current grid data.
+     */
+    getGrid(): Grid | null;
+    /**
+     * Get current selection.
+     */
+    getSelection(): SelectedData;
+    /**
+     * Set current selection.
+     */
+    setSelection(selection: SelectedData): void;
+    /**
+     * Get current sheet index.
+     */
+    getCurrentSheetIndex(): number;
+    /**
+     * Set current sheet by index.
+     */
+    setCurrentSheetIndex(index: number): void;
+    /**
+     * Get cached sheet info.
+     */
+    getSheets(): readonly SheetInfo[];
+    /**
+     * Get engine configuration.
+     */
+    getConfig(): EngineConfig;
+    /**
+     * Check if engine is ready.
+     */
+    isReady(): boolean;
+    /**
+     * Set the license key (API key) to activate the engine.
+     * If valid, the watermark will be removed.
+     *
+     * License validation happens INSIDE the worker - cannot be bypassed.
+     *
+     * @param apiKey - The license key provided to customers
+     * @returns License validation status
+     *
+     * @example
+     * ```javascript
+     * const status = await engine.setLicense('eyJkb21haW4i...');
+     * if (status.valid) {
+     *   console.log('License activated!');
+     * } else {
+     *   console.log('License invalid:', status.reason);
+     * }
+     * ```
+     */
+    setLicense(apiKey: string): Promise<{
+        valid: boolean;
+        reason?: string;
+    }>;
+    /**
+     * Clear the current license and show watermark again.
+     */
+    clearLicense(): void;
+    private _ensureReady;
+}
+export default Engine;

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

@@ -0,0 +1,36 @@
+/**
+ * LogiSheets Engine - Global entry point
+ *
+ * This file exposes the entire engine API to the global `window.LogiSheetsEngine` object.
+ * It can be used in any framework or vanilla JavaScript.
+ *
+ * Usage in browser:
+ * ```html
+ * <script src="logisheets-engine.umd.js"></script>
+ * <script>
+ *   const engine = new LogiSheetsEngine.Engine();
+ *   await engine.init(document.getElementById('canvas'));
+ * </script>
+ * ```
+ *
+ * Usage as ES module:
+ * ```javascript
+ * import { Engine, Transaction, CellInputBuilder } from 'logisheets-engine';
+ * const engine = new Engine();
+ * ```
+ */
+export { Engine, default } from "./engine";
+export type { EngineEventType, EngineEventMap } from "./engine";
+export type { License, LicenseStatus } from "./license";
+export { DataService, WorkbookClient, OffscreenClient } from "./clients";
+export { WorkbookWorkerService, OffscreenWorkerService } from "./worker";
+export { BlockManager, EnumSetManager, FieldManager, LOGISHEETS_BUILTIN_CRAFT_ID, FIELD_AND_VALIDATION_TAG, expandFieldFormula, colIdxToLetters, } from "./block";
+export type { EnumInfo, EnumVariant, FieldInfo, FieldTypeEnum } from "./block";
+export type { Grid, Row, Column, Range, Cell, SelectorStyle, CellLayout, CanvasProps, EngineConfig, } from "$types/index";
+export { DEFAULT_ENGINE_CONFIG, Range as RangeClass, Cell as CellClass, } from "$types/index";
+export * from "logisheets-web";
+export { match, xForColStart, xForColEnd, yForRowStart, yForRowEnd, getPosition, getSelectedCellRange, getSelectedLines, getSelectedRows, getSelectedColumns, findVisibleRowIdxRange, findVisibleColIdxRange, buildSelectedDataFromCell, buildSelectedDataFromCellRange, buildSelectedDataFromLines, getReferenceString, ptToPx, pxToPt, pxToWidth, simpleUuid, } from "./components/utils";
+export type { ContextMenuItem, ContextMenuContext, } from "./components/contextMenuTypes";
+export { convertCanvasPropsToAdapterProps } from "./adapters";
+export type { SpreadsheetAdapterProps, CanvasAdapterProps, UseSpreadsheetConfig, UseSpreadsheetReturn, } from "./adapters";
+export { Spreadsheet, ColumnHeaders, RowHeaders, Selector, SheetTabs, Scrollbar, ContextMenu, } from "./components";

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

@@ -0,0 +1,15 @@
+export { Spreadsheet, ColumnHeaders, RowHeaders, Selector, SheetTabs, Scrollbar, ContextMenu, match, xForColStart, xForColEnd, yForRowStart, yForRowEnd, getPosition, getSelectedCellRange, getSelectedRows, getSelectedColumns, getSelectedLines, findVisibleRowIdxRange, findVisibleColIdxRange, buildSelectedDataFromCell, buildSelectedDataFromCellRange, ptToPx, pxToPt, pxToWidth, simpleUuid, } from "./components";
+export type { ContextMenuItem, ContextMenuContext, } from "./components/contextMenuTypes";
+export { DataService, WorkbookClient, OffscreenClient } from "./clients";
+export { WorkbookWorkerService, OffscreenWorkerService } from "./worker";
+export { BlockManager, EnumSetManager, FieldManager, LOGISHEETS_BUILTIN_CRAFT_ID, FIELD_AND_VALIDATION_TAG, expandFieldFormula, colIdxToLetters, } from "./block";
+export type { EnumInfo, EnumVariant, FieldInfo, FieldTypeEnum } from "./block";
+export type { Grid, Row, Column, Range, Cell, SelectorStyle, CellLayout, CanvasProps, EngineConfig, } from "$types/index";
+export { DEFAULT_ENGINE_CONFIG } from "$types/index";
+export { Range as RangeClass, Cell as CellClass } from "$types/index";
+export { Engine, default as EngineDefault } from "./engine";
+export type { EngineEventType, EngineEventMap, EngineMountOptions, } from "./engine";
+export type { SelectedData, Transaction, Payload, SheetInfo, } from "logisheets-web";
+export { isErrorMessage, getFirstCell, } from "logisheets-web";
+export { convertCanvasPropsToAdapterProps } from "./adapters";
+export type { SpreadsheetAdapterProps, CanvasAdapterProps, UseSpreadsheetConfig, UseSpreadsheetReturn, } from "./adapters";

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

@@ -0,0 +1,26 @@
+/**
+ * License verification module using WebCrypto API (zero dependencies)
+ * Uses ECDSA P-256 for signature verification
+ */
+export interface License {
+    domain: string;
+    issuedAt: number;
+    validDays: number;
+    signature: string;
+}
+export interface LicenseStatus {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Parse and validate a license key
+ */
+export declare function validateLicense(apiKey: string): Promise<LicenseStatus>;
+/**
+ * Check if license is currently valid
+ */
+export declare function isLicenseValid(): boolean;
+/**
+ * Clear current license
+ */
+export declare function clearLicense(): void;

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

@@ -0,0 +1,24 @@
+/**
+ * BorderHelper is used to generate the continuous borders. Drawing borders
+ * cell by cell will make the borders discontinuous.
+ */
+import type { BorderPr } from "logisheets-web";
+import type { CellView } from "./view_manager";
+export interface BorderSegment {
+    pr: BorderPr | undefined;
+    from: number;
+    to: number;
+    start: number;
+    coordinateX: number;
+    coordinateY: number;
+}
+export declare class BorderHelper {
+    private readonly _data;
+    private _rowBorderStore;
+    private _colBorderStore;
+    constructor(_data: CellView);
+    generateRowBorder(r: number): BorderSegment[];
+    generateColBorder(c: number): BorderSegment[];
+    private _setRowBorder;
+    private _setColBorder;
+}

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

@@ -0,0 +1,3 @@
+export { WorkbookWorkerService } from "./workbook.worker";
+export { OffscreenWorkerService } from "./offscreen.worker";
+export type * from "./types";

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

@@ -0,0 +1,27 @@
+/**
+ * License verification module for Worker context
+ * Uses WebCrypto API (zero dependencies)
+ * Uses ECDSA P-256 for signature verification
+ *
+ * This module runs INSIDE the worker, so license validation cannot be bypassed
+ * by sending direct messages to the worker.
+ *
+ * PUBLIC KEY OBFUSCATION:
+ * The public key is stored as encoded fragments to prevent easy discovery.
+ * Run `node scripts/license-cli.mjs generate-keys` to get the fragments.
+ */
+export interface License {
+    domain: string;
+    issuedAt: number;
+    validDays: number;
+    signature: string;
+}
+export interface LicenseStatus {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Validate a license key and return the status
+ * This is called inside the worker - no way to bypass it
+ */
+export declare function validateLicenseInWorker(apiKey: string, currentDomain: string): Promise<LicenseStatus>;

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

@@ -0,0 +1,35 @@
+/**
+ * Offscreen worker service - handles rendering operations in a Web Worker.
+ */
+import type { Grid, AppropriateHeight } from "$types/index";
+import type { IWorkbookWorker, Result } from "./types";
+import { type LicenseStatus } from "./license";
+export declare class OffscreenWorkerService {
+    private readonly _workbook;
+    private readonly _ctx;
+    constructor(_workbook: IWorkbookWorker, _ctx: Worker);
+    private _canvas;
+    private _dpr;
+    private _painter;
+    private _sheetId;
+    private _anchorX;
+    private _anchorY;
+    init(canvas: OffscreenCanvas, dpr: number): void;
+    /**
+     * Set license - validates the license inside the worker
+     * This is the ONLY way to hide the watermark - no bypass possible
+     */
+    setLicense(apiKey: string, domain: string): Promise<LicenseStatus>;
+    /**
+     * Clear license and show watermark again
+     */
+    clearLicense(): void;
+    resize(width: number, height: number, dpr: number): Result<Grid>;
+    render(sheetId: number, anchorX: number, anchorY: number): Result<Grid>;
+    getAppropriateHeights(sheetId: number, anchorX: number, anchorY: number): Result<AppropriateHeight[]>;
+    handleRequest(request: {
+        m: string;
+        args: any;
+        rid: number;
+    }): void;
+}