CellStore | @sheetwrite/wasm

The workbook-wide store: every sheet, one string pool.

Source: packages/wasm/pkg/sheetwrite_wasm.d.ts#L41

Members 99

acknowledgeRevision

acknowledgeRevision: (revision: bigint) => void;

addPagedSheet Allocate a logical sheet whose cell chunks materialize on page load or edit.

addPagedSheet: (n_cols: number, row_count: number, chunk_rows: number, byte_budget: number, max_dirty_cells: number) => number;

addRows

addRows: (sheet: number, at: number, count: number) => void;

addSheet Allocate a sheet grid and return its numeric handle.

addSheet: (n_cols: number, row_count: number) => number;

admitSourceRange Whether a source rectangle can replace its spill cells without cutting an installed spill away from its anchor.

admitSourceRange: (sheet: number, r0: number, c0: number, r1: number, c1: number) => boolean;

Whether a source rectangle can replace its spill cells without cutting an installed spill away from its anchor. No owner window crosses WASM.

aggregate Column aggregate over numeric cells.

aggregate: (sheet: number, col: number, op: number) => number;

Column aggregate over numeric cells. op: 0 sum, 1 avg, 2 min, 3 max, 4 count.

beginMutation

beginMutation: () => bigint;

beginPageLoad

beginPageLoad: () => void;

canDirtyCell

canDirtyCell: (sheet: number, row: number, col: number) => boolean;

captureRange Capture a dense rectangle into an opaque store-local history resource.

captureRange: (sheet: number, r0: number, c0: number, rows: number, cols: number) => RangeSnapshot | undefined;

captureReferences Capture only persisted references for one sheet.

captureReferences: (sheet: number, max_entries: number) => SourceSnapshot | undefined;

Capture only persisted references for one sheet. The explicit entry cap bounds allocation for host-side structural admission simulation.

captureSources Capture only persisted formula/reference sources in a rectangle.

captureSources: (sheet: number, r0: number, c0: number, rows: number, cols: number) => SourceSnapshot | undefined;

Capture only persisted formula/reference sources in a rectangle. The returned opaque object is compact in source cardinality, not cell count.

captureSourcesForRows Capture persisted formula/reference sources and derived-spill identity for arbitrary row/column coordinates in one boundary crossing.

captureSourcesForRows: (sheet: number, rows: Uint32Array, cols: Uint32Array) => SourceSnapshot | undefined;

Capture persisted formula/reference sources and derived-spill identity for arbitrary row/column coordinates in one boundary crossing. Offsets follow the caller's row-major coordinate order.

cellSnapshots Resolved values of a sparse coordinate list in one batched read.

cellSnapshots: (sheet: number, rows: Uint32Array, cols: Uint32Array) => CellSnapshot | undefined;

Resolved values of a sparse coordinate list in one batched read.

rows and cols are absolute coordinates and must have the same length; otherwise the result carries no cells. Every entry reads exactly like [Self::get_cell], so a batched capture reports the values a per-cell read would.

cellState 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.

cellState: (sheet: number, row: number, col: number) => number;

clearCell

clearCell: (sheet: number, row: number, col: number, style: number) => void;

clearRange Clear a rectangle while independently controlling contents and style.

clearRange: (sheet: number, r0: number, c0: number, r1: number, c1: number, contents: boolean, style: boolean) => boolean;

colCount

colCount: (sheet: number) => number;

columnsFullyLoaded

columnsFullyLoaded: (sheet: number, start_row: number, end_row: number, cols: Uint32Array) => boolean;

commitSources Commit staged user or host sources.

commitSources: () => void;

Commit staged user or host sources. Admission metadata must be staged before this barrier; derived values and string roots are complete on return. Beginning a page load suppresses local dirty tracking until this commit.

compactStringStorage Reclaim unreachable text and release growth slack at a transaction barrier.

compactStringStorage: () => void;

