Grid@sheetwrite/vue

readonly store: Store;

readonly actions: GridActions;

getRuntimeResourceSnapshot(operation: RuntimeResourceOperation, phase: RuntimeResourcePhase, runtime?: RuntimeMemoryObservation): RuntimeResourceSnapshot;

getCommandState(command: GridCommandName): GridCommandState;

setActiveSheet(id: SheetId): void;

scrollToCell(addr: CellAddress): void;

getCellAtPoint(clientX: number, clientY: number): CellAddress | null;

getActiveSheet(): SheetId;

getCellInput(row: number, col: number): CellInputSnapshot | null;

getSelection(): Selection | null;

setSelection(sel: Selection | null): void;

getTheme(): Theme;

getShortcutLabel(action: KeyboardAction): string;

setTheme(theme: Partial<Theme>): void;

replaceTheme(theme: Partial<Theme> | undefined): void;

getEffectiveTheme(): Theme;

setReadOnly(readOnly: boolean): void;

setConfig(config: GridConfig | undefined): void;

applyTransaction(transaction: GridTransaction): ApplyTransactionResult;

import type { Grid } from "@sheetwrite/core";

function setFirstCell(grid: Grid) {
  return grid.applyTransaction({ patches: [
    { op: "set", addr: { sheet: grid.getActiveSheet(), row: 0, col: 0 },
      value: { kind: "literal", value: 42 } },
  ] });
}

exportSnapshot(): WorkbookSnapshot;

applyRemoteOperations(operations: readonly DocumentOp[], options?: RemoteOperationOptions): ApplyTransactionResult;

defineCellRenderer(name: string, renderer: CellRenderer): void;

aggregate(col: number, op: AggregateOp): number;

import type { Grid } from "@sheetwrite/core";

function total(grid: Grid) {
  return grid.aggregate(1, "sum");
}

sortBy(col: number, ascending?: boolean): void;

import type { Grid } from "@sheetwrite/core";

function showLargestFirst(grid: Grid) {
  grid.sortBy(1, false);
}

sortByMulti(keys: readonly SortKey[]): void;

filterBy(col: number, needle: string): void;

import type { Grid } from "@sheetwrite/core";

function showOpenRows(grid: Grid) {
  grid.filterBy(0, "Open");
}

setColumnFilter(col: number, filter: ColumnFilter | null): void;

setSort(keys: readonly SortKey[]): ApplyTransactionResult;

getColumnFilters(): ReadonlyMap<number, ColumnFilter>;

distinctValues(col: number, limit?: number): CellScalar[];

hideRows(rows: readonly number[]): void;

showRows(rows?: readonly number[]): void;

hiddenRows(): readonly number[];

hideColumns(cols?: readonly number[]): void;

showColumns(cols?: readonly number[]): void;

hiddenColumns(): readonly number[];

groupRows(start: number, end: number): void;

ungroupRows(start: number, end: number): void;

setGroupCollapsed(start: number, collapsed: boolean): void;

rowGroups(): readonly RowGroup[];

clearView(): void;

undo(): void;

import type { Grid } from "@sheetwrite/core";

function undoAndRestore(grid: Grid) {
  grid.undo();
  grid.redo();
}

redo(): void;

exportCsv(filename: string): void;

import type { Grid } from "@sheetwrite/core";

function downloadCsv(grid: Grid) {
  grid.exportCsv("sales.csv");
}

exportXlsx(filename: string): Promise<void>;

import type { Grid } from "@sheetwrite/core";
import { registerXlsxBackends } from "@sheetwrite/xlsx";

async function downloadXlsx(grid: Grid) {
  await registerXlsxBackends();
  await grid.exportXlsx("sales.xlsx");
}

search(query: string, opts?: SearchOptions): SearchResult;

findNext(): SearchResult;

findPrev(): SearchResult;

clearSearch(): void;

replaceCurrent(replacement: string): SearchResult;

replaceAll(replacement: string): ReplaceResult;

insertRows(at: number, count?: number): void;

removeRows(at: number, count?: number): void;

insertColumns(at: number, count?: number): void;

removeColumns(at: number, count?: number): void;

addSheet(input: AddSheetInput): SheetLifecycleResult;

removeSheet(id: SheetId): SheetLifecycleResult;

renameSheet(id: SheetId, name: string): SheetLifecycleResult;

moveSheet(id: SheetId, toIndex: number): SheetLifecycleResult;

setSheetVisibility(id: SheetId, visibility: SheetVisibility): SheetLifecycleResult;

setConditionalFormats(rules: readonly ConditionalFormatRule[]): void;

setHyperlink(hyperlink: CellHyperlink): ApplyTransactionResult;

removeHyperlink(id: string): ApplyTransactionResult;

getHyperlink(addr: CellAddress): CellHyperlink | null;

activateHyperlink(addr: CellAddress): boolean;

setValidationRule(rule: DataValidationRule): ApplyTransactionResult;

removeValidationRule(id: string): ApplyTransactionResult;

setProtectedRange(protectedRange: ProtectedRange): ApplyTransactionResult;

removeProtectedRange(id: string): ApplyTransactionResult;

setProtectionResolver(resolver: ProtectionResolver | undefined, mode?: MutationPolicyMode): void;

setNote(addr: CellAddress, text: string | null): ApplyTransactionResult;

getNote(addr: CellAddress): string | null;

setOverscan(overscan?: number): void;

setMinColumns(minColumns?: number): void;

highlightCells(ranges: readonly HighlightRange[] | null, color?: string): void;

setPresenceOverlays(overlays: readonly PresenceOverlay[] | null): void;

styleRange(range: Range, style: Partial<CellStyle> | null): void;

beginEdit(row: number, col: number, initial?: string, selectAll?: boolean): void;

dataEdge(row: number, col: number, dRow: number, dCol: number): number | null;

setRowHeight(row: number, height: number): void;

setColumnWidth(col: number, width: number): void;

autoFitRows(range?: Range): void;

autoFitColumns(cols?: readonly number[]): void;

setFrozen(rows: number, cols?: number): void;

setZoom(zoom: number): void;

getZoom(): number;

rendererKind(): "canvas" | "worker";

on<E extends keyof GridEvents>(evt: E, fn: (e: GridEvents[E]) => void): () => void;

refresh(): void;

destroy(): void;