SheetSnapshot | @sheetwrite/core

Serializable complete state for one workbook sheet.

Package: @sheetwrite/core
Source: packages/core/src/types/document.ts#L277

Members 18

id

id: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;

name

name: string;

order

order: number;

visibility Hidden worksheets remain in the workbook and retain formulas/references.

visibility?: SheetVisibilitytype SheetVisibility = "visible" | "hidden" | "veryHidden";type SheetVisibility = "visible" | "hidden" | "veryHidden";type SheetVisibility =
  | "visible"
  | "hidden"
  | "veryHidden";Native worksheet visibility preserved across workbook snapshots and tab rendering.API reference →;

rowCount

rowCount: number;

columns Keys are stable, unique document column identities as well as datasource keys.

columns: Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[];

frozenRows

frozenRows?: number;

frozenCols

frozenCols?: number;

rowMeta

rowMeta?: Array<[row: number, meta: RowMetadatainterface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}Persistent display and grouping metadata for one document row.API reference →]>;

merges

merges?: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference →[];

conditionalFormats

conditionalFormats?: ConditionalFormatRuleinterface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}Ordered condition and style applied to a cell range.API reference →[];

validationRules

validationRules?: DataValidationRuleinterface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}One stable, range-scoped data-entry rule. Blank cells are allowed unless disabled.API reference →[];

protectedRanges

protectedRanges?: ProtectedRangeinterface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}Serializable client UX policy. A host resolver decides whether a local mutation may proceed.API reference →[];

notes

notes?: CellNoteinterface CellNote {
  addr: CellAddress;
  text: string;
}interface CellNote {
  addr: CellAddress;
  text: string;
}interface CellNote {
  addr: CellAddress;
  text: string;
}Serializable plain-text note anchored to a cell.API reference →[];

sortKeys

sortKeys?: SortKeyinterface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}One key of a multi-column sort, applied in array order (first = primary).API reference →[];

filters

filters?: Array<[col: number, filter: ColumnFiltertype ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | {
      kind: "values";
      values: readonly CellScalar[];
    }
  | {
      kind: "contains";
      text: string;
      matchCase?: boolean;
    }
  | {
      kind: "compare";
      op:
        | "gt"
        | "gte"
        | "lt"
        | "lte"
        | "eq"
        | "neq";
  // … 4 more lines — see the API reference
}One column's filter predicate. All active column filters AND together; matching is against the cell's resolved value (text or number).API reference →]>;

rowGroups

rowGroups?: RowGroupinterface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}A collapsible row group (data-row range, end-inclusive), Sheets-style.API reference →[];

cells

cells: CellBlockinterface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}interface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}interface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}Sparse row-major cells bounded by one rectangular block.API reference →[];

Declaration

View full TypeScript declaration

export interface SheetSnapshot {
  id: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →;
  name: string;
  order: number;
  visibility?: SheetVisibilitytype SheetVisibility = "visible" | "hidden" | "veryHidden";type SheetVisibility = "visible" | "hidden" | "veryHidden";type SheetVisibility =
  | "visible"
  | "hidden"
  | "veryHidden";Native worksheet visibility preserved across workbook snapshots and tab rendering.API reference →;
  rowCount: number;
  columns: Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[];
  frozenRows?: number;
  frozenCols?: number;
  rowMeta?: Array<[row: number, meta: RowMetadatainterface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}interface RowMetadata {
  height?: number;
  hidden?: boolean;
}Persistent display and grouping metadata for one document row.API reference →]>;
  merges?: MergeRangeinterface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}interface MergeRange {
  r0: number;
  c0: number;
  r1: number;
  c1: number;
}Inclusive merged-cell rectangle in data-row/column coordinates.API reference →[];
  conditionalFormats?: ConditionalFormatRuleinterface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}interface ConditionalFormatRule {
  range: Range;
  when: ConditionalFormatPredicate;
  style: CellStyle;
}Ordered condition and style applied to a cell range.API reference →[];
  validationRules?: DataValidationRuleinterface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}interface DataValidationRule {
  id: string;
  range: Range;
  condition: DataValidationCondition;
  policy: ValidationPolicy;
  allowBlank?: boolean;
  helpText?: string;
}One stable, range-scoped data-entry rule. Blank cells are allowed unless disabled.API reference →[];
  protectedRanges?: ProtectedRangeinterface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}interface ProtectedRange {
  id: string;
  range: Range;
  label?: string;
  permissionKey?: string;
}Serializable client UX policy. A host resolver decides whether a local mutation may proceed.API reference →[];
  notes?: CellNoteinterface CellNote {
  addr: CellAddress;
  text: string;
}interface CellNote {
  addr: CellAddress;
  text: string;
}interface CellNote {
  addr: CellAddress;
  text: string;
}Serializable plain-text note anchored to a cell.API reference →[];
  sortKeys?: SortKeyinterface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}interface SortKey {
  col: number;
  ascending: boolean;
}One key of a multi-column sort, applied in array order (first = primary).API reference →[];
  filters?: Array<[col: number, filter: ColumnFiltertype ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | { kind: "values"; values: readonly CellScalar[] }
  | { kind: "contains"; text: string; matchCase?: boolean }
  | {
      kind: "compare";
      op: "gt" | "gte" | "lt" | "lte" | "eq" | "neq";
      value: number;
    }
  | { kind: "empty" }
  | { kind: "nonEmpty" };type ColumnFilter =
  | {
      kind: "values";
      values: readonly CellScalar[];
    }
  | {
      kind: "contains";
      text: string;
      matchCase?: boolean;
    }
  | {
      kind: "compare";
      op:
        | "gt"
        | "gte"
        | "lt"
        | "lte"
        | "eq"
        | "neq";
  // … 4 more lines — see the API reference
}One column's filter predicate. All active column filters AND together; matching is against the cell's resolved value (text or number).API reference →]>;
  rowGroups?: RowGroupinterface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}interface RowGroup {
  start: number;
  end: number;
  collapsed: boolean;
}A collapsible row group (data-row range, end-inclusive), Sheets-style.API reference →[];
  cells: CellBlockinterface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}interface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}interface CellBlock {
  startRow: number;
  startCol: number;
  rowCount: number;
  colCount: number;
  cells: SnapshotCell[];
}Sparse row-major cells bounded by one rectangular block.API reference →[];
}