logisheets 0.7.0 → 1.0.0

package/dist/src/api/workbook.js

@@ -1,87 +1,308 @@
-import { new_workbook, undo, redo, transaction_end, transaction_start, cell_input, row_insert, row_delete, col_insert, col_delete, create_block, move_block, block_input, set_font, set_border, read_file, release, input_async_result, get_patches, block_line_shift, sheet_rename_by_idx, sheet_rename_by_name, create_sheet, delete_sheet, get_sheet_count, } from '../../wasm/logisheets_wasm_server';
+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 rpc('checkBindBlock', { sheetIdx, blockId, rowCount, colCount }, 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, rowCnt, colCnt) {
+        const id = this._blockManager.getAvailableBlockId(sheetIdx);
+        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.value,
+            };
+        }
+        const bind = this._blockManager.bindBlock(sheetIdx, id, rowCnt, colCnt);
+        if (!bind) {
+            return {
+                msg: 'failed to bind block',
+                ty: 1,
+            };
+        }
+        return id;
     }
     undo() {
-        return undo(this._id);
+        const result = rpc('undo', undefined, this._id);
+        if (result) {
+            this._onCellUpdate();
+            this._onSheetUpdate();
+        }
+        return result;
     }
     redo() {
-        return redo(this._id);
+        const result = rpc('redo', undefined, this._id);
+        if (result) {
+            this._onCellUpdate();
+            this._onSheetUpdate();
+        }
+        return result;
+    }
+    registerCellUpdatedCallback(callback) {
+        this._cellUpdatedCallbacks.push(callback);
+    }
+    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);
     }
