logisheets 0.8.0 → 1.1.0

package/dist/src/api/worksheet.js

@@ -1,51 +1,168 @@
-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);
+    }
+    // Ctrl+Arrow: jump to the next data/block boundary. Returns an
+    // ErrorMessage when there is no boundary ahead (caller shows a hint).
+    getUpwardDataBoundary(row, col) {
+        return rpc('getDataBoundary', { sheetIdx: this._sheetIdx, rowIdx: row, colIdx: col, direction: 'up' }, this._id);
+    }
+    getDownwardDataBoundary(row, col) {
+        return rpc('getDataBoundary', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'down',
+        }, this._id);
+    }
+    getLeftwardDataBoundary(row, col) {
+        return rpc('getDataBoundary', {
+            sheetIdx: this._sheetIdx,
+            rowIdx: row,
+            colIdx: col,
+            direction: 'left',
+        }, this._id);
+    }
+    getRightwardDataBoundary(row, col) {
+        return rpc('getDataBoundary', {
+            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);
+    }
+    /**
+     * 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, dst) {
+        return rpc('predictFill', {
+            sheetIdx: this._sheetIdx,
+            srcStartRow: src.startRow,
+            srcStartCol: src.startCol,
+            srcEndRow: src.endRow,
+            srcEndCol: src.endCol,
+            dstStartRow: dst.startRow,
+            dstStartCol: dst.startCol,
+            dstEndRow: dst.endRow,
+            dstEndCol: dst.endCol,
+        }, 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 +172,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[];
+    };
 }

package/dist/src/bindings/action_effect.js

@@ -1 +1,96 @@
-export {};
+export class ActionEffectBuilder {
+    _version;
+    _asyncTasks;
+    _status;
+    _valueChanged;
+    _cellRemoved;
+    _styleChanged;
+    _rowInserted;
+    _rowRemoved;
+    _rowUpdated;
+    _colInserted;
+    _colRemoved;
+    _colUpdated;
+    _headerUpdated;
+    version(value) {
+        this._version = value;
+        return this;
+    }
+    asyncTasks(value) {
+        this._asyncTasks = value;
+        return this;
+    }
+    status(value) {
+        this._status = value;
+        return this;
+    }
+    valueChanged(value) {
+        this._valueChanged = value;
+        return this;
+    }
+    cellRemoved(value) {
+        this._cellRemoved = value;
+        return this;
+    }
+    styleChanged(value) {
+        this._styleChanged = value;
+        return this;
+    }
+    rowInserted(value) {
+        this._rowInserted = value;
+        return this;
+    }
+    rowRemoved(value) {
+        this._rowRemoved = value;
+        return this;
+    }
+    rowUpdated(value) {
+        this._rowUpdated = value;
+        return this;
+    }
+    colInserted(value) {
+        this._colInserted = value;
+        return this;
+    }
+    colRemoved(value) {
+        this._colRemoved = value;
+        return this;
+    }
+    colUpdated(value) {
+        this._colUpdated = value;
+        return this;
+    }
+    headerUpdated(value) {
+        this._headerUpdated = value;
+        return this;
+    }
+    build() {
+        if (this._version === undefined)
+            throw new Error('missing version');
+        if (this._asyncTasks === undefined)
+            throw new Error('missing asyncTasks');
+        if (this._status === undefined)
+            throw new Error('missing status');
+        if (this._valueChanged === undefined)
+            throw new Error('missing valueChanged');
+        if (this._cellRemoved === undefined)
+            throw new Error('missing cellRemoved');
+        if (this._styleChanged === undefined)
+            throw new Error('missing styleChanged');
+        if (this._rowInserted === undefined)
+            throw new Error('missing rowInserted');
+        if (this._rowRemoved === undefined)
+            throw new Error('missing rowRemoved');
+        if (this._rowUpdated === undefined)
+            throw new Error('missing rowUpdated');
+        if (this._colInserted === undefined)
+            throw new Error('missing colInserted');
+        if (this._colRemoved === undefined)
+            throw new Error('missing colRemoved');
+        if (this._colUpdated === undefined)
+            throw new Error('missing colUpdated');
+        if (this._headerUpdated === undefined)
+            throw new Error('missing headerUpdated');
+        return { version: this._version, asyncTasks: this._asyncTasks, status: this._status, valueChanged: this._valueChanged, cellRemoved: this._cellRemoved, styleChanged: this._styleChanged, rowInserted: this._rowInserted, rowRemoved: this._rowRemoved, rowUpdated: this._rowUpdated, colInserted: this._colInserted, colRemoved: this._colRemoved, colUpdated: this._colUpdated, headerUpdated: this._headerUpdated };
+    }
+}

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

@@ -3,4 +3,5 @@ import { VerticalAlignment } from './vertical_alignment';
 export interface Alignment {
     horizontal?: HorizontalAlignment;
     vertical?: VerticalAlignment;
+    wrapText?: boolean;
 }

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

@@ -0,0 +1,4 @@
+export interface AppData {
+    name: string;
+    data: string;
+}

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

@@ -0,0 +1,5 @@
+export interface Appendix {
+    craftId: string;
+    tag: number;
+    content: string;
+}

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

@@ -0,0 +1,8 @@
+import { Appendix } from './appendix';
+export interface AppendixWithCell {
+    appendix: Appendix;
+    sheetId: number;
+    blockId: number;
+    rowIdx: number;
+    colIdx: number;
+}

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

@@ -3,3 +3,13 @@ export interface AsyncFuncResult {
     tasks: readonly Task[];
     values: readonly string[];
 }
+export declare class AsyncFuncResultBuilder {
+    private _tasks;
+    private _values;
+    tasks(value: readonly Task[]): this;
+    values(value: readonly string[]): this;
+    build(): {
+        tasks: readonly Task[];
+        values: readonly string[];
+    };
+}

package/dist/src/bindings/async_func_result.js

@@ -1 +1,19 @@
-export {};
+export class AsyncFuncResultBuilder {
+    _tasks;
+    _values;
+    tasks(value) {
+        this._tasks = value;
+        return this;
+    }
+    values(value) {
+        this._values = value;
+        return this;
+    }
+    build() {
+        if (this._tasks === undefined)
+            throw new Error('missing tasks');
+        if (this._values === undefined)
+            throw new Error('missing values');
+        return { tasks: this._tasks, values: this._values };
+    }
+}

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

@@ -0,0 +1,50 @@
+export interface BindFormSchema {
+    refName: string;
+    sheetIdx: number;
+    blockId: number;
+    fieldFrom: number;
+    keyIdx: number;
+    fields: readonly string[];
+    renderIds: readonly string[];
+    row: boolean;
+    fieldFormulas: readonly string[];
+    validationFormulas: readonly string[];
+    editabilityFormulas: readonly string[];
+}
+export declare class BindFormSchemaBuilder {
+    private _refName;
+    private _sheetIdx;
+    private _blockId;
+    private _fieldFrom;
+    private _keyIdx;
+    private _fields;
+    private _renderIds;
+    private _row;
+    private _fieldFormulas;
+    private _validationFormulas;
+    private _editabilityFormulas;
+    refName(value: string): this;
+    sheetIdx(value: number): this;
+    blockId(value: number): this;
+    fieldFrom(value: number): this;
+    keyIdx(value: number): this;
+    fields(value: readonly string[]): this;
+    renderIds(value: readonly string[]): this;
+    row(value: boolean): this;
+    fieldFormulas(value: readonly string[]): this;
+    validationFormulas(value: readonly string[]): this;
+    editabilityFormulas(value: readonly string[]): this;
+    build(): {
+        refName: string;
+        sheetIdx: number;
+        blockId: number;
+        fieldFrom: number;
+        keyIdx: number;
+        fields: readonly string[];
+        renderIds: readonly string[];
+        row: boolean;
+        fieldFormulas: readonly string[];
+        validationFormulas: readonly string[];
+        editabilityFormulas: readonly string[];
+    };
+}

package/dist/src/bindings/bind_form_schema.js

@@ -0,0 +1,82 @@
+export class BindFormSchemaBuilder {
+    _refName;
+    _sheetIdx;
+    _blockId;
+    _fieldFrom;
+    _keyIdx;
+    _fields;
+    _renderIds;
+    _row;
+    _fieldFormulas;
+    _validationFormulas;
+    _editabilityFormulas;
+    refName(value) {
+        this._refName = value;
+        return this;
+    }
+    sheetIdx(value) {
+        this._sheetIdx = value;
+        return this;
+    }
+    blockId(value) {
+        this._blockId = value;
+        return this;
+    }
+    fieldFrom(value) {
+        this._fieldFrom = value;
+        return this;
+    }
+    keyIdx(value) {
+        this._keyIdx = value;
+        return this;
+    }
+    fields(value) {
+        this._fields = value;
+        return this;
+    }
+    renderIds(value) {
+        this._renderIds = value;
+        return this;
+    }
+    row(value) {
+        this._row = value;
+        return this;
+    }
+    fieldFormulas(value) {
+        this._fieldFormulas = value;
+        return this;
+    }
+    validationFormulas(value) {
+        this._validationFormulas = value;
+        return this;
+    }
+    editabilityFormulas(value) {
+        this._editabilityFormulas = value;
+        return this;
+    }
+    build() {
+        if (this._refName === undefined)
+            throw new Error('missing refName');
+        if (this._sheetIdx === undefined)
+            throw new Error('missing sheetIdx');
+        if (this._blockId === undefined)
+            throw new Error('missing blockId');
+        if (this._fieldFrom === undefined)
+            throw new Error('missing fieldFrom');
+        if (this._keyIdx === undefined)
+            throw new Error('missing keyIdx');
+        if (this._fields === undefined)
+            throw new Error('missing fields');
+        if (this._renderIds === undefined)
+            throw new Error('missing renderIds');
+        if (this._row === undefined)
+            throw new Error('missing row');
+        if (this._fieldFormulas === undefined)
+            throw new Error('missing fieldFormulas');
+        if (this._validationFormulas === undefined)
+            throw new Error('missing validationFormulas');
+        if (this._editabilityFormulas === undefined)
+            throw new Error('missing editabilityFormulas');
+        return { refName: this._refName, sheetIdx: this._sheetIdx, blockId: this._blockId, fieldFrom: this._fieldFrom, keyIdx: this._keyIdx, fields: this._fields, renderIds: this._renderIds, row: this._row, fieldFormulas: this._fieldFormulas, validationFormulas: this._validationFormulas, editabilityFormulas: this._editabilityFormulas };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { RandomSchemaUnit } from './random_schema_unit';
+export interface BindRandomSchema {
+    refName: string;
+    sheetIdx: number;
+    blockId: number;
+    units: readonly RandomSchemaUnit[];
+}
+export declare class BindRandomSchemaBuilder {
+    private _refName;
+    private _sheetIdx;
+    private _blockId;
+    private _units;
+    refName(value: string): this;
+    sheetIdx(value: number): this;
+    blockId(value: number): this;
+    units(value: readonly RandomSchemaUnit[]): this;
+    build(): {
+        refName: string;
+        sheetIdx: number;
+        blockId: number;
+        units: readonly RandomSchemaUnit[];
+    };
+}

package/dist/src/bindings/bind_random_schema.js

@@ -0,0 +1,33 @@
+export class BindRandomSchemaBuilder {
+    _refName;
+    _sheetIdx;
+    _blockId;
+    _units;
+    refName(value) {
+        this._refName = value;
+        return this;
+    }
+    sheetIdx(value) {
+        this._sheetIdx = value;
+        return this;
+    }
+    blockId(value) {
+        this._blockId = value;
+        return this;
+    }
+    units(value) {
+        this._units = value;
+        return this;
+    }
+    build() {
+        if (this._refName === undefined)
+            throw new Error('missing refName');
+        if (this._sheetIdx === undefined)
+            throw new Error('missing sheetIdx');
+        if (this._blockId === undefined)
+            throw new Error('missing blockId');
+        if (this._units === undefined)
+            throw new Error('missing units');
+        return { refName: this._refName, sheetIdx: this._sheetIdx, blockId: this._blockId, units: this._units };
+    }
+}

package/dist/src/bindings/block_cell_id.js

@@ -1,2 +1 @@
-// DO NOT EDIT. CODE GENERATED BY gents.
 export {};

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

@@ -0,0 +1,5 @@
+import { Value } from './value';
+export interface BlockCellInfo {
+    value: Value;
+    shadowValue?: Value;
+}

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

@@ -0,0 +1,4 @@
+import { Value } from './value';
+export interface BlockDataRow {
+    cells: readonly Value[];
+}

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

@@ -0,0 +1,7 @@
+import { BlockInfo } from './block_info';
+import { CellPosition } from './cell_position';
+export interface BlockDisplayInfo {
+    info: BlockInfo;
+    startPosition: CellPosition;
+    endPosition: CellPosition;
+}

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

@@ -0,0 +1,5 @@
+export interface BlockField {
+    sheetId: number;
+    blockId: number;
+    fieldId: string;
+}