Reclaim unreachable text and release growth slack at a transaction barrier. Raw pool IDs must be discarded when `stringPoolEpoch` changes.

dataEdge Ctrl+Arrow destination: from (row, col) stepping by (drow, dcol) (exactly one of them ±1), return the destination row (vertical moves) or column (horizontal moves), Google Sheets semantics: - current and adjacent…

dataEdge: (sheet: number, row: number, col: number, d_row: number, d_col: number) => number;

Ctrl+Arrow destination: from `(row, col)` stepping by `(d_row, d_col)` (exactly one of them ±1), return the destination row (vertical moves) or column (horizontal moves), Google Sheets semantics:

current and adjacent cell non-empty → end of the contiguous non-empty run;
otherwise → the next non-empty cell in that direction;
nothing ahead → the sheet edge.

dataEdgeOrdered

dataEdgeOrdered: (sheet: number, order: Uint32Array, row: number, col: number, d_row: number, d_col: number) => number;

dirtyRevision

dirtyRevision: (sheet: number, row: number, col: number) => bigint;

distinctValues

distinctValues: (sheet: number, col: number, limit: number) => DistinctColumn;

exportMemoryState Export only live state, not allocator slack or a dependency-index cache.

exportMemoryState: () => Uint8Array;

filterRows Data-row indices whose column text contains needle (case-insensitive).

filterRows: (sheet: number, col: number, needle: string) => Uint32Array;

filterRowsMulti

filterRowsMulti: (sheet: number, cols: Uint32Array, kinds: Uint8Array, flags: Uint8Array, nums: Float64Array, num_counts: Uint32Array, text_counts: Uint32Array, value_nums: Float64Array, value_texts: string[]) => Uint32Array;

formulaMatrixResourceStats Benchmark diagnostic: [current matrix bytes, peak matrix bytes, allocations].

formulaMatrixResourceStats: () => Float64Array;

formulaReadBands Same-sheet calculation prerequisites for startrow..endrow × cols, as flat [rowstart, rowend, colstart, colend) rectangles.

formulaReadBands: (sheet: number, start_row: number, end_row: number, cols: Uint32Array, max_cells: number) => Uint32Array;

Same-sheet calculation prerequisites for `start_row..end_row` × `cols`, as flat `[row_start, row_end, col_start, col_end)` rectangles.

The walk follows each read into the formula cells it reaches, so for H = F - G and F = D - E it reports D, E, F, and G. Spill children follow their anchor; attempted spill destinations are also prerequisites because admission must establish that source cells are empty. Reads of other sheets are skipped. max_cells bounds the walk: a read larger than the remaining budget is skipped, so one whole-column range cannot make a window demand the full column. Rectangles are disjoint and ascend by column, then by row.

formulaSource

formulaSource: (sheet: number, row: number, col: number) => string | undefined;

free

free: () => void;

getCell Single-cell read for interactions/tests — never the render hot path.

getCell: (sheet: number, row: number, col: number) => CellOut;

getWindow One bulk read of a rectangular window for the renderer.

getWindow: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => WindowView;

One bulk read of a rectangular window for the renderer. Returns contiguous packed cell data (row-major over `rows x cols`) with pool IDs and window-local formula-error strings, avoiding per-cell boundary reads.

getWindowRows Bulk read of an explicit row list (sorted/filtered views) — same output shape as getwindow, rows taken from rows rather than a range.

getWindowRows: (sheet: number, rows: Uint32Array, cols: Uint32Array) => WindowView;

Bulk read of an explicit row list (sorted/filtered views) — same output shape as `get_window`, rows taken from `rows` rather than a range.

hydratePageNumbers Hydrate one datasource page column while retaining local dirty cells and request-revision exceptions.

hydratePageNumbers: (sheet: number, col: number, start_row: number, values: Float64Array, style: number, protected_offsets: Uint32Array) => void;

Hydrate one datasource page column while retaining local dirty cells and request-revision exceptions. `protected_offsets` is sorted and relative to `start_row`.

