logisheets 0.7.0 → 0.8.0

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

@@ -0,0 +1,21 @@
+export declare class BlockManager {
+    constructor(checkBindBlock: (sheetIdx: number, blockId: number, rowCount: number, colCount: number) => boolean, getAvailableBlockId: (sheetIdx: number) => number);
+    /**
+     * Todo: make sure that the block/craft will never be changed by other
+     * crafts.
+     */
+    bindBlock(sheetIdx: number, blockId: number, rowCount: number, colCount: number): boolean;
+    /**
+     * This function should only find the greatest block id when the available block id
+     * has been set. After that, it will always use the cached value.
+     * This means that every time you call this function after initialization,
+     * it will return a new block id. It will lead to the waste of block ids if you don't create
+     * a block with this id.
+     *
+     * Block id is `usize` in `WASM` side. It should be enough for most cases even we waste some of the ids.
+     */
+    getAvailableBlockId(sheetIdx: number): number;
+    private sheetAvailableBlockIds;
+    private _checkBindBlock;
+    private _getAvailableBlockId;
+}

package/dist/src/api/block_manager.js

@@ -0,0 +1,35 @@
+export class BlockManager {
+    constructor(checkBindBlock, getAvailableBlockId) {
+        this._checkBindBlock = checkBindBlock;
+        this._getAvailableBlockId = getAvailableBlockId;
+    }
+    /**
+     * Todo: make sure that the block/craft will never be changed by other
+     * crafts.
+     */
+    bindBlock(sheetIdx, blockId, rowCount, colCount) {
+        return this._checkBindBlock(sheetIdx, blockId, rowCount, colCount);
+    }
+    /**
+     * This function should only find the greatest block id when the available block id
+     * has been set. After that, it will always use the cached value.
+     * This means that every time you call this function after initialization,
+     * it will return a new block id. It will lead to the waste of block ids if you don't create
+     * a block with this id.
+     *
+     * Block id is `usize` in `WASM` side. It should be enough for most cases even we waste some of the ids.
+     */
+    getAvailableBlockId(sheetIdx) {
+        if (this.sheetAvailableBlockIds.has(sheetIdx)) {
+            const result = this.sheetAvailableBlockIds.get(sheetIdx);
+            this.sheetAvailableBlockIds.set(sheetIdx, result + 1);
+            return result;
+        }
+        const id = this._getAvailableBlockId(sheetIdx);
+        this.sheetAvailableBlockIds.set(sheetIdx, id);
+        return id;
+    }
+    sheetAvailableBlockIds = new Map();
+    _checkBindBlock;
+    _getAvailableBlockId;
+}

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

@@ -0,0 +1,19 @@
+import { AsyncFuncResult, Task } from '../bindings';
+export declare const enum CalcException {
+    Unspecified = 0,
+    ArgErr = 1,
+    TimeOut = 2,
+    NotFound = 3
+}
+export type Executor = (args: readonly string[]) => Promise<string | CalcException>;
+export declare class CustomFunc {
+    readonly funcName: string;
+    executor: Executor;
+    constructor(funcName: string, executor: Executor);
+}
+export declare class Calculator {
+    calc(tasks: readonly Task[]): Promise<AsyncFuncResult>;
+    registry(f: CustomFunc): void;
+    private _exec;
+    private _registry;
+}

package/dist/src/api/calculator.js

