logisheets 0.8.0 → 1.0.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,113 @@ 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);
+    }
+    /**
+     * 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 +202,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,17 +222,40 @@ 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())
@@ -135,75 +268,20 @@ export class Workbook {
     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);
     }
     _inputAsyncResult(r) {
         return input_async_result(this._id, r);
@@ -220,6 +298,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 } from '../bindings';
 import { Cell } from './cell';
 import { Result } from './utils';
 export declare class Worksheet {
@@ -7,18 +7,31 @@ 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;
     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,51 +1,116 @@
-import { get_cell_info, get_col_info, get_col_width, get_formula, get_row_height, get_row_info, get_style, get_value, get_display_window, get_display_window_with_start_point, get_display_window_within_cell, get_cell_position, get_all_fully_covered_blocks, get_sheet_dimension, get_sheet_id, } from '../../wasm';
-import { get_merged_cells } from '../../wasm/logisheets_wasm_server';
+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, sheetIdxOrId, isSheetIdx = true) {
         this._id = id;
         if (isSheetIdx) {
-            this._sheetId = get_sheet_id(id, sheetIdxOrId);
+            this._sheetIdx = sheetIdxOrId;
+            this._sheetId = rpc('getSheetId', { sheetIdx: sheetIdxOrId }, id);
         }
         else {
             this._sheetId = sheetIdxOrId;
+            this._sheetIdx = rpc('getSheetIdx', { sheetId: sheetIdxOrId }, id);
         }
     }
     getSheetDimension() {
-        return get_sheet_dimension(this._id, this._sheetId);
+        return rpc('getSheetDimension', { sheetId: this._sheetId }, this._id);
     }
     getDisplayWindow(startRow, endRow, startCol, endCol) {
-        return get_display_window(this._id, this._sheetId, startRow, endRow, startCol, endCol);
+        return rpc('getDisplayWindow', { sheetIdx: this._sheetIdx, startRow, endRow, startCol, endCol }, this._id);
     }
     getDisplayWindowWithStartPoint(startX, startY, height, width) {
-        return get_display_window_with_start_point(this._id, this._sheetId, startX, startY, height, width);
+        return rpc('getDisplayWindowWithStartPoint', { sheetIdx: this._sheetIdx, startX, startY, height, width }, this._id);
     }
     getCellPosition(row, col) {
-        const result = get_cell_position(this._id, this._sheetId, row, col);
-        return result;
+        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 get_display_window_within_cell(this._id, this._sheetId, 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 get_row_height(this._id, this._sheetId, rowIdx);
+        return rpc('getRowHeight', { sheetId: this._sheetId, rowIdx }, this._id);
     }
     getColWidth(colIdx) {
-        return get_col_width(this._id, this._sheetId, colIdx);
+        return rpc('getColWidth', { sheetId: this._sheetId, colIdx }, this._id);
     }
     getRowInfo(rowIdx) {
-        return get_row_info(this._id, this._sheetId, rowIdx);
+        return rpc('getRowInfo', { sheetIdx: this._sheetIdx, rowIdx }, this._id);
     }
     getColInfo(colIdx) {
-        return get_col_info(this._id, this._sheetId, colIdx);
+        return rpc('getColInfo', { sheetIdx: this._sheetIdx, colIdx }, this._id);
     }
     getCellInfo(rowIdx, colIdx) {
-        const cellInfo = get_cell_info(this._id, this._sheetId, rowIdx, colIdx);
-        return cellInfo;
+        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);
     }
     getMergedCells(startRow, startCol, endRow, endCol) {
-        return get_merged_cells(this._id, this._sheetId, startRow, startCol, endRow, endCol);
+        return rpc('getMergedCells', { sheetIdx: this._sheetIdx, startRow, startCol, endRow, endCol }, this._id);
     }
     getCell(rowIdx, colIdx) {
         const cellInfo = this.getCellInfo(rowIdx, colIdx);
@@ -55,17 +120,41 @@ export class Worksheet {
         return new Cell(cellInfo);
     }
     getFormula(rowIdx, colIdx) {
-        return get_formula(this._id, this._sheetId, rowIdx, colIdx);
+        return rpc('getFormula', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
     getStyle(rowIdx, colIdx) {
-        return get_style(this._id, this._sheetId, rowIdx, colIdx);
+        return rpc('getStyle', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
     getValue(rowIdx, colIdx) {
-        return get_value(this._id, this._sheetId, rowIdx, colIdx);
+        return rpc('getValue', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
+    }
+    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;
+    }
+    lookupAppendixUpward(blockId, row, col, craftId, tag) {
+        return rpc('lookupAppendixUpward', {
+            sheetId: this._sheetId,
+            blockId,
+            row,
+            col,
+            craftId,
+            tag,
+        }, this._id);
     }
     getFullyCoveredBlocks(rowIdx, colIdx, rowCnt, colCnt) {
-        return get_all_fully_covered_blocks(this._id, this._sheetId, 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[];
+    };
 }