hydratePageStringsPacked Packed-string counterpart to [CellStore::hydratepagenumbers].

hydratePageStringsPacked: (sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number, protected_offsets: Uint32Array) => void;

Packed-string counterpart to [`CellStore::hydrate_page_numbers`].

importRangeMemoryState

importRangeMemoryState: (bytes: Uint8Array, sheet: number, row_start: number, col_start: number) => RangeSnapshot;

insertCols

insertCols: (sheet: number, at: number, count: number) => void;

isFullyLoaded

isFullyLoaded: (sheet: number) => boolean;

isPaged

isPaged: (sheet: number) => boolean;

isSheetAlive

isSheetAlive: (sheet: number) => boolean;

loadedSpans Loaded row runs of one column inside startrow..endrow, as flat [start, end) pairs in ascending, disjoint order.

loadedSpans: (sheet: number, start_row: number, end_row: number, col: number) => Uint32Array;

Loaded row runs of one column inside `start_row..end_row`, as flat `[start, end)` pairs in ascending, disjoint order.

A row belongs to a run only when [Self::columns_fully_loaded] would report it loaded, so a caller can reconcile a whole column with one call instead of probing the band row by row. Rows outside the sheet and empty requests produce no pairs.

markCellCleanRevision

markCellCleanRevision: (sheet: number, row: number, col: number, revision: bigint) => boolean;

markRangeClean

markRangeClean: (sheet: number, start_row: number, end_row: number, start_col: number, end_col: number) => void;

memoryStats

memoryStats: () => Float64Array;

pagedDirtyCoordinates

pagedDirtyCoordinates: (sheet: number) => Float64Array;

pagedStats [chunks, loaded cells, dirty cells, clean chunk bytes, fully loaded, dirty bytes].

pagedStats: (sheet: number) => Float64Array;

persistedCellData Sparse persisted-cell records.

persistedCellData: (sheet: number) => Float64Array;

Sparse persisted-cell records. Each record starts with `[row, col, kind, number, style, string_id, source_kind, source_length]`. Formula UTF-8 is packed into little-endian u32 words; references append one `[sheet, row, col]` triple. The allocation scales with serialized cells and source bytes, never the logical sheet rectangle.

pinRange Replaces caller-owned persistent pins; empty row ranges leave them unchanged.

pinRange: (sheet: number, start_row: number, end_row: number, cols: Uint32Array) => void;

pinReadWindow Replaces transient read protection without changing explicit or viewport pins.

pinReadWindow: (sheet: number, start_row: number, end_row: number, rows: Uint32Array, cols: Uint32Array) => void;

Replaces transient read protection without changing explicit or viewport pins. Nonempty `rows` are backing row IDs; otherwise `[start_row, end_row)` is used.

pinViewportBands Replaces viewport-owned protection independently of transient read pins.

pinViewportBands: (sheet: number, bands: Uint32Array) => void;

poolStrings

poolStrings: (ids: Uint32Array) => string[];

queryResourceStats [contains cache constructions, owned distinct strings].

queryResourceStats: () => Float64Array;

rangeFullyLoaded

rangeFullyLoaded: (sheet: number, r0: number, c0: number, r1: number, c1: number) => boolean;

rangeStyleIds Unique style ids present in a rectangle; cost stays inside WASM.

rangeStyleIds: (sheet: number, r0: number, c0: number, r1: number, c1: number) => Uint32Array;

recompute Recompute formulas affected by cells changed since the last call.

recompute: (sheet: number) => void;

Recompute formulas affected by cells changed since the last call.

The pass first grows the dirty cell set through formula read-sets to find all dependent formulas. It then evaluates only those formulas, using a per-pass memo table to reuse formula results across dependent reads.

recomputeVolatile Explicit volatile barrier.

recomputeVolatile: (serial: number) => boolean;

Explicit volatile barrier. `serial` is a UTC spreadsheet serial using the 1899-12-30 epoch; only TODAY/NOW formulas and their dependents dirty.

