logisheets 0.8.0 → 1.1.0

package/dist/src/api/workbook.js

@@ -1,42 +1,63 @@
-import { block_input, block_line_shift, calc_condition, cell_clear, cell_input, check_bind_block, check_formula, col_delete, col_insert, create_block, create_sheet, delete_sheet, get_all_sheet_info, get_available_block_id, get_sheet_count, get_sheet_id, input_async_result, merge_cells, move_block, new_workbook, read_file, redo, release, row_delete, row_insert, set_cell_alignment, set_cell_border, set_cell_format_brush, set_cell_pattern_fill, set_col_width, set_font, set_line_alignment, set_line_border, set_line_font, set_line_format_brush, set_line_pattern_fill, set_row_height, sheet_rename_by_idx, sheet_rename_by_name, split_merged_cells, transaction_end, transaction_start, undo, } from '../../wasm/logisheets_wasm_server';
-import { Transaction } from '../transactions';
+import { handle, input_async_result } from '../../wasm/logisheets_wasm_server';
 import { Worksheet } from './worksheet';
 import { Calculator } from './calculator';
+import { isErrorMessage } from './utils';
 import { BlockManager } from './block_manager';
+function rpc(method, params, bookId
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const msg = params === undefined ? method : { method, value: params };
+    return handle(msg, bookId ?? null);
+}
 export class Workbook {
     constructor() {
-        this._id = new_workbook();
+        this._id = rpc('newWorkbook');
         this._blockManager = new BlockManager((sheetIdx, blockId, rowCount, colCount) => {
-            return check_bind_block(this._id, sheetIdx, blockId, rowCount, colCount);
+            return rpc('checkBindBlock', { sheetIdx, blockId, rowCount, colCount }, this._id);
         }, (sheetIdx) => {
-            return get_available_block_id(this._id, sheetIdx);
+            return rpc('getAvailableBlockId', { sheetIdx }, this._id);
         });
     }
+    getSheetIdx(sheetId) {
+        return rpc('getSheetIdx', { sheetId }, this._id);
+    }
+    getBlockValues(params) {
+        return rpc('getBlockValues', params, this._id);
+    }
+    getAvailableBlockId(params) {
+        return rpc('getAvailableBlockId', params, this._id);
+    }
     /**
      * @returns the block id if success, otherwise the error message
      *
      * It is caller's responsibility to store the block id.
      */
-    createBlockForNewCraft(sheetIdx, masterRow, masterCol, rowCount, colCount) {
+    createBlockForNewCraft(sheetIdx, masterRow, masterCol, rowCnt, colCnt) {
         const id = this._blockManager.getAvailableBlockId(sheetIdx);
-        const effect = this.execTransaction(new Transaction([
-            {
-                type: 'createBlock',
-                sheetIdx,
-                blockId: id,
-                masterRow,
-                masterCol,
-                rowCnt: rowCount,
-                colCnt: colCount,
-            },
-        ], false));
-        if ('err' in effect.status) {
+        const effect = this.execTransaction({
+            payloads: [
+                {
+                    type: 'createBlock',
+                    value: {
+                        sheetIdx,
+                        id,
+                        masterRow,
+                        masterCol,
+                        rowCnt,
+                        colCnt,
+                    },
+                },
+            ],
+            undoable: false,
+            temp: false,
+        });
+        if (effect.status.type === 'err') {
             return {
                 msg: 'failed to create block',
-                ty: effect.status.err,
+                ty: effect.status.value,
             };
         }
-        const bind = this._blockManager.bindBlock(sheetIdx, id, rowCount, colCount);
+        const bind = this._blockManager.bindBlock(sheetIdx, id, rowCnt, colCnt);
         if (!bind) {
             return {
                 msg: 'failed to bind block',
@@ -46,7 +67,7 @@ export class Workbook {
         return id;
     }
     undo() {
-        const result = undo(this._id);
+        const result = rpc('undo', undefined, this._id);
         if (result) {
             this._onCellUpdate();
             this._onSheetUpdate();
@@ -54,7 +75,7 @@ export class Workbook {
         return result;
     }
     redo() {
-        const result = redo(this._id);
+        const result = rpc('redo', undefined, this._id);
         if (result) {
             this._onCellUpdate();
             this._onSheetUpdate();
@@ -67,24 +88,123 @@ export class Workbook {
     registerSheetInfoUpdateCallback(callback) {
         this._sheetInfoUpdatedCallbacks.push(callback);
     }
+    /**
+     * Fires after a transaction with sheet indices whose row/column headers
+     * changed (i.e. SetRowHeight / SetColWidth payloads). Useful for the UI
+     * to know which sheets need their header strip re-rendered.
+     */
+    registerHeaderUpdatedCallback(callback) {
+        this._headerUpdatedCallbacks.push(callback);
+    }
+    getSheetNameByIdx(idx) {
+        return rpc('getSheetNameByIdx', { idx }, this._id);
+    }
     getAllSheetInfo() {
-        return get_all_sheet_info(this._id);
+        return rpc('getAllSheetInfo', undefined, this._id);
     }
     checkFormula(f) {
-        return check_formula(this._id, f);
+        return rpc('checkFormula', { formula: f }, this._id);
     }
     calcCondition(sheetIdx, f) {
-        return calc_condition(this._id, sheetIdx, f);
+        return rpc('calcCondition', { sheetIdx, condition: f }, this._id);
+    }
+    /**
+     * Resolve a (refName, key, field) triple to a concrete cell, the same
+     * way the BLOCKREF formula resolves at evaluation time. Useful for
+     * subscribing to block cells without threading sheet/block/row/col
+     * coordinates.
+     */
+    getCellIdByBlockRef(refName, key, field) {
+        return rpc('getCellIdByBlockRef', { refName, key, field }, this._id);
+    }
+    /**
+     * Export a block's data as a row-per-key, column-per-field matrix of
+     * values. `keyFilter`/`fieldFilter` narrow the rows/columns (omit for
+     * all). Columns follow the schema's field order (filtered); pair them with
+     * the field metadata from the field manager — including which field is the
+     * key — on the caller side.
+     */
+    exportBlockData(refName, keyFilter, fieldFilter) {
+        return rpc('exportBlockData', { refName, keyFilter, fieldFilter }, this._id);
+    }
+    /**
+     * Snapshot of all cell-value differences between the active temp
+     * branch and the committed (fork) status. Returns an empty diff
+     * when no temp branch is active. Used by the host's diff layer to
+     * drive its overlay without needing JS-side snapshot/compare.
+     */
+    getTempStatusChanges() {
+        return rpc('getTempStatusChanges', undefined, this._id);
     }
     getSheetId(sheetIdx) {
-        return get_sheet_id(this._id, sheetIdx);
+        return rpc('getSheetId', { sheetIdx }, this._id);
     }
-    execTransaction(tx) {
-        transaction_start(this._id);
-        tx.payloads.forEach((p) => {
-            this._addPayload(p);
+    getBlockRowId(sheetId, blockId, rowIdx) {
+        return rpc('getBlockRowId', { sheetId, blockId, rowIdx }, this._id);
+    }
+    getBlockColId(sheetId, blockId, colIdx) {
+        return rpc('getBlockColId', { sheetId, blockId, colIdx }, this._id);
+    }
+    getDisplayUnitsOfFormula(f) {
+        return rpc('getDisplayUnitsOfFormula', { formula: f }, this._id);
+    }
+    onCellValueChanged(sheetIdx, rowIdx, colIdx, callback) {
+        const cellId = this.getCellId({ sheetIdx, rowIdx, colIdx });
+        if (isErrorMessage(cellId)) {
+            return cellId;
+        }
+        this._registerCellValueChangedCallback(cellId, callback);
+    }
+    onCellRemoved(sheetIdx, rowIdx, colIdx, callback) {
+        const cellId = this.getCellId({ sheetIdx, rowIdx, colIdx });
+        if (isErrorMessage(cellId)) {
+            return cellId;
+        }
+        this._registerCellRemovedCallback(cellId, callback);
+    }
+    onShadowCellValueChanged(sheetIdx, rowIdx, colIdx, callback) {
+        const shadowId = this.getShadowCellId({
+            sheetIdx,
+            rowIdx,
+            colIdx,
         });
-        const result = transaction_end(this._id, tx.undoable);
+        if (isErrorMessage(shadowId)) {
+            return shadowId;
+        }
+        this._registerCellValueChangedCallback(shadowId, callback);
+    }
+    _registerCellRemovedCallback(cellId, callback) {
+        if (!this._cellRemovedCallbacks.has(cellId)) {
+            this._cellRemovedCallbacks.set(cellId, []);
+        }
+        this._cellRemovedCallbacks.get(cellId)?.push(callback);
+    }
+    _registerCellValueChangedCallback(id, callback) {
+        if (!this._cellValueChangedCallbacks.has(id)) {
+            this._cellValueChangedCallbacks.set(id, []);
+        }
+        this._cellValueChangedCallbacks.get(id)?.push(callback);
+    }
+    registerCellValueChangedByCellId(cellId, callback) {
+        this._registerCellValueChangedCallback(cellId, callback);
+    }
+    commitTempStatus() {
+        rpc('commitTempStatus', undefined, this._id);
+    }
+    cleanupTempStatus() {
+        rpc('cleanTempStatus', undefined, this._id);
+    }
+    toggleStatus(useTemp) {
+        rpc('toggleStatus', { useTemp }, this._id);
+    }
+    batchGetCellInfoById(ids) {
+        return rpc('batchGetCellInfoById', { ids }, this._id);
+    }
+    batchGetCellCoordinateWithSheetById(ids) {
+        return rpc('batchGetCellCoordinateWithSheetById', { ids }, this._id);
+    }
+    execTransaction(tx) {
+        const result = rpc('handleTransaction', { transaction: tx }, this._id);
         if (result.asyncTasks.length > 0) {
             const asyncResult = this._calculator.calc(result.asyncTasks);
             asyncResult.then((result) => {
@@ -92,8 +212,8 @@ export class Workbook {
                 this._onCellUpdate();
             });
         }
-        if ('ok' in result.status) {
-            switch (result.status.ok) {
+        if (result.status.type === 'ok') {
+            switch (result.status.value) {
                 case 'cell':
                     this._onCellUpdate();
                     break;
@@ -112,98 +232,120 @@ export class Workbook {
                     this._onCellUpdate();
                     this._onSheetUpdate();
             }
+            result.valueChanged.forEach((cellId) => {
+                this._cellValueChangedCallbacks
+                    .get(cellId)
+                    ?.forEach((callback) => {
+                    callback();
+                });
+            });
+            result.cellRemoved.forEach((cellId) => {
+                this._cellRemovedCallbacks.get(cellId)?.forEach((callback) => {
+                    callback();
+                });
+                this._cellRemovedCallbacks.delete(cellId);
+                this._cellValueChangedCallbacks.delete(cellId);
+            });
+            if (result.headerUpdated.length > 0) {
+                this._headerUpdatedCallbacks.forEach((cb) => cb(result.headerUpdated));
+            }
         }
         return result;
     }
     load(buf, bookName) {
-        return read_file(this._id, bookName, buf);
+        return rpc('loadWorkbook', { content: Array.from(buf), name: bookName }, this._id);
+    }
+    save(data) {
+        return rpc('saveWorkbook', { appData: data }, this._id);
+    }
+    getAppData() {
+        return rpc('getAppData', undefined, this._id);
     }
     release() {
-        release(this._id);
+        rpc('release', undefined, this._id);
     }
     getSheetCount() {
-        return get_sheet_count(this._id);
+        return rpc('getSheetCount', undefined, this._id);
     }
     getWorksheet(idx) {
         if (idx >= this.getSheetCount())
             throw Error(`invalid sheet index: ${idx}`);
         return new Worksheet(this._id, idx);
     }
+    /**
+     * Fill-handle drag: predict the contents for `dst` from the source
+     * block `src` and commit them as a single (undoable) transaction.
+     *
+     * The semantics (formula reference shift, arithmetic series, value
+     * copy) live in the Rust engine; this just predicts then dispatches.
+     * Returns the prediction error if the ranges don't align on one axis.
+     */
+    fill(sheetIdx, src, dst) {
+        const inputs = this.getWorksheet(sheetIdx).predictFill(src, dst);
+        if (isErrorMessage(inputs))
+            return inputs;
+        return this.execTransaction({
+            payloads: inputs.map((value) => ({ type: 'cellInput', value })),
+            undoable: true,
+            temp: false,
+        });
+    }
     getWorksheetById(id) {
         return new Worksheet(this._id, id, false);
     }
     registryCustomFunc(customFunc) {
         this._calculator.registry(customFunc);
     }
-    _addPayload(p) {
-        if (p.type === 'cellInput')
-            return cell_input(this._id, p.sheetIdx, p.row, p.col, p.input);
-        if (p.type === 'insertRows')
-            return row_insert(this._id, p.sheetIdx, p.start, p.cnt);
-        if (p.type === 'deleteRows')
-            return row_delete(this._id, p.sheetIdx, p.start, p.cnt);
-        if (p.type === 'insertCols')
-            return col_insert(this._id, p.sheetIdx, p.start, p.cnt);
-        if (p.type === 'deleteCols')
-            return col_delete(this._id, p.sheetIdx, p.start, p.cnt);
-        if (p.type === 'createBlock')
-            return create_block(this._id, p.sheetIdx, p.blockId, p.masterRow, p.masterCol, p.rowCnt, p.colCnt);
-        if (p.type === 'moveBlock')
-            return move_block(this._id, p.sheetIdx, p.blockId, p.newMasterRow, p.newMasterCol);
-        if (p.type === 'setCellBorder')
-            return set_cell_border(this._id, p.sheetIdx, p.row, p.col, p.leftColor, p.rightColor, p.topColor, p.bottomColor, p.leftBorderType, p.rightBorderType, p.topBorderType, p.bottomBorderType, p.outline, p.diagonalUp, p.diagonalDown);
-        if (p.type === 'setLineBorder')
-            return set_line_border(this._id, p.sheetIdx, p.row, p.line, p.leftColor, p.rightColor, p.topColor, p.bottomColor, p.leftBorderType, p.rightBorderType, p.topBorderType, p.bottomBorderType, p.outline, p.diagonalUp, p.diagonalDown);
-        if (p.type === 'setCellFont')
-            return set_font(this._id, p.sheetIdx, p.row, p.col, p.bold, p.italic, p.name, p.underline, p.color, p.size, p.outline, p.shadow, p.strike, p.condense);
-        if (p.type === 'setLineFont')
-            return set_line_font(this._id, p.sheetIdx, p.from, p.to, p.row, p.bold, p.italic, p.name, p.underline, p.color, p.size, p.outline, p.shadow, p.strike, p.condense);
-        if (p.type === 'blockInput')
-            return block_input(this._id, p.sheetIdx, p.blockId, p.row, p.col, p.input);
-        if (p.type === 'insertBlockCols')
-            return block_line_shift(this._id, p.sheetIdx, p.blockId, p.colIdx, p.cnt, false, true);
-        if (p.type === 'insertBlockRows')
-            return block_line_shift(this._id, p.sheetIdx, p.blockId, p.rowIdx, p.cnt, true, true);
-        if (p.type === 'deleteBlockRows')
-            return block_line_shift(this._id, p.sheetIdx, p.blockId, p.rowIdx, p.cnt, true, false);
-        if (p.type === 'deleteBlockCols')
-            return block_line_shift(this._id, p.sheetIdx, p.blockId, p.colIdx, p.cnt, true, true);
-        if (p.type === 'sheetRename') {
-            if (p.oldName) {
-                return sheet_rename_by_name(this._id, p.oldName, p.newName);
-            }
-            if (p.idx) {
-                return sheet_rename_by_idx(this._id, p.idx, p.newName);
-            }
-        }
-        if (p.type === 'deleteSheet')
-            return delete_sheet(this._id, p.sheetIdx);
-        if (p.type === 'insertSheet')
-            return create_sheet(this._id, p.sheetIdx, p.name);
-        if (p.type === 'cellClear')
-            return cell_clear(this._id, p.sheetIdx, p.row, p.col);
-        if (p.type === 'setColWidth')
-            return set_col_width(this._id, p.sheetIdx, p.col, p.width);
-        if (p.type === 'setRowHeight')
-            return set_row_height(this._id, p.sheetIdx, p.row, p.height);
-        if (p.type === 'setLineAlignment')
-            return set_line_alignment(this._id, p.sheetIdx, p.row, p.from, p.to, p.alignment.horizontal, p.alignment.vertical);
-        if (p.type === 'setCellAlignment')
-            return set_cell_alignment(this._id, p.sheetIdx, p.row, p.col, p.alignment.horizontal, p.alignment.vertical);
-        if (p.type === 'setCellPatternFill')
-            return set_cell_pattern_fill(this._id, p.sheetIdx, p.row, p.col, p.fgColor, p.bgColor, p.pattern);
-        if (p.type === 'setLinePatternFill')
-            return set_line_pattern_fill(this._id, p.sheetIdx, p.row, p.from, p.to, p.fgColor, p.bgColor, p.pattern);
-        if (p.type === 'mergeCells')
-            return merge_cells(this._id, p.sheetIdx, p.startRow, p.startCol, p.endRow, p.endCol);
-        if (p.type === 'splitMergedCells')
-            return split_merged_cells(this._id, p.sheetIdx, p.row, p.col);
-        if (p.type === 'cellFormatBrush')
-            return set_cell_format_brush(this._id, p.srcSheetIdx, p.srcRow, p.srcCol, p.dstSheetIdx, p.dstRowStart, p.dstColStart, p.dstRowEnd, p.dstColEnd);
-        if (p.type === 'lineFormatBrush')
-            return set_line_format_brush(this._id, p.srcSheetIdx, p.srcRow, p.srcCol, p.dstSheetIdx, p.row, p.from, p.to);
-        // eslint-disable-next-line no-console
-        console.log(`Unimplemented!: ${p.type}`);
+    getShadowCellId(params) {
+        return rpc('getShadowCellId', params, this._id);
+    }
+    getShadowCellIds(params) {
+        return rpc('getShadowCellIds', params, this._id);
+    }
+    getShadowInfoById(params) {
+        return rpc('getShadowInfoById', params, this._id);
+    }
+    getCellId(params) {
+        return rpc('getCellId', params, this._id);
+    }
+    getAllBlockFields() {
+        return rpc('getAllBlockFields', undefined, this._id);
+    }
+    /**
+     * Enumerate blocks across the workbook.
+     *
+     * Scope:
+     *   - `sheetId` set → only that sheet
+     *   - `sheetIdx` set → resolve to sheetId, then that sheet
+     *   - neither set → every sheet
+     * `sheetId` wins if both are set.
+     */
+    getAllBlocks(params) {
+        return rpc('getAllBlocks', {
+            sheetIdx: params?.sheetIdx,
+            sheetId: params?.sheetId,
+        }, this._id);
+    }
+    // ---- Named checkpoints --------------------------------------------
+    //
+    // Save / delete / list go through dedicated RPCs (not the
+    // transaction pipeline) — they manage session-only checkpoint
+    // storage and don't touch sheet state. To restore, send a normal
+    // `restoreCheckpoint` payload via handleTransaction; that lands on
+    // the undo stack so users can Ctrl-Z to reverse the restore.
+    /** Snapshot the current workbook state under `label`. Overwrites
+     *  any existing checkpoint with the same label. Returns the number
+     *  of checkpoints currently stored after this save. */
+    saveCheckpoint(label, description) {
+        return rpc('saveCheckpoint', { label, description }, this._id);
+    }
+    /** Drop a named checkpoint. Returns `true` if it existed. */
+    deleteCheckpoint(label) {
+        return rpc('deleteCheckpoint', { label }, this._id);
+    }
+    /** List all checkpoints (newest first). */
+    listCheckpoints() {
+        return rpc('listCheckpoints', undefined, this._id);
     }
     _inputAsyncResult(r) {
         return input_async_result(this._id, r);
@@ -220,6 +362,9 @@ export class Workbook {
     }
     _cellUpdatedCallbacks = [];
     _sheetInfoUpdatedCallbacks = [];
+    _headerUpdatedCallbacks = [];
+    _cellValueChangedCallbacks = new Map();
+    _cellRemovedCallbacks = new Map();
     // The book id which is generated by `WASM`
     _id;
     _blockManager;

package/dist/src/api/worksheet.d.ts

@@ -1,4 +1,4 @@
-import { BlockInfo, CellPosition, ColInfo, DisplayWindow, DisplayWindowWithStartPoint, RowInfo, Style, Value, CellInfo, SheetDimension, MergeCell } from '../bindings';
+import { BlockInfo, CellPosition, ColInfo, DisplayWindow, DisplayWindowWithStartPoint, RowInfo, Style, Value, CellInfo, SheetDimension, MergeCell, AppendixWithCell, ReproducibleCell, SheetCoordinate, CellInput } from '../bindings';
 import { Cell } from './cell';
 import { Result } from './utils';
 export declare class Worksheet {
@@ -7,18 +7,56 @@ export declare class Worksheet {
     getDisplayWindow(startRow: number, endRow: number, startCol: number, endCol: number): Result<DisplayWindow>;
     getDisplayWindowWithStartPoint(startX: number, startY: number, height: number, width: number): DisplayWindowWithStartPoint;
     getCellPosition(row: number, col: number): CellPosition;
+    getNextUpwardVisibleCell(row: number, col: number): CellPosition;
+    getNextDownwardVisibleCell(row: number, col: number): CellPosition;
+    getNextLeftwardVisibleCell(row: number, col: number): CellPosition;
+    getNextRightwardVisibleCell(row: number, col: number): CellPosition;
+    getUpwardDataBoundary(row: number, col: number): CellPosition;
+    getDownwardDataBoundary(row: number, col: number): CellPosition;
+    getLeftwardDataBoundary(row: number, col: number): CellPosition;
+    getRightwardDataBoundary(row: number, col: number): CellPosition;
     getDisplayWindowWithCellPosition(row: number, col: number, height: number, width: number): DisplayWindowWithStartPoint;
+    getBlockDisplayWindow(blockId: number): Result<DisplayWindow>;
     getRowHeight(rowIdx: number): Result<number>;
     getColWidth(colIdx: number): Result<number>;
     getRowInfo(rowIdx: number): Result<RowInfo>;
     getColInfo(colIdx: number): Result<ColInfo>;
     getCellInfo(rowIdx: number, colIdx: number): Result<CellInfo>;
+    getReproducibleCell(rowIdx: number, colIdx: number): Result<ReproducibleCell>;
+    getReproducibleCells(coordinates: readonly SheetCoordinate[]): Result<readonly ReproducibleCell[]>;
+    getCellInfos(startRow: number, startCol: number, endRow: number, endCol: number): Result<readonly CellInfo[]>;
+    getCellInfosExceptWindow(startRow: number, startCol: number, endRow: number, endCol: number, windowStartRow: number, windowStartCol: number, windowEndRow: number, windowEndCol: number): Result<readonly CellInfo[]>;
+    /**
+     * Predict the fill-handle result: given a source block and the target
+     * block the user dragged over, returns one `CellInput` per target cell
+     * (formula relative-reference shift, arithmetic series, or value copy).
+     *
+     * This is a pure read-only query — it does not mutate the workbook. The
+     * caller wraps the returned inputs in a single transaction (see
+     * `Workbook.fill`) so the fill is one undo step. `src` and `dst` must
+     * align on a single axis (a pure vertical or horizontal drag).
+     */
+    predictFill(src: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }, dst: {
+        startRow: number;
+        startCol: number;
+        endRow: number;
+        endCol: number;
+    }): Result<readonly CellInput[]>;
+    getBlockInfo(blockId: number): BlockInfo;
     getMergedCells(startRow: number, startCol: number, endRow: number, endCol: number): readonly MergeCell[];
     getCell(rowIdx: number, colIdx: number): Result<Cell>;
     getFormula(rowIdx: number, colIdx: number): Result<string>;
     getStyle(rowIdx: number, colIdx: number): Result<Style>;
     getValue(rowIdx: number, colIdx: number): Result<Value>;
+    getDiyCellIdWithBlockId(blockId: number, row: number, col: number): Result<number>;
+    lookupAppendixUpward(blockId: number, row: number, col: number, craftId: string, tag: number): Result<AppendixWithCell>;
     getFullyCoveredBlocks(rowIdx: number, colIdx: number, rowCnt: number, colCnt: number): Result<BlockInfo[]>;
     private _id;
     private _sheetId;
+    private _sheetIdx;
 }