@@ -0,0 +1,46 @@
+export class CustomFunc {
+    funcName;
+    executor;
+    constructor(funcName, executor) {
+        this.funcName = funcName;
+        this.executor = executor;
+    }
+}
+export class Calculator {
+    async calc(tasks) {
+        const promises = tasks.map((t) => this._exec(t.asyncFunc, t.args));
+        return Promise.all(promises).then((values) => {
+            const res = values.map((v) => {
+                if (typeof v === 'string') {
+                    return v;
+                }
+                switch (v) {
+                    case 1 /* CalcException.ArgErr */:
+                        return '#ARGERR!';
+                    case 2 /* CalcException.TimeOut */:
+                        return '#TIMEOUT!';
+                    case 3 /* CalcException.NotFound */:
+                        return '#NOTFOUND!';
+                    default:
+                        return '#UNKNOWN!';
+                }
+            });
+            const asyncFuncResult = {
+                tasks,
+                values: res,
+            };
+            return asyncFuncResult;
+        });
+    }
+    registry(f) {
+        this._registry.set(f.funcName, f.executor);
+    }
+    async _exec(func, args) {
+        const executor = this._registry.get(func);
+        if (executor === undefined) {
+            return 3 /* CalcException.NotFound */;
+        }
+        return executor(args);
+    }
+    _registry = new Map();
+}

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

@@ -0,0 +1,28 @@
+import { CellInfo, Value, Style } from '../bindings';
+export declare class Cell {
+    constructor(cellInfo: CellInfo);
+    getText(): string;
+    getStyle(): Style;
+    getFormula(): string;
+    private _value;
+    private _style;
+    private _formula;
+}
+export declare class CellValue {
+    cellValueOneof?: {
+        $case: 'str';
+        str: string;
+    } | {
+        $case: 'number';
+        number: number;
+    } | {
+        $case: 'bool';
+        bool: boolean;
+    } | {
+        $case: 'error';
+        error: string;
+    };
+    get value(): string | number | boolean;
+    get valueStr(): string;
+    static from(value: Value): CellValue;
+}

package/dist/src/api/cell.js

@@ -0,0 +1,52 @@
+export class Cell {
+    constructor(cellInfo) {
+        this._value = CellValue.from(cellInfo.value);
+        this._formula = cellInfo.formula;
+        this._style = cellInfo.style;
+    }
+    getText() {
+        return this._value.valueStr ?? '';
+    }
+    getStyle() {
+        return this._style;
+    }
+    getFormula() {
+        return this._formula;
+    }
+    _value;
+    _style;
+    _formula = '';
+}
+export class CellValue {
+    cellValueOneof;
+    get value() {
+        if (this.cellValueOneof?.$case === 'str')
+            return this.cellValueOneof.str;
+        else if (this.cellValueOneof?.$case === 'bool')
+            return this.cellValueOneof.bool;
+        else if (this.cellValueOneof?.$case === 'error')
+            return this.cellValueOneof.error;
+        else if (this.cellValueOneof?.$case === 'number')
+            return this.cellValueOneof.number;
+        else
+            return '';
+    }
+    get valueStr() {
+        return this.value.toString();
+    }
+    static from(value) {
+        const v = new CellValue();
+        if (hasOwnProperty(value, 'str'))
+            v.cellValueOneof = { $case: 'str', str: value.str };
+        else if (hasOwnProperty(value, 'bool'))
+            v.cellValueOneof = { $case: 'bool', bool: value.bool };
+        else if (hasOwnProperty(value, 'number'))
+            v.cellValueOneof = { $case: 'number', number: value.number };
+        else if (hasOwnProperty(value, 'error'))
+            v.cellValueOneof = { $case: 'error', error: value.error };
+        return v;
+    }
+}
+function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}

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

@@ -1,2 +1,7 @@
 export * from './workbook';
 export * from './worksheet';
+export { CalcException, CustomFunc, Calculator } from './calculator';
+export type { Executor } from './calculator';
+export * from './cell';
+export { isErrorMessage, getPatternFill } from './utils';
+export type { Result } from './utils';

package/dist/src/api/index.js

@@ -1,2 +1,5 @@
 export * from './workbook';
 export * from './worksheet';
+export { CustomFunc, Calculator } from './calculator';
+export * from './cell';
+export { isErrorMessage, getPatternFill } from './utils';

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

@@ -1,3 +1,5 @@
+import { Fill, PatternFill } from '../bindings';
 import { ErrorMessage } from '../bindings/error_message';
 export declare function isErrorMessage(v: any): v is ErrorMessage;