referenceTarget

referenceTarget: (sheet: number, row: number, col: number) => Uint32Array | undefined;

referencesTargeting Return packed [sourcesheet, sourcerow, sourcecol, ...] references targeting one sheet, bounded before crossing into the host.

referencesTargeting: (target_sheet: number, max_entries: number) => Uint32Array | undefined;

Return packed `[source_sheet, source_row, source_col, ...]` references targeting one sheet, bounded before crossing into the host.

remapRangeStyles Remap styles over a rectangle using parallel old/new id tables.

remapRangeStyles: (sheet: number, r0: number, c0: number, r1: number, c1: number, old_ids: Uint32Array, new_ids: Uint32Array) => boolean;

removeCols

removeCols: (sheet: number, at: number, count: number) => void;

removeNamedRange

removeNamedRange: (name: string, scope: number) => boolean;

removeRows

removeRows: (sheet: number, at: number, count: number) => void;

removeSheet Tombstone a stable sheet handle and invalidate every formula reference to it.

removeSheet: (sheet: number) => boolean;

removeTable

removeTable: (id: string) => boolean;

renameSheet Rename a live stable sheet handle and rewrite every resolved formula AST reference.

renameSheet: (sheet: number, id: string, name: string) => boolean;

resetFormulaMatrixResourceStats

resetFormulaMatrixResourceStats: () => void;

resetQueryResourceStats

resetQueryResourceStats: () => void;

restoreRange Restore a captured block at a destination of the same dimensions.

restoreRange: (sheet: number, r0: number, c0: number, snapshot: RangeSnapshot) => boolean;

rowCount

rowCount: (sheet: number) => number;

search Cell coordinates whose text matches query, as a flat [row, col, ...] list.

search: (sheet: number, cols: Uint32Array, query: string, case_insensitive: boolean, whole_cell: boolean) => Uint32Array;

Cell coordinates whose text matches `query`, as a flat `[row, col, ...]` list. Scans the requested columns column-major (cache-local), then sorts row-major so search navigation runs top-to-bottom, left-to-right.

setBlockPacked Atomically write one row-major mixed literal/formula/reference block whose text payload arrives packed instead of once per cell.

setBlockPacked: (sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, text_buf: Uint8Array, text_offsets: Uint32Array, styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array) => number;

Atomically write one row-major mixed literal/formula/reference block whose text payload arrives packed instead of once per cell.

text_buf holds the UTF-8 bytes of every KIND_STRING cell of kinds in cell-offset order. text_offsets carries their byte boundaries: the n-th string cell owns text_offsets[n]..text_offsets[n + 1], and the last entry equals the buffer length, so a block without strings passes an empty buffer and &[0]. Literal strings are interned in cell-offset order; source-owned text slots are consumed without interning. The compact status is 0 success, 1 invalid shape/bounds, 2 invalid or duplicate source metadata, and 3 paged dirty-capacity rejection.

setBool

setBool: (sheet: number, row: number, col: number, value: boolean, style: number) => void;

setColumnBlockPacked Atomically write one column-major mixed literal/formula/reference block whose text payload arrives packed.

setColumnBlockPacked: (sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, text_buf: Uint8Array, text_offsets: Uint32Array, styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array) => number;

Atomically write one column-major mixed literal/formula/reference block whose text payload arrives packed.

This is [Self::set_block_packed] with the flat input arrays in the store's own column-major order: cell (row, col) sits at col * rows + row, so a columnar import can fill them column by column. Text packing, source metadata and every status code behave exactly as in [Self::set_block_packed].

setColumnNumbers Bulk-load one column with numbers starting at startrow.

setColumnNumbers: (sheet: number, col: number, start_row: number, values: Float64Array, style: number) => void;

Bulk-load one column with numbers starting at `start_row`.

setColumnStrings Bulk-load one column with strings starting at startrow.