-    execTransaction(tx, undoable) {
-        transaction_start(this._id);
-        tx.payloads.forEach((p) => {
-            this._addPayload(p);
+    getAllSheetInfo() {
+        return rpc('getAllSheetInfo', undefined, this._id);
+    }
+    checkFormula(f) {
+        return rpc('checkFormula', { formula: f }, this._id);
+    }
+    calcCondition(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);
+    }
+    /**
+     * 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 rpc('getSheetId', { sheetIdx }, this._id);
+    }
+    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,
         });
-        return transaction_end(this._id, 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);
     }
-    load(buf, book_name) {
-        return read_file(this._id, book_name, buf);
+    _registerCellValueChangedCallback(id, callback) {
+        if (!this._cellValueChangedCallbacks.has(id)) {
+            this._cellValueChangedCallbacks.set(id, []);
+        }
+        this._cellValueChangedCallbacks.get(id)?.push(callback);
     }
-    release() {
-        release(this._id);
+    registerCellValueChangedByCellId(cellId, callback) {
+        this._registerCellValueChangedCallback(cellId, callback);
     }
-    inputAsyncResult(r) {
-        return input_async_result(this._id, r);
+    commitTempStatus() {
+        rpc('commitTempStatus', undefined, this._id);
     }
-    getPatches(sheet_idx, version) {
-        const res = get_patches(this._id, sheet_idx, version);
-        return res;
+    cleanupTempStatus() {
+        rpc('cleanTempStatus', undefined, this._id);
     }
-    get_sheet_count() {
-        return get_sheet_count(this._id);
+    toggleStatus(useTemp) {
+        rpc('toggleStatus', { useTemp }, this._id);
     }
-    get_worksheet(idx) {
-        if (idx >= this.get_sheet_count())
-            throw Error(`invalid sheet index: ${idx}`);
-        return new Worksheet(this._id, idx);
+    batchGetCellInfoById(ids) {
+        return rpc('batchGetCellInfoById', { ids }, this._id);
     }
-    _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 === 'setBorder')
-            return set_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 === 'setFont')
-            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 === '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);
+    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) => {
+                this._inputAsyncResult(result);
+                this._onCellUpdate();
+            });
+        }
+        if (result.status.type === 'ok') {
+            switch (result.status.value) {
+                case 'cell':
+                    this._onCellUpdate();
+                    break;
+                case 'sheet':
+                    this._onSheetUpdate();
+                    break;
+                case 'sheetAndCell':
+                    this._onCellUpdate();
+                    this._onSheetUpdate();
+                    break;
+                case 'undoNothing':
+                case 'redoNothing':
+                case 'doNothing':
+                    break;
+                default:
+                    this._onCellUpdate();
+                    this._onSheetUpdate();
             }
-            if (p.idx) {
-                return sheet_rename_by_idx(this._id, p.idx, p.newName);
+            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));
             }
         }
-        if (p.type === 'deleteSheet')
-            return delete_sheet(this._id, p.sheetIdx);
-        if (p.type === 'insertSheet')
-            return create_sheet(this._id, p.sheetIdx, p.name);
-        // eslint-disable-next-line no-console
-        console.log('Unimplemented!');
+        return result;
+    }
+    load(buf, bookName) {
+        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() {
+        rpc('release', undefined, this._id);
+    }
+    getSheetCount() {
+        return rpc('getSheetCount', undefined, this._id);
+    }
+    getWorksheet(idx) {
+        if (idx >= this.getSheetCount())
+            throw Error(`invalid sheet index: ${idx}`);
+        return new Worksheet(this._id, idx);
+    }
+    getWorksheetById(id) {
+        return new Worksheet(this._id, id, false);
+    }
+    registryCustomFunc(customFunc) {
+        this._calculator.registry(customFunc);
+    }
+    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);
+    }
+    _inputAsyncResult(r) {
+        return input_async_result(this._id, r);
+    }
+    _onCellUpdate() {
+        this._cellUpdatedCallbacks.forEach((exec) => {
+            exec();
+        });
+    }
+    _onSheetUpdate() {
+        this._sheetInfoUpdatedCallbacks.forEach((exec) => {
+            exec();
+        });
     }
+    _cellUpdatedCallbacks = [];
+    _sheetInfoUpdatedCallbacks = [];
+    _headerUpdatedCallbacks = [];
+    _cellValueChangedCallbacks = new Map();
+    _cellRemovedCallbacks = new Map();
     // The book id which is generated by `WASM`
     _id;
+    _blockManager;
+    _calculator = new Calculator();
 }

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

@@ -1,16 +1,37 @@
-import { ColInfo, RowInfo, Style, Value } from '../bindings';
-import { CellInfo } from '../bindings/cell_info';
+import { BlockInfo, CellPosition, ColInfo, DisplayWindow, DisplayWindowWithStartPoint, RowInfo, Style, Value, CellInfo, SheetDimension, MergeCell, AppendixWithCell, ReproducibleCell, SheetCoordinate } from '../bindings';
+import { Cell } from './cell';
 import { Result } from './utils';
 export declare class Worksheet {
-    constructor(id: number, idx: number);
-    get_row_height(row_idx: number): Result<number>;
-    get_col_width(col_idx: number): Result<number>;
-    get_row_info(row_idx: number): Result<RowInfo>;
-    get_col_info(col_idx: number): Result<ColInfo>;
-    get_cell_info(row_idx: number, col_idx: number): Result<CellInfo>;
-    get_formula(row_idx: number, col_idx: number): Result<string>;
-    get_style(row_idx: number, col_idx: number): Result<Style>;
-    get_value(row_idx: number, col_idx: number): Result<Value>;
+    constructor(id: number, sheetIdxOrId: number, isSheetIdx?: boolean);
+    getSheetDimension(): Result<SheetDimension>;
+    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;
+    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[]>;
+    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;
 }

package/dist/src/api/worksheet.js

@@ -1,33 +1,160 @@
-import { get_cell_info, get_col_info, get_col_width, get_formula, get_row_height, get_row_info, get_style, get_value, } from '../../wasm';
+import { handle } from '../../wasm/logisheets_wasm_server';
+import { Cell } from './cell';
+import { isErrorMessage } from './utils';
+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 Worksheet {
-    constructor(id, idx) {
+    constructor(id, sheetIdxOrId, isSheetIdx = true) {
         this._id = id;
-        this._sheetIdx = idx;
+        if (isSheetIdx) {
+            this._sheetIdx = sheetIdxOrId;
+            this._sheetId = rpc('getSheetId', { sheetIdx: sheetIdxOrId }, id);
+        }
+        else {
+            this._sheetId = sheetIdxOrId;
+            this._sheetIdx = rpc('getSheetIdx', { sheetId: sheetIdxOrId }, id);
+        }
+    }
+    getSheetDimension() {
+        return rpc('getSheetDimension', { sheetId: this._sheetId }, this._id);
+    }
+    getDisplayWindow(startRow, endRow, startCol, endCol) {
+        return rpc('getDisplayWindow', { sheetIdx: this._sheetIdx, startRow, endRow, startCol, endCol }, this._id);
+    }
+    getDisplayWindowWithStartPoint(startX, startY, height, width) {
+        return rpc('getDisplayWindowWithStartPoint', { sheetIdx: this._sheetIdx, startX, startY, height, width }, this._id);
+    }
+    getCellPosition(row, col) {
+        return rpc('getCellPosition', { sheetIdx: this._sheetIdx, row, col }, this._id);
+    }
+    getNextUpwardVisibleCell(row, col) {
+        return rpc('getNextVisibleCell', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'up',
+        }, this._id);
+    }
+    getNextDownwardVisibleCell(row, col) {
+        return rpc('getNextVisibleCell', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'down',
+        }, this._id);
+    }
+    getNextLeftwardVisibleCell(row, col) {
+        return rpc('getNextVisibleCell', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'left',
+        }, this._id);
+    }
+    getNextRightwardVisibleCell(row, col) {
+        return rpc('getNextVisibleCell', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'right',
+        }, this._id);
+    }
+    getDisplayWindowWithCellPosition(row, col, height, width) {
+        return rpc('getDisplayWindowWithinCell', { sheetIdx: this._sheetIdx, row, col, height, width }, this._id);
+    }
+    getBlockDisplayWindow(blockId) {
+        return rpc('getBlockDisplayWindow', { sheetId: this._sheetId, blockId }, this._id);
+    }
+    getRowHeight(rowIdx) {
+        return rpc('getRowHeight', { sheetId: this._sheetId, rowIdx }, this._id);
+    }
+    getColWidth(colIdx) {
+        return rpc('getColWidth', { sheetId: this._sheetId, colIdx }, this._id);
+    }
+    getRowInfo(rowIdx) {
+        return rpc('getRowInfo', { sheetIdx: this._sheetIdx, rowIdx }, this._id);
+    }
+    getColInfo(colIdx) {
+        return rpc('getColInfo', { sheetIdx: this._sheetIdx, colIdx }, this._id);
+    }
+    getCellInfo(rowIdx, colIdx) {
+        return rpc('getCell', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
+    }
+    getReproducibleCell(rowIdx, colIdx) {
+        return rpc('getReproducibleCell', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
+    }
+    getReproducibleCells(coordinates) {
+        return rpc('getReproducibleCells', { sheetIdx: this._sheetIdx, coordinates }, this._id);
+    }
+    getCellInfos(startRow, startCol, endRow, endCol) {
+        return rpc('getCellInfos', { sheetIdx: this._sheetIdx, startRow, startCol, endRow, endCol }, this._id);
+    }
+    getCellInfosExceptWindow(startRow, startCol, endRow, endCol, windowStartRow, windowStartCol, windowEndRow, windowEndCol) {
+        return rpc('getCellsExceptWindow', {
+            sheetIdx: this._sheetIdx,
+            startRow,
+            startCol,
+            endRow,
+            endCol,
+            windowStartRow,
+            windowStartCol,
+            windowEndRow,
+            windowEndCol,
+        }, this._id);
+    }
+    getBlockInfo(blockId) {
+        return rpc('getBlockInfo', { sheetId: this._sheetId, blockId }, this._id);
     }
-    get_row_height(row_idx) {
-        return get_row_height(this._id, this._sheetIdx, row_idx);
+    getMergedCells(startRow, startCol, endRow, endCol) {
+        return rpc('getMergedCells', { sheetIdx: this._sheetIdx, startRow, startCol, endRow, endCol }, this._id);
     }
-    get_col_width(col_idx) {
-        return get_col_width(this._id, this._sheetIdx, col_idx);
+    getCell(rowIdx, colIdx) {
+        const cellInfo = this.getCellInfo(rowIdx, colIdx);
+        if (isErrorMessage(cellInfo)) {
+            return cellInfo;
+        }
+        return new Cell(cellInfo);
     }
-    get_row_info(row_idx) {
-        return get_row_info(this._id, this._sheetIdx, row_idx);
+    getFormula(rowIdx, colIdx) {
+        return rpc('getFormula', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
-    get_col_info(col_idx) {
-        return get_col_info(this._id, this._sheetIdx, col_idx);
+    getStyle(rowIdx, colIdx) {
+        return rpc('getStyle', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
-    get_cell_info(row_idx, col_idx) {
-        return get_cell_info(this._id, this._sheetIdx, row_idx, col_idx);
+    getValue(rowIdx, colIdx) {
+        return rpc('getValue', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
-    get_formula(row_idx, col_idx) {
-        return get_formula(this._id, this._sheetIdx, row_idx, col_idx);
+    getDiyCellIdWithBlockId(blockId, row, col) {
+        const cellId = rpc('getDiyCellIdWithBlockId', { sheetId: this._sheetId, blockId, row, col }, this._id);
+        if (cellId === undefined) {
+            return { msg: 'Cell not found', ty: 0 };
+        }
+        return cellId;
     }
-    get_style(row_idx, col_idx) {
-        return get_style(this._id, this._sheetIdx, row_idx, col_idx);
+    lookupAppendixUpward(blockId, row, col, craftId, tag) {
+        return rpc('lookupAppendixUpward', {
+            sheetId: this._sheetId,
+            blockId,
+            row,
+            col,
+            craftId,
+            tag,
+        }, this._id);
     }
-    get_value(row_idx, col_idx) {
-        return get_value(this._id, this._sheetIdx, row_idx, col_idx);
+    getFullyCoveredBlocks(rowIdx, colIdx, rowCnt, colCnt) {
+        return rpc('getFullyCoveredBlocks', {
+            sheetId: this._sheetId,
+            row: rowIdx,
+            col: colIdx,
+            rowCnt,
+            colCnt,
+        }, this._id);
     }
     _id;
+    _sheetId;
     _sheetIdx;
 }

package/dist/src/bindings/action_effect.d.ts

@@ -1,7 +1,63 @@
+import { SheetCellId } from './sheet_cell_id';
+import { SheetColId } from './sheet_col_id';
+import { SheetRowId } from './sheet_row_id';
 import { StatusCode } from './status_code';
 import { Task } from './task';
 export interface ActionEffect {
     version: number;
     asyncTasks: readonly Task[];
     status: StatusCode;
+    valueChanged: readonly SheetCellId[];
+    cellRemoved: readonly SheetCellId[];
+    styleChanged: readonly SheetCellId[];
+    rowInserted: readonly SheetRowId[];
+    rowRemoved: readonly SheetRowId[];
+    rowUpdated: readonly SheetRowId[];
+    colInserted: readonly SheetColId[];
+    colRemoved: readonly SheetColId[];
+    colUpdated: readonly SheetColId[];
+    headerUpdated: readonly number[];
+}
+export declare class ActionEffectBuilder {
+    private _version;
+    private _asyncTasks;
+    private _status;
+    private _valueChanged;
+    private _cellRemoved;
+    private _styleChanged;
+    private _rowInserted;
+    private _rowRemoved;
+    private _rowUpdated;
+    private _colInserted;
+    private _colRemoved;
+    private _colUpdated;
+    private _headerUpdated;
+    version(value: number): this;
+    asyncTasks(value: readonly Task[]): this;
+    status(value: StatusCode): this;
+    valueChanged(value: readonly SheetCellId[]): this;
+    cellRemoved(value: readonly SheetCellId[]): this;
+    styleChanged(value: readonly SheetCellId[]): this;
+    rowInserted(value: readonly SheetRowId[]): this;
+    rowRemoved(value: readonly SheetRowId[]): this;
+    rowUpdated(value: readonly SheetRowId[]): this;
+    colInserted(value: readonly SheetColId[]): this;
+    colRemoved(value: readonly SheetColId[]): this;
+    colUpdated(value: readonly SheetColId[]): this;
+    headerUpdated(value: readonly number[]): this;
+    build(): {
+        version: number;
+        asyncTasks: readonly Task[];
+        status: StatusCode;
+        valueChanged: readonly SheetCellId[];
+        cellRemoved: readonly SheetCellId[];
+        styleChanged: readonly SheetCellId[];
+        rowInserted: readonly SheetRowId[];
+        rowRemoved: readonly SheetRowId[];
+        rowUpdated: readonly SheetRowId[];
+        colInserted: readonly SheetColId[];
+        colRemoved: readonly SheetColId[];
+        colUpdated: readonly SheetColId[];
+        headerUpdated: readonly number[];
+    };
 }