-export declare type Result<V> = V | ErrorMessage;
+export type Result<V> = V | ErrorMessage;
+export declare function getPatternFill(v: Fill): PatternFill | null;

package/dist/src/api/utils.js

@@ -2,3 +2,8 @@
 export function isErrorMessage(v) {
     return 'msg' in v && 'ty' in v;
 }
+export function getPatternFill(v) {
+    if ('patternFill' in v)
+        return v.patternFill;
+    return null;
+}

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

@@ -1,18 +1,40 @@
-import { ActionEffect, AsyncFuncResult, DisplayResponse } from '../bindings';
+import { ActionEffect, SheetInfo } from '../bindings';
 import { Transaction } from '../transactions';
 import { Worksheet } from './worksheet';
-export declare type ReturnCode = number;
+import { CustomFunc } from './calculator';
+import { Result } from './utils';
+export type ReturnCode = number;
+export type Callback = () => void;
 export declare class Workbook {
     constructor();
+    /**
+     * @returns the block id if success, otherwise the error message
+     *
+     * It is caller's responsibility to store the block id.
+     */
+    createBlockForNewCraft(sheetIdx: number, masterRow: number, masterCol: number, rowCount: number, colCount: number): Result<number>;
     undo(): boolean;
     redo(): boolean;
-    execTransaction(tx: Transaction, undoable: boolean): ActionEffect;
-    load(buf: Uint8Array, book_name: string): ReturnCode;
+    registerCellUpdatedCallback(callback: Callback): void;
+    registerSheetInfoUpdateCallback(callback: Callback): void;
+    getAllSheetInfo(): Array<SheetInfo>;
+    checkFormula(f: string): boolean;
+    calcCondition(sheetIdx: number, f: string): Result<boolean>;
+    getSheetId(sheetIdx: number): Result<number>;
+    execTransaction(tx: Transaction): ActionEffect;
+    load(buf: Uint8Array, bookName: string): ReturnCode;
     release(): void;
-    inputAsyncResult(r: AsyncFuncResult): ActionEffect;
-    getPatches(sheet_idx: number, version: number): DisplayResponse;
-    get_sheet_count(): number;
-    get_worksheet(idx: number): Worksheet;
+    getSheetCount(): number;
+    getWorksheet(idx: number): Worksheet;
+    getWorksheetById(id: number): Worksheet;
+    registryCustomFunc(customFunc: CustomFunc): void;
     private _addPayload;
+    private _inputAsyncResult;
+    private _onCellUpdate;
+    private _onSheetUpdate;
+    private _cellUpdatedCallbacks;
+    private _sheetInfoUpdatedCallbacks;
     private _id;
+    private _blockManager;
+    private _calculator;
 }

package/dist/src/api/workbook.js