setColumnStrings: (sheet: number, col: number, start_row: number, values: string[], style: number) => void;

Bulk-load one column with strings starting at `start_row`.

setColumnStringsPacked Bulk-load one column of strings from a single concatenated buffer plus per-row lengths in UTF-16 code units (the JS string.length unit).

setColumnStringsPacked: (sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number) => void;

Bulk-load one column of strings from a single concatenated buffer plus per-row lengths in UTF-16 code units (the JS `string.length` unit). One boundary decode and one Rust allocation for the whole column, instead of one per row — the dominant ingest cost for text columns.

setConditionalRules Replace a sheet's conditional-format rules.

setConditionalRules: (sheet: number, kinds: Uint8Array, bounds: Uint32Array, nums: Float64Array, strs: string[], flags: Uint8Array) => void;

Replace a sheet's conditional-format rules. Packed columnar encoding, one entry per rule: `kinds` 0 gt / 1 lt / 2 eqNum / 3 eqStr / 4 eqEmpty / 5 contains / 6 boolean formula; `bounds` = normalized `[r0, c0, r1, c1]` per rule; `nums` carries the numeric operand; `strs` the text/formula operand; `flags` bit 0 = match-case for `contains`, bit 1 = stop-if-true. Formula strings are parsed once here, never once per visible cell.

setFormula Parse and store a formula at (row, col).

setFormula: (sheet: number, row: number, col: number, src: string, style: number) => number;

Parse and store a formula at `(row, col)`.

Setters only mark cells dirty; they do not recompute formulas. The host calls recompute(sheet) once at the transaction barrier so a multi-cell edit performs one dependency-scoped pass instead of one full-sheet pass per setter. A successful parse returns the pre-write cached scalar; a parse rejection returns 0.0, and a rejected write returns NaN.

The dependency index is invalidated only when the rewrite changes what the formula reads or whether it produces an array. A constant-only edit keeps the cached index, so its next recompute visits just the edited formula and its dependents instead of every formula in the workbook.

setNamedRange

setNamedRange: (name: string, scope: number, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number) => boolean;

setNumber

setNumber: (sheet: number, row: number, col: number, value: number, style: number) => void;

setSheetName

setSheetName: (sheet: number, id: string, name: string) => void;

setSparseBlock Write one sparse mixed transaction/page/snapshot block without allocating by logical rectangle size.

setSparseBlock: (sheet: number, start_row: number, start_col: number, rows: number, cols: number, offsets: Uint32Array, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array) => number;

Write one sparse mixed transaction/page/snapshot block without allocating by logical rectangle size. Inside `beginPageLoad`, dirty paged cells are skipped; otherwise the whole sparse write is preflighted.

setSpillBlockers Replace the host-owned merge/protection collision ranges.

setSpillBlockers: (sheet: number, bounds: Uint32Array) => boolean;

Replace the host-owned merge/protection collision ranges. Packed as `[row_start, col_start, row_end, col_end, ...]`; invalid input fails without weakening the old gate.

setString

setString: (sheet: number, row: number, col: number, value: string, style: number) => void;

setTable

setTable: (id: string, name: string, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number, header_row: boolean, totals_row: boolean, column_ids: string[], column_names: string[]) => boolean;

snapshotNumbers

snapshotNumbers: (snapshot: RangeSnapshot) => Float64Array;

snapshotTexts

snapshotTexts: (snapshot: RangeSnapshot) => string[];

sortRows Stable row order sorted by a column.

sortRows: (sheet: number, col: number, ascending: boolean) => Uint32Array;

Stable row order sorted by a column. Returns a data-row permutation.

sortRowsMulti

sortRowsMulti: (sheet: number, cols: Uint32Array, ascending: Uint8Array, candidates: Uint32Array) => Uint32Array;

spillAnchorCol

spillAnchorCol: (sheet: number, row: number, col: number) => number;

spillAnchorRow Stable spill owner coordinate, or u32::MAX when cell is not part of a materialized spill.

spillAnchorRow: (sheet: number, row: number, col: number) => number;

spillDerivedMask Row-major mask aligned with render-window layout; 1 marks a derived spill cell and deliberately excludes the anchor.

spillDerivedMask: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => Uint8Array;

spillOwnerCoordinates Packed row-major [anchorrow, anchorcol, ...] owner coordinates.

spillOwnerCoordinates: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => Uint32Array;

Packed row-major `[anchor_row, anchor_col, ...]` owner coordinates.

stringPoolEpoch Raw string IDs are valid only within this epoch, including window IDs.

stringPoolEpoch: () => number;

styleIdAt Current style-dictionary id at a cell; 0 when out of bounds.

styleIdAt: (sheet: number, row: number, col: number) => number;

Current style-dictionary id at a cell; `0` when out of bounds. Used by the host to write derived (reference-shadow) values without disturbing the cell's style.

wasmCommittedBytes

wasmCommittedBytes: () => number;

importMemoryState Import into a fresh instance; failure never mutates the source store.

static importMemoryState: (bytes: Uint8Array) => CellStore

Declaration

View full TypeScript declaration

class CellStore {
  acknowledgeRevision: (revision: bigint) => void;
  addPagedSheet: (
    n_cols: number,
    row_count: number,
    chunk_rows: number,
    byte_budget: number,
    max_dirty_cells: number,
  ) => number;
  addRows: (sheet: number, at: number, count: number) => void;
  addSheet: (n_cols: number, row_count: number) => number;
  admitSourceRange: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
  ) => boolean;
  aggregate: (sheet: number, col: number, op: number) => number;
  beginMutation: () => bigint;
  beginPageLoad: () => void;
  canDirtyCell: (sheet: number, row: number, col: number) => boolean;
  captureRange: (
    sheet: number,
    r0: number,
    c0: number,
    rows: number,
    cols: number,
  ) => RangeSnapshot | undefined;
  captureReferences: (
    sheet: number,
    max_entries: number,
  ) => SourceSnapshot | undefined;
  captureSources: (
    sheet: number,
    r0: number,
    c0: number,
    rows: number,
    cols: number,
  ) => SourceSnapshot | undefined;
  captureSourcesForRows: (
    sheet: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => SourceSnapshot | undefined;
  cellSnapshots: (
    sheet: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => CellSnapshot | undefined;
  cellState: (sheet: number, row: number, col: number) => number;
  clearCell: (sheet: number, row: number, col: number, style: number) => void;
  clearRange: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
    contents: boolean,
    style: boolean,
  ) => boolean;
  colCount: (sheet: number) => number;
  columnsFullyLoaded: (
    sheet: number,
    start_row: number,
    end_row: number,
    cols: Uint32Array,
  ) => boolean;
  commitSources: () => void;
  compactStringStorage: () => void;
  dataEdge: (
    sheet: number,
    row: number,
    col: number,
    d_row: number,
    d_col: number,
  ) => number;
  dataEdgeOrdered: (
    sheet: number,
    order: Uint32Array,
    row: number,
    col: number,
    d_row: number,
    d_col: number,
  ) => number;
  dirtyRevision: (sheet: number, row: number, col: number) => bigint;
  distinctValues: (
    sheet: number,
    col: number,
    limit: number,
  ) => DistinctColumn;
  exportMemoryState: () => Uint8Array;
  filterRows: (sheet: number, col: number, needle: string) => Uint32Array;
  filterRowsMulti: (
    sheet: number,
    cols: Uint32Array,
    kinds: Uint8Array,
    flags: Uint8Array,
    nums: Float64Array,
    num_counts: Uint32Array,
    text_counts: Uint32Array,
    value_nums: Float64Array,
    value_texts: string[],
  ) => Uint32Array;
  formulaMatrixResourceStats: () => Float64Array;
  formulaReadBands: (
    sheet: number,
    start_row: number,
    end_row: number,
    cols: Uint32Array,
    max_cells: number,
  ) => Uint32Array;
  formulaSource: (
    sheet: number,
    row: number,
    col: number,
  ) => string | undefined;
  free: () => void;
  getCell: (sheet: number, row: number, col: number) => CellOut;
  getWindow: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => WindowView;
  getWindowRows: (
    sheet: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => WindowView;
  hydratePageNumbers: (
    sheet: number,
    col: number,
    start_row: number,
    values: Float64Array,
    style: number,
    protected_offsets: Uint32Array,
  ) => void;
  hydratePageStringsPacked: (
    sheet: number,
    col: number,
    start_row: number,
    buf: string,
    utf16_lens: Uint32Array,
    style: number,
    protected_offsets: Uint32Array,
  ) => void;
  importRangeMemoryState: (
    bytes: Uint8Array,
    sheet: number,
    row_start: number,
    col_start: number,
  ) => RangeSnapshot;
  insertCols: (sheet: number, at: number, count: number) => void;
  isFullyLoaded: (sheet: number) => boolean;
  isPaged: (sheet: number) => boolean;
  isSheetAlive: (sheet: number) => boolean;
  loadedSpans: (
    sheet: number,
    start_row: number,
    end_row: number,
    col: number,
  ) => Uint32Array;
  markCellCleanRevision: (
    sheet: number,
    row: number,
    col: number,
    revision: bigint,
  ) => boolean;
  markRangeClean: (
    sheet: number,
    start_row: number,
    end_row: number,
    start_col: number,
    end_col: number,
  ) => void;
  memoryStats: () => Float64Array;
  pagedDirtyCoordinates: (sheet: number) => Float64Array;
  pagedStats: (sheet: number) => Float64Array;
  persistedCellData: (sheet: number) => Float64Array;
  pinRange: (
    sheet: number,
    start_row: number,
    end_row: number,
    cols: Uint32Array,
  ) => void;
  pinReadWindow: (
    sheet: number,
    start_row: number,
    end_row: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => void;
  pinViewportBands: (sheet: number, bands: Uint32Array) => void;
  poolStrings: (ids: Uint32Array) => string[];
  queryResourceStats: () => Float64Array;
  rangeFullyLoaded: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
  ) => boolean;
  rangeStyleIds: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
  ) => Uint32Array;
  recompute: (sheet: number) => void;
  recomputeVolatile: (serial: number) => boolean;
  referenceTarget: (
    sheet: number,
    row: number,
    col: number,
  ) => Uint32Array | undefined;
  referencesTargeting: (
    target_sheet: number,
    max_entries: number,
  ) => Uint32Array | undefined;
  remapRangeStyles: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
    old_ids: Uint32Array,
    new_ids: Uint32Array,
  ) => boolean;
  removeCols: (sheet: number, at: number, count: number) => void;
  removeNamedRange: (name: string, scope: number) => boolean;
  removeRows: (sheet: number, at: number, count: number) => void;
  removeSheet: (sheet: number) => boolean;
  removeTable: (id: string) => boolean;
  renameSheet: (sheet: number, id: string, name: string) => boolean;
  resetFormulaMatrixResourceStats: () => void;
  resetQueryResourceStats: () => void;
  restoreRange: (
    sheet: number,
    r0: number,
    c0: number,
    snapshot: RangeSnapshot,
  ) => boolean;
  rowCount: (sheet: number) => number;
  search: (
    sheet: number,
    cols: Uint32Array,
    query: string,
    case_insensitive: boolean,
    whole_cell: boolean,
  ) => Uint32Array;
  setBlockPacked: (
    sheet: number,
    start_row: number,
    start_col: number,
    rows: number,
    cols: number,
    kinds: Uint8Array,
    numbers: Float64Array,
    text_buf: Uint8Array,
    text_offsets: Uint32Array,
    styles: Uint32Array,
    formula_offsets: Uint32Array,
    formula_sources: string[],
    reference_offsets: Uint32Array,
    reference_targets: Uint32Array,
  ) => number;
  setBool: (
    sheet: number,
    row: number,
    col: number,
    value: boolean,
    style: number,
  ) => void;
  setColumnBlockPacked: (
    sheet: number,
    start_row: number,
    start_col: number,
    rows: number,
    cols: number,
    kinds: Uint8Array,
    numbers: Float64Array,
    text_buf: Uint8Array,
    text_offsets: Uint32Array,
    styles: Uint32Array,
    formula_offsets: Uint32Array,
    formula_sources: string[],
    reference_offsets: Uint32Array,
    reference_targets: Uint32Array,
  ) => number;
  setColumnNumbers: (
    sheet: number,
    col: number,
    start_row: number,
    values: Float64Array,
    style: number,
  ) => void;
  setColumnStrings: (
    sheet: number,
    col: number,
    start_row: number,
    values: string[],
    style: number,
  ) => void;
  setColumnStringsPacked: (
    sheet: number,
    col: number,
    start_row: number,
    buf: string,
    utf16_lens: Uint32Array,
    style: number,
  ) => void;
  setConditionalRules: (
    sheet: number,
    kinds: Uint8Array,
    bounds: Uint32Array,
    nums: Float64Array,
    strs: string[],
    flags: Uint8Array,
  ) => void;
  setFormula: (
    sheet: number,
    row: number,
    col: number,
    src: string,
    style: number,
  ) => number;
  setNamedRange: (
    name: string,
    scope: number,
    sheet: number,
    row_start: number,
    col_start: number,
    row_end: number,
    col_end: number,
  ) => boolean;
  setNumber: (
    sheet: number,
    row: number,
    col: number,
    value: number,
    style: number,
  ) => void;
  setSheetName: (sheet: number, id: string, name: string) => void;
  setSparseBlock: (
    sheet: number,
    start_row: number,
    start_col: number,
    rows: number,
    cols: number,
    offsets: Uint32Array,
    kinds: Uint8Array,
    numbers: Float64Array,
    texts: string[],
    styles: Uint32Array,
    formula_offsets: Uint32Array,
    formula_sources: string[],
    reference_offsets: Uint32Array,
    reference_targets: Uint32Array,
  ) => number;
  setSpillBlockers: (sheet: number, bounds: Uint32Array) => boolean;
  setString: (
    sheet: number,
    row: number,
    col: number,
    value: string,
    style: number,
  ) => void;
  setTable: (
    id: string,
    name: string,
    sheet: number,
    row_start: number,
    col_start: number,
    row_end: number,
    col_end: number,
    header_row: boolean,
    totals_row: boolean,
    column_ids: string[],
    column_names: string[],
  ) => boolean;
  snapshotNumbers: (snapshot: RangeSnapshot) => Float64Array;
  snapshotTexts: (snapshot: RangeSnapshot) => string[];
  sortRows: (sheet: number, col: number, ascending: boolean) => Uint32Array;
  sortRowsMulti: (
    sheet: number,
    cols: Uint32Array,
    ascending: Uint8Array,
    candidates: Uint32Array,
  ) => Uint32Array;
  spillAnchorCol: (sheet: number, row: number, col: number) => number;
  spillAnchorRow: (sheet: number, row: number, col: number) => number;
  spillDerivedMask: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => Uint8Array;
  spillOwnerCoordinates: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => Uint32Array;
  stringPoolEpoch: () => number;
  styleIdAt: (sheet: number, row: number, col: number) => number;
  wasmCommittedBytes: () => number;
  static importMemoryState: (bytes: Uint8Array) => CellStore;
}

Referenced by

Workspace packages depending on @sheetwrite/wasm

@sheetwrite/benchdependency
@sheetwrite/coredependency
@sheetwrite/docs-startdependency

Public exports naming CellStore

SheetwriteEngine@sheetwrite/core

Loading documentation…