@@ -1,43 +1,140 @@
-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 { 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 { Worksheet } from './worksheet';
+import { Calculator } from './calculator';
+import { BlockManager } from './block_manager';
 export class Workbook {
     constructor() {
         this._id = new_workbook();
+        this._blockManager = new BlockManager((sheetIdx, blockId, rowCount, colCount) => {
+            return check_bind_block(this._id, sheetIdx, blockId, rowCount, colCount);
+        }, (sheetIdx) => {
+            return get_available_block_id(this._id, sheetIdx);
+        });
+    }
+    /**
+     * @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) {
+        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) {
+            return {
+                msg: 'failed to create block',
+                ty: effect.status.err,
+            };
+        }
+        const bind = this._blockManager.bindBlock(sheetIdx, id, rowCount, colCount);
+        if (!bind) {
+            return {
+                msg: 'failed to bind block',
+                ty: 1,
+            };
+        }
+        return id;
     }
     undo() {
-        return undo(this._id);
+        const result = undo(this._id);
+        if (result) {
+            this._onCellUpdate();
+            this._onSheetUpdate();
+        }
+        return result;
     }
     redo() {
-        return redo(this._id);
+        const result = redo(this._id);
+        if (result) {
+            this._onCellUpdate();
+            this._onSheetUpdate();
+        }
+        return result;
+    }
+    registerCellUpdatedCallback(callback) {
+        this._cellUpdatedCallbacks.push(callback);
     }
-    execTransaction(tx, undoable) {
+    registerSheetInfoUpdateCallback(callback) {
+        this._sheetInfoUpdatedCallbacks.push(callback);
+    }
+    getAllSheetInfo() {
+        return get_all_sheet_info(this._id);
+    }
+    checkFormula(f) {
+        return check_formula(this._id, f);
+    }
+    calcCondition(sheetIdx, f) {
+        return calc_condition(this._id, sheetIdx, f);
+    }
+    getSheetId(sheetIdx) {
+        return get_sheet_id(this._id, sheetIdx);
+    }
+    execTransaction(tx) {
         transaction_start(this._id);
         tx.payloads.forEach((p) => {
             this._addPayload(p);
         });
-        return transaction_end(this._id, undoable);
+        const result = transaction_end(this._id, tx.undoable);
+        if (result.asyncTasks.length > 0) {
+            const asyncResult = this._calculator.calc(result.asyncTasks);
+            asyncResult.then((result) => {
+                this._inputAsyncResult(result);
+                this._onCellUpdate();
+            });
+        }
+        if ('ok' in result.status) {
+            switch (result.status.ok) {
+                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();
+            }
+        }
+        return result;
     }
-    load(buf, book_name) {
-        return read_file(this._id, book_name, buf);
+    load(buf, bookName) {
+        return read_file(this._id, bookName, buf);
     }
     release() {
         release(this._id);
     }
-    inputAsyncResult(r) {
-        return input_async_result(this._id, r);
-    }
-    getPatches(sheet_idx, version) {
-        const res = get_patches(this._id, sheet_idx, version);
-        return res;
-    }
-    get_sheet_count() {
+    getSheetCount() {
         return get_sheet_count(this._id);
     }
-    get_worksheet(idx) {
-        if (idx >= this.get_sheet_count())
+    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);
+    }
     _addPayload(p) {
         if (p.type === 'cellInput')
             return cell_input(this._id, p.sheetIdx, p.row, p.col, p.input);
@@ -53,10 +150,14 @@ export class Workbook {
             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')
+        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')
@@ -79,9 +180,48 @@ export class Workbook {
             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!');
+        console.log(`Unimplemented!: ${p.type}`);
+    }
+    _inputAsyncResult(r) {
+        return input_async_result(this._id, r);
+    }
+    _onCellUpdate() {
+        this._cellUpdatedCallbacks.forEach((exec) => {
+            exec();
+        });
+    }
+    _onSheetUpdate() {
+        this._sheetInfoUpdatedCallbacks.forEach((exec) => {
+            exec();
+        });
     }
+    _cellUpdatedCallbacks = [];
+    _sheetInfoUpdatedCallbacks = [];
     // The book id which is generated by `WASM`
     _id;
+    _blockManager;
+    _calculator = new Calculator();
 }

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

@@ -1,16 +1,24 @@
-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 } 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;
+    getDisplayWindowWithCellPosition(row: number, col: number, height: number, width: number): DisplayWindowWithStartPoint;
+    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>;
+    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>;
+    getFullyCoveredBlocks(rowIdx: number, colIdx: number, rowCnt: number, colCnt: number): Result<BlockInfo[]>;
     private _id;
-    private _sheetIdx;
+    private _sheetId;
 }

package/dist/src/api/worksheet.js

@@ -1,33 +1,71 @@
-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 { 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 { Cell } from './cell';
+import { isErrorMessage } from './utils';
 export class Worksheet {
-    constructor(id, idx) {
+    constructor(id, sheetIdxOrId, isSheetIdx = true) {
         this._id = id;
-        this._sheetIdx = idx;
+        if (isSheetIdx) {
+            this._sheetId = get_sheet_id(id, sheetIdxOrId);
+        }
+        else {
+            this._sheetId = sheetIdxOrId;
+        }
     }
-    get_row_height(row_idx) {
-        return get_row_height(this._id, this._sheetIdx, row_idx);
+    getSheetDimension() {
+        return get_sheet_dimension(this._id, this._sheetId);
     }
-    get_col_width(col_idx) {
-        return get_col_width(this._id, this._sheetIdx, col_idx);
+    getDisplayWindow(startRow, endRow, startCol, endCol) {
+        return get_display_window(this._id, this._sheetId, startRow, endRow, startCol, endCol);
     }
-    get_row_info(row_idx) {
-        return get_row_info(this._id, this._sheetIdx, row_idx);
+    getDisplayWindowWithStartPoint(startX, startY, height, width) {
+        return get_display_window_with_start_point(this._id, this._sheetId, startX, startY, height, width);
     }
-    get_col_info(col_idx) {
-        return get_col_info(this._id, this._sheetIdx, col_idx);
+    getCellPosition(row, col) {
+        const result = get_cell_position(this._id, this._sheetId, row, col);
+        return result;
     }
-    get_cell_info(row_idx, col_idx) {
-        return get_cell_info(this._id, this._sheetIdx, row_idx, col_idx);
+    getDisplayWindowWithCellPosition(row, col, height, width) {
+        return get_display_window_within_cell(this._id, this._sheetId, row, col, height, width);
     }
-    get_formula(row_idx, col_idx) {
-        return get_formula(this._id, this._sheetIdx, row_idx, col_idx);
+    getRowHeight(rowIdx) {
+        return get_row_height(this._id, this._sheetId, rowIdx);
     }
-    get_style(row_idx, col_idx) {
-        return get_style(this._id, this._sheetIdx, row_idx, col_idx);
+    getColWidth(colIdx) {
+        return get_col_width(this._id, this._sheetId, colIdx);
     }
-    get_value(row_idx, col_idx) {
-        return get_value(this._id, this._sheetIdx, row_idx, col_idx);
+    getRowInfo(rowIdx) {
+        return get_row_info(this._id, this._sheetId, rowIdx);
+    }
+    getColInfo(colIdx) {
+        return get_col_info(this._id, this._sheetId, colIdx);
+    }
+    getCellInfo(rowIdx, colIdx) {
+        const cellInfo = get_cell_info(this._id, this._sheetId, rowIdx, colIdx);
+        return cellInfo;
+    }
+    getMergedCells(startRow, startCol, endRow, endCol) {
+        return get_merged_cells(this._id, this._sheetId, startRow, startCol, endRow, endCol);
+    }
+    getCell(rowIdx, colIdx) {
+        const cellInfo = this.getCellInfo(rowIdx, colIdx);
+        if (isErrorMessage(cellInfo)) {
+            return cellInfo;
+        }
+        return new Cell(cellInfo);
+    }
+    getFormula(rowIdx, colIdx) {
+        return get_formula(this._id, this._sheetId, rowIdx, colIdx);
+    }
+    getStyle(rowIdx, colIdx) {
+        return get_style(this._id, this._sheetId, rowIdx, colIdx);
+    }
+    getValue(rowIdx, colIdx) {
+        return get_value(this._id, this._sheetId, rowIdx, colIdx);
+    }
+    getFullyCoveredBlocks(rowIdx, colIdx, rowCnt, colCnt) {
+        return get_all_fully_covered_blocks(this._id, this._sheetId, rowIdx, colIdx, rowCnt, colCnt);
     }
     _id;
-    _sheetIdx;
+    _sheetId;
 }

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

@@ -0,0 +1,6 @@
+import { HorizontalAlignment } from './horizontal_alignment';
+import { VerticalAlignment } from './vertical_alignment';
+export interface Alignment {
+    horizontal?: HorizontalAlignment;
+    vertical?: VerticalAlignment;
+}

package/dist/src/bindings/alignment.js

@@ -0,0 +1 @@
+export {};