@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/state/filter-handlers.d.ts

@@ -0,0 +1,34 @@
+export interface GridFilterHandler<TRow = unknown, TModel = unknown> {
+    doesPass(row: TRow, model: TModel): boolean;
+    readonly serverSerializable: boolean;
+}
+export interface FilterHandlerIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export interface GridFilterHandlerRegistry<TRow = unknown> {
+    register(colId: string, handler: GridFilterHandler<TRow>): void;
+    resolve(colId: string): GridFilterHandler<TRow> | null;
+    readonly size: number;
+}
+export declare function createFilterHandlerRegistry<TRow = unknown>(): GridFilterHandlerRegistry<TRow>;
+export interface FilterHandlerModelDecode {
+    readonly ok: boolean;
+    readonly model: unknown;
+    readonly issues: readonly FilterHandlerIssue[];
+}
+export declare function deserializeFilterHandlerModel(raw: unknown): FilterHandlerModelDecode;
+export interface FilterHandlerEvaluation<TRow> {
+    readonly rows: readonly TRow[];
+    readonly report: {
+        readonly unsupportedColumns: readonly string[];
+    };
+}
+export declare function evaluateFilterHandlers<TRow>(rows: readonly TRow[], models: Readonly<Record<string, unknown>>, registry: GridFilterHandlerRegistry<TRow>): FilterHandlerEvaluation<TRow>;
+export interface FilterHandlerServerPayload {
+    readonly payload: string;
+    readonly report: {
+        readonly withheldColumns: readonly string[];
+    };
+}
+export declare function serializeFilterHandlerModels<TRow>(models: Readonly<Record<string, unknown>>, registry: GridFilterHandlerRegistry<TRow>): FilterHandlerServerPayload;

package/dist/types/components/grid/core/state/find-state.d.ts

@@ -0,0 +1,11 @@
+export interface SyGridFindSlice {
+    readonly query: string;
+    readonly caseSensitive: boolean;
+    readonly scope: 'visible' | 'all';
+    readonly displayValues?: boolean;
+}
+export interface FindSliceIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export declare function validateFindSlice(value: unknown): FindSliceIssue[];

package/dist/types/components/grid/core/state/grid-state.d.ts

@@ -0,0 +1,61 @@
+import { type SyGridState, type SyGridStateEnvelopeIssue, type SyGridStateSliceKey } from './contracts.ts';
+import { type ColumnsSliceApplyResult, type ColumnsSliceCaptureInput } from './slices/columns.ts';
+import { type FilterSliceApplyContext, type FilterSliceApplyResult, type FilterSliceCaptureInput, type FilterSliceIssue } from './slices/filter.ts';
+import { type RowsSlicesApplyContext, type RowsSlicesApplyResult, type RowsSlicesCaptureInput } from './slices/rows.ts';
+import { type UiRestoreContext, type UiRestorePlan, type UiSlicesCaptureInput } from './slices/ui.ts';
+import { type SyGridFindSlice } from './find-state.ts';
+export interface GridStateCaptureInput {
+    readonly find?: SyGridFindSlice;
+    readonly columns: ColumnsSliceCaptureInput;
+    readonly filter: FilterSliceCaptureInput;
+    readonly rows: RowsSlicesCaptureInput;
+    readonly ui: UiSlicesCaptureInput;
+}
+export interface GridStateBuildResult {
+    readonly state: SyGridState;
+    readonly issues: readonly FilterSliceIssue[];
+}
+export declare function buildGridState(input: GridStateCaptureInput): GridStateBuildResult;
+export interface GridStateApplyContexts {
+    readonly findAvailable?: boolean;
+    readonly liveFields: readonly string[];
+    readonly filter: FilterSliceApplyContext;
+    readonly rows: RowsSlicesApplyContext;
+    readonly ui: UiRestoreContext;
+}
+export interface GridStateApplyOptions {
+    readonly applyOrder?: boolean;
+    readonly slices?: readonly SyGridStateSliceKey[];
+}
+export interface GridStateApplyPlan {
+    readonly find?: SyGridFindSlice;
+    readonly ok: boolean;
+    readonly issues: readonly SyGridStateEnvelopeIssue[];
+    readonly requestedAbsentSlices: readonly SyGridStateSliceKey[];
+    readonly unrestorableSlices: readonly SyGridStateSliceKey[];
+    readonly appliedSlices: readonly SyGridStateSliceKey[];
+    readonly columns: ColumnsSliceApplyResult | null;
+    readonly filter: FilterSliceApplyResult | null;
+    readonly rows: RowsSlicesApplyResult | null;
+    readonly ui: UiRestorePlan | null;
+}
+export declare function planGridStateApply(value: unknown, contexts: GridStateApplyContexts, options?: GridStateApplyOptions): GridStateApplyPlan;
+export interface SyGridStateApplyReport {
+    readonly ok: boolean;
+    readonly issues: readonly SyGridStateEnvelopeIssue[];
+    readonly appliedSlices: readonly SyGridStateSliceKey[];
+    readonly requestedAbsentSlices: readonly SyGridStateSliceKey[];
+    readonly unrestorableSlices: readonly SyGridStateSliceKey[];
+    readonly columns: ColumnsSliceApplyResult['report'] | null;
+    readonly filter: FilterSliceApplyResult['report'] | null;
+    readonly rows: RowsSlicesApplyResult['report'] | null;
+    readonly uiUnavailable: readonly UiRestorePlan['unavailable'][number][];
+    readonly afterDataPending: boolean;
+    readonly appliedMigrations: readonly string[];
+    readonly droppedSlices: readonly {
+        slice: string;
+        reason: string;
+    }[];
+}
+export declare function summarizeGridStatePlan(plan: GridStateApplyPlan, afterDataPending: boolean): SyGridStateApplyReport;
+export declare function cloneGridState(state: SyGridState): SyGridState;

package/dist/types/components/grid/core/state/migrate.d.ts

@@ -0,0 +1,21 @@
+import { type SyGridState, type SyGridStateEnvelopeIssue } from './contracts.ts';
+export interface GridStateMigrationContext {
+    dropSlice(slice: string, reason: string): void;
+}
+export interface GridStateMigrationStep {
+    readonly id: string;
+    readonly untilVersion: `${number}.${number}.${number}`;
+    readonly migrate: (value: Record<string, unknown>, context: GridStateMigrationContext) => Record<string, unknown>;
+}
+export interface GridStateMigrationResult {
+    readonly ok: boolean;
+    readonly state: SyGridState | null;
+    readonly issues: readonly SyGridStateEnvelopeIssue[];
+    readonly appliedMigrations: readonly string[];
+    readonly droppedSlices: readonly {
+        slice: string;
+        reason: string;
+    }[];
+}
+export declare const GRID_STATE_MIGRATIONS: readonly GridStateMigrationStep[];
+export declare function migrateGridState(value: unknown, migrations?: readonly GridStateMigrationStep[]): GridStateMigrationResult;

package/dist/types/components/grid/core/state/ownership.d.ts

@@ -0,0 +1,2 @@
+import type { SyGridStateSliceKey } from './contracts.ts';
+export declare const SY_GRID_STATE_SLICE_OWNERS: Readonly<Record<SyGridStateSliceKey, string>>;

package/dist/types/components/grid/core/state/persistence.d.ts

@@ -0,0 +1,21 @@
+import { type SyGridState, type SyGridStateEnvelopeIssue, type SyGridStateSliceKey } from './contracts.ts';
+import { type GridStateMigrationResult } from './migrate.ts';
+export declare const DEFAULT_GRID_STATE_TRANSPORT_BUDGET_BYTES: number;
+export declare const GRID_STATE_PII_BEARING_SLICES: readonly SyGridStateSliceKey[];
+export interface GridStateEncodeResult {
+    readonly ok: boolean;
+    readonly encoded: string | null;
+    readonly jsonBytes: number;
+    readonly issues: readonly SyGridStateEnvelopeIssue[];
+}
+export declare function encodeGridStateForTransport(state: SyGridState, { maxJsonBytes }?: {
+    maxJsonBytes?: number;
+}): GridStateEncodeResult;
+export declare function decodeGridStateFromTransport(encoded: string): GridStateMigrationResult;
+export interface GridStateRedactionResult {
+    readonly state: SyGridState;
+    readonly redactedSlices: readonly SyGridStateSliceKey[];
+}
+export declare function redactGridState(state: SyGridState, slices?: readonly SyGridStateSliceKey[]): GridStateRedactionResult;
+export declare function gridStatesEquivalent(left: SyGridState, right: SyGridState): boolean;
+export declare function namespacedGridStateKey(namespace: string, gridId: string): string;

package/dist/types/components/grid/core/state/slices/columns.d.ts

@@ -0,0 +1,55 @@
+import { type ApplyColumnStateResult, type ColumnStateInput } from '../../column/column-state.ts';
+export interface SyGridColumnsSliceEntry {
+    readonly colId: string;
+    readonly width: number | null;
+    readonly order: number | null;
+    readonly hidden: boolean;
+    readonly pinned: 'left' | 'right' | null;
+    readonly sort: {
+        readonly direction: 'asc' | 'desc';
+        readonly index: number;
+    } | null;
+    readonly aggFunc: string | null;
+    readonly rowGroupIndex: number | null;
+    readonly pivotRowGroupIndex: number | null;
+    readonly pivotIndex: number | null;
+    readonly valueIndex: number | null;
+}
+export interface SyGridColumnsSlice {
+    readonly entries: readonly SyGridColumnsSliceEntry[];
+    readonly collapsedGroupIds: readonly string[];
+    readonly pivotMode: boolean;
+}
+export interface ColumnsSliceCaptureInput extends ColumnStateInput {
+    readonly aggFuncs?: ReadonlyMap<string, string>;
+    readonly rowGroupFields?: readonly string[];
+    readonly pivotRowGroupFields?: readonly string[];
+    readonly pivotMode?: boolean;
+    readonly pivotFields?: readonly string[];
+    readonly valueFields?: readonly string[];
+    readonly collapsedGroupIds?: ReadonlySet<string>;
+}
+export declare function captureColumnsSlice(input: ColumnsSliceCaptureInput): SyGridColumnsSlice;
+export interface ColumnsSliceApplyResult {
+    readonly columnState: ApplyColumnStateResult;
+    readonly aggFuncs: ReadonlyMap<string, string | null>;
+    readonly rowGroupFields: readonly string[];
+    readonly pivotRowGroupFields: readonly string[];
+    readonly pivotMode: boolean;
+    readonly pivotFields: readonly string[];
+    readonly valueFields: readonly string[];
+    readonly collapsedGroupIds: readonly string[];
+    readonly report: {
+        readonly missingColumns: readonly string[];
+        readonly newColumns: readonly string[];
+    };
+}
+export interface ColumnsSliceApplyOptions {
+    readonly applyOrder?: boolean;
+}
+export declare function applyColumnsSlice(slice: SyGridColumnsSlice, liveFields: readonly string[], options?: ColumnsSliceApplyOptions): ColumnsSliceApplyResult;
+export interface ColumnsSliceIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export declare function validateColumnsSlice(value: unknown): ColumnsSliceIssue[];

package/dist/types/components/grid/core/state/slices/filter.d.ts

@@ -0,0 +1,45 @@
+import { type ConditionNode } from '../../filter/condition-builder.ts';
+import type { ActiveFilter, ActiveFilterMap } from '../../filter-cycle.ts';
+export interface SyGridFilterSlice {
+    readonly builtIn: Readonly<Record<string, unknown>>;
+    readonly customModels: Readonly<Record<string, unknown>> | null;
+    readonly quickFilter: string | null;
+    readonly conditionTree: string | null;
+    readonly externalFilterActive: boolean;
+}
+export interface FilterSliceIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export interface FilterSliceCaptureInput {
+    readonly activeFilters: ActiveFilterMap;
+    readonly customModels: Readonly<Record<string, unknown>> | null;
+    readonly customModelErrors?: readonly string[];
+    readonly quickFilter: string | null;
+    readonly conditionTree: ConditionNode | null;
+    readonly externalFilterActive: boolean;
+}
+export interface FilterSliceCaptureResult {
+    readonly slice: SyGridFilterSlice;
+    readonly issues: readonly FilterSliceIssue[];
+}
+export declare function captureFilterSlice(input: FilterSliceCaptureInput): FilterSliceCaptureResult;
+export interface FilterSliceApplyContext {
+    readonly fields: readonly string[];
+    readonly customFilterColumnIds: ReadonlySet<string>;
+}
+export interface FilterSliceApplyResult {
+    readonly builtIn: Readonly<Record<string, ActiveFilter>>;
+    readonly customModels: Readonly<Record<string, unknown>>;
+    readonly quickFilter: string | null;
+    readonly conditionTree: ConditionNode | null;
+    readonly report: {
+        readonly unknownBuiltInColumns: readonly string[];
+        readonly invalidBuiltIn: readonly FilterSliceIssue[];
+        readonly unavailableCustomFilters: readonly string[];
+        readonly conditionTreeError: string | null;
+        readonly externalFilterWasActive: boolean;
+    };
+}
+export declare function applyFilterSlice(slice: SyGridFilterSlice, context: FilterSliceApplyContext): FilterSliceApplyResult;
+export declare function validateFilterSlice(value: unknown): FilterSliceIssue[];

package/dist/types/components/grid/core/state/slices/rows.d.ts

@@ -0,0 +1,73 @@
+import type { CellRange } from '../../selection/range.ts';
+import type { RowSelectionState } from '../../selection/row.ts';
+export type SyGridRowId = string | number;
+export interface SyGridRowGroupingSlice {
+    readonly collapsedGroupRoutes: readonly string[];
+}
+export interface SyGridPivotSlice {
+    readonly collapsedGroupRoutes: readonly string[];
+}
+export interface SyGridExpansionSlice {
+    readonly collapsedTreeNodePaths: readonly string[];
+    readonly expandedDetailRowIds: readonly SyGridRowId[];
+}
+export interface SyGridSelectionSlice {
+    readonly rows: {
+        readonly mode: 'none' | 'single' | 'multi';
+        readonly ids: readonly SyGridRowId[];
+    };
+    readonly ranges: readonly CellRange[];
+}
+export interface RowsSliceIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export declare function compareRowIds(left: SyGridRowId, right: SyGridRowId): number;
+export interface RowsSlicesCaptureInput {
+    readonly collapsedGroupRoutes: ReadonlySet<string>;
+    readonly pivotCollapsedGroupRoutes: ReadonlySet<string>;
+    readonly collapsedTreeNodePaths: ReadonlySet<string>;
+    readonly expandedDetailRowIds: ReadonlySet<SyGridRowId>;
+    readonly rowSelection: RowSelectionState;
+    readonly cellRanges: readonly CellRange[];
+}
+export interface RowsSlices {
+    readonly rowGrouping: SyGridRowGroupingSlice;
+    readonly pivot: SyGridPivotSlice;
+    readonly expansion: SyGridExpansionSlice;
+    readonly selection: SyGridSelectionSlice;
+}
+export declare function captureRowsSlices(input: RowsSlicesCaptureInput): RowsSlices;
+export interface RowsSlicesApplyContext {
+    readonly liveRowIds: ReadonlySet<SyGridRowId> | null;
+    readonly liveTreeNodePaths: ReadonlySet<string> | null;
+    readonly pivotModeActive: boolean;
+    readonly rowCount: number;
+    readonly columnCount: number;
+}
+export interface RowsSlicesApplyResult {
+    readonly collapsedGroupRoutes: readonly string[];
+    readonly pivotCollapsedGroupRoutes: readonly string[];
+    readonly collapsedTreeNodePaths: readonly string[];
+    readonly expandedDetailRowIds: readonly SyGridRowId[];
+    readonly selection: {
+        readonly mode: 'none' | 'single' | 'multi';
+        readonly ids: readonly SyGridRowId[];
+    };
+    readonly ranges: readonly CellRange[];
+    readonly report: {
+        readonly missingDetailRowIds: readonly SyGridRowId[];
+        readonly unverifiedDetailRowIds: readonly SyGridRowId[];
+        readonly missingSelectedRowIds: readonly SyGridRowId[];
+        readonly unverifiedSelectedRowIds: readonly SyGridRowId[];
+        readonly missingTreeNodePaths: readonly string[];
+        readonly unverifiedTreeNodePaths: readonly string[];
+        readonly deferredPivotRoutes: readonly string[];
+        readonly droppedRanges: readonly CellRange[];
+    };
+}
+export declare function applyRowsSlices(slices: RowsSlices, context: RowsSlicesApplyContext): RowsSlicesApplyResult;
+export declare function validateRowGroupingSlice(value: unknown): RowsSliceIssue[];
+export declare function validatePivotSlice(value: unknown): RowsSliceIssue[];
+export declare function validateExpansionSlice(value: unknown): RowsSliceIssue[];
+export declare function validateSelectionSlice(value: unknown): RowsSliceIssue[];

package/dist/types/components/grid/core/state/slices/ui.d.ts

@@ -0,0 +1,77 @@
+export type SyGridRowId = string | number;
+export interface SyGridFocusSlice {
+    readonly activeCell: {
+        readonly rowIndex: number;
+        readonly colIndex: number;
+    } | null;
+}
+export interface SyGridScrollSlice {
+    readonly top: number;
+    readonly left: number;
+}
+export interface SyGridPaginationSlice {
+    readonly pageIndex: number;
+    readonly pageSize: number;
+}
+export interface SyGridSideBarSlice {
+    readonly openPanelId: 'columns' | 'filters' | null;
+}
+export interface SyGridPinnedRowsSlice {
+    readonly topRowIds: readonly SyGridRowId[];
+    readonly bottomRowIds: readonly SyGridRowId[];
+}
+export interface UiSlices {
+    readonly focus: SyGridFocusSlice;
+    readonly scroll: SyGridScrollSlice;
+    readonly pagination: SyGridPaginationSlice;
+    readonly sideBar: SyGridSideBarSlice;
+    readonly pinnedRows: SyGridPinnedRowsSlice;
+}
+export interface UiSlicesCaptureInput {
+    readonly activeCell: {
+        readonly rowIndex: number;
+        readonly colIndex: number;
+    } | null;
+    readonly scrollTop: number;
+    readonly scrollLeft: number;
+    readonly pagination: {
+        readonly pageIndex: number;
+        readonly pageSize: number;
+    } | null;
+    readonly openPanelId: 'columns' | 'filters' | null;
+    readonly pinnedRows?: SyGridPinnedRowsSlice;
+}
+export declare const DEFAULT_UI_PAGINATION: SyGridPaginationSlice;
+export declare function captureUiSlices(input: UiSlicesCaptureInput): UiSlices;
+export interface UiRestoreContext {
+    readonly rowCount: number;
+    readonly columnCount: number;
+    readonly pinnedRowsSupported: boolean;
+}
+export interface UiUnavailableEntry {
+    readonly slice: 'focus' | 'scroll' | 'pagination' | 'sideBar' | 'pinnedRows';
+    readonly path: string;
+    readonly reason: string;
+}
+export interface UiRestorePlan {
+    readonly immediate: {
+        readonly sideBar: SyGridSideBarSlice;
+        readonly pagination: SyGridPaginationSlice;
+    };
+    readonly afterData: {
+        readonly scroll: SyGridScrollSlice;
+        readonly focus: SyGridFocusSlice;
+        readonly pinnedRows: SyGridPinnedRowsSlice | null;
+    };
+    readonly unavailable: readonly UiUnavailableEntry[];
+}
+export declare function planUiRestore(slices: UiSlices, context: UiRestoreContext): UiRestorePlan;
+export interface UiSliceIssue {
+    readonly path: string;
+    readonly detail: string;
+}
+export declare function validateFocusSlice(value: unknown): UiSliceIssue[];
+export declare function validateScrollSlice(value: unknown): UiSliceIssue[];
+export declare function validatePaginationSlice(value: unknown): UiSliceIssue[];
+export declare function validateSideBarSlice(value: unknown): UiSliceIssue[];
+export declare function validatePinnedRowsSlice(value: unknown): UiSliceIssue[];

package/dist/types/components/grid/core/state/state-events.d.ts

@@ -0,0 +1,50 @@
+import type { SyGridStateSliceKey } from './contracts.ts';
+export declare const STATE_ATOM_SLICES: Readonly<{
+    readonly columnWidths: "columns";
+    readonly columnOrder: "columns";
+    readonly columnHidden: "columns";
+    readonly columnPinned: "columns";
+    readonly activeSortModel: "columns";
+    readonly collapsedGroups: "columns";
+    readonly columnDefs: "columns";
+    readonly groupBy: "columns";
+    readonly pivotMode: "columns";
+    readonly pivotRowGroupColumns: "columns";
+    readonly pivotColumns: "columns";
+    readonly pivotValueColumns: "columns";
+    readonly activeFilters: "filter";
+    readonly quickFilterValue: "filter";
+    readonly activeConditionTree: "filter";
+    readonly lifecycleFilterVersion: "filter";
+    readonly collapsedRowGroups: "rowGrouping";
+    readonly pivotCollapsedRowGroups: "pivot";
+    readonly collapsedTreeNodes: "expansion";
+    readonly expandedDetailRows: "expansion";
+    readonly selectionState: "selection";
+    readonly rangeState: "selection";
+    readonly activeCell: "focus";
+    readonly hScrollLeft: "scroll";
+    readonly scrollTop: "scroll";
+    readonly activePagination: "pagination";
+    readonly openToolPanelId: "sideBar";
+}>;
+export type StateAtomKey = keyof typeof STATE_ATOM_SLICES;
+export type StateAtomSnapshot = Readonly<Record<StateAtomKey, unknown>>;
+export interface StateChangeTracker {
+    diff(current: StateAtomSnapshot): SyGridStateSliceKey[];
+}
+export declare function createStateChangeTracker(): StateChangeTracker;
+export type StateUpdateSource = 'interactive' | 'api' | 'restore' | 'initial-state';
+export interface StateUpdatedFlush {
+    readonly changedSlices: readonly SyGridStateSliceKey[];
+    readonly sources: readonly StateUpdateSource[];
+    readonly coalescedBatches: number;
+}
+export interface StateEventCoalescer {
+    note(slices: readonly SyGridStateSliceKey[], source?: StateUpdateSource): boolean;
+    hasPending(): boolean;
+    takeFlush(): StateUpdatedFlush | null;
+    finalizeOnce(): boolean;
+    isFinalized(): boolean;
+}
+export declare function createStateEventCoalescer(): StateEventCoalescer;

package/dist/types/components/grid/core/state/validate.d.ts

@@ -0,0 +1,9 @@
+import { type SyGridState, type SyGridStateEnvelopeValidation, type SyGridStateValidateOptions } from './contracts.ts';
+export interface ParsedGridStateVersion {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+}
+export declare function parseGridStateVersion(value: unknown): ParsedGridStateVersion | null;
+export declare function validateGridStateEnvelope(value: unknown, options?: SyGridStateValidateOptions): SyGridStateEnvelopeValidation;
+export declare function createEmptyGridState(): SyGridState;

package/dist/types/components/grid/core/status-bar/status-bar.d.ts

@@ -0,0 +1,18 @@
+export type StatusPanelId = 'totalRows' | 'filteredRows' | 'totalAndFilteredRows' | 'selectedRows' | 'aggregation';
+export type StatusPanelAlign = 'left' | 'center' | 'right';
+export interface StatusPanelDecl {
+    readonly panel: StatusPanelId;
+    readonly align?: StatusPanelAlign;
+}
+export interface ResolvedStatusPanel {
+    readonly panel: StatusPanelId;
+    readonly align: StatusPanelAlign;
+}
+export interface ResolvedStatusBar {
+    readonly panels: ReadonlyArray<ResolvedStatusPanel>;
+    readonly invalid: readonly string[];
+}
+export declare const STATUS_PANEL_IDS: readonly StatusPanelId[];
+export declare const DEFAULT_STATUS_PANELS: ReadonlyArray<ResolvedStatusPanel>;
+export declare function resolveStatusBar(input: unknown): ResolvedStatusBar | null;
+export type { StatusPanelMessageKey, StatusRowCounts } from './status-panels';

package/dist/types/components/grid/core/status-bar/status-panels.d.ts

@@ -0,0 +1,11 @@
+import type { StatusPanelId } from './status-bar.ts';
+export interface StatusRowCounts {
+    readonly total: number;
+    readonly filtered: number;
+    readonly selected?: number | null;
+}
+export type StatusPanelMessageKey = 'statusBar.totalRows' | 'statusBar.filteredRows' | 'statusBar.totalAndFilteredRows' | 'statusBar.selectedRows';
+export declare function statusPanelMessage(panel: StatusPanelId, counts: StatusRowCounts): {
+    key: StatusPanelMessageKey;
+    vars: Record<string, number>;
+} | null;

package/dist/types/components/grid/core/sync/array.d.ts

@@ -0,0 +1,44 @@
+import { type Op, type SharedType, SyncDoc } from './doc.ts';
+import { type OpId } from './id.ts';
+export interface ArrayInsertOp<V = unknown> extends Op {
+    readonly originLeft: OpId | null;
+    readonly originRight: OpId | null;
+    readonly content: V;
+}
+export interface ArrayDeleteOp extends Op {
+    readonly targets: ReadonlyArray<OpId>;
+}
+export interface ArraySnapshotItem<V = unknown> {
+    readonly id: OpId;
+    readonly origin: OpId | null;
+    readonly rightOrigin: OpId | null;
+    readonly content: V;
+    readonly deleted: boolean;
+}
+export declare class SyncArray<V = unknown> implements SharedType {
+    readonly name: string;
+    private readonly doc;
+    private start;
+    private tail;
+    private visibleLength;
+    private readonly byId;
+    constructor(doc: SyncDoc, name: string);
+    insert(index: number, value: V): void;
+    push(value: V): void;
+    delete(index: number): boolean;
+    deleteRange(index: number, count: number): boolean;
+    move(from: number, to: number): boolean;
+    get length(): number;
+    get(index: number): V | undefined;
+    toArray(): V[];
+    applyOp(op: Op): void;
+    private applyDelete;
+    exportItems(): ArraySnapshotItem<V>[];
+    loadItems(items: ReadonlyArray<ArraySnapshotItem<V>>): void;
+    gc(minSeen: ReadonlyMap<string, number>): number;
+    private nthVisible;
+    private resolve;
+    private sameOrigin;
+    private integrate;
+    private linkAfter;
+}

package/dist/types/components/grid/core/sync/clock.d.ts

@@ -0,0 +1,32 @@
+export type ClockMode = 'lamport' | 'hlc';
+export interface Timestamp {
+    readonly time: number;
+    readonly seq: number;
+    readonly userId: string;
+}
+export interface ClockOptions {
+    mode?: ClockMode;
+    now?: () => number;
+    maxDriftMs?: number;
+}
+export declare function compareTimestamp(a: Timestamp, b: Timestamp): number;
+export declare function timestampEqual(a: Timestamp, b: Timestamp): boolean;
+export declare class LogicalClock {
+    readonly userId: string;
+    readonly mode: ClockMode;
+    private readonly now;
+    private readonly maxDriftMs;
+    private lamport;
+    private hlcWall;
+    private hlcCounter;
+    private seq;
+    constructor(userId: string, options?: ClockOptions);
+    tick(): Timestamp;
+    merge(remote: Timestamp): void;
+    currentTime(): number;
+    currentSeq(): number;
+    seed(time: number, seq: number): void;
+    private physicalWall;
+    private packHlc;
+    private guardCounter;
+}

package/dist/types/components/grid/core/sync/collab-bridge.d.ts

@@ -0,0 +1,28 @@
+import { SyncDoc, type Op } from './doc.ts';
+export type SyncStatus = 'offline' | 'connecting' | 'synced';
+export interface CollabProvider {
+    connect(): void;
+    disconnect(): void;
+    getStatus(): SyncStatus;
+    send(ops: ReadonlyArray<Op>): void;
+    onRemoteOps(listener: (ops: ReadonlyArray<Op>) => void): void;
+    onStatusChange(listener: (status: SyncStatus) => void): void;
+}
+export declare const NOOP_COLLAB_PROVIDER: CollabProvider;
+export interface CollabSigner {
+    signOp(op: Op): Promise<Op>;
+    verifyOp(op: Op): Promise<boolean>;
+}
+export declare class CollabBridge {
+    private readonly doc;
+    private provider;
+    private readonly forwardLocal;
+    private attached;
+    private signer;
+    constructor(doc: SyncDoc);
+    setSigner(signer: CollabSigner | null): void;
+    attach(provider: CollabProvider): void;
+    private receive;
+    detach(): void;
+    getStatus(): SyncStatus;
+}

package/dist/types/components/grid/core/sync/doc.d.ts

@@ -0,0 +1,35 @@
+import { LogicalClock, type ClockOptions, type Timestamp } from './clock.ts';
+export interface Op {
+    readonly ts: Timestamp;
+    readonly target: string;
+    readonly kind: string;
+    readonly sig?: string;
+}
+export interface SharedType {
+    readonly name: string;
+    applyOp(op: Op): void;
+}
+export interface SyncUpdate {
+    readonly ops: ReadonlyArray<Op>;
+    readonly origin: unknown;
+    readonly local: boolean;
+}
+export type UpdateListener = (update: SyncUpdate) => void;
+export declare class SyncDoc {
+    readonly clock: LogicalClock;
+    private readonly shared;
+    private readonly updateListeners;
+    private tx;
+    constructor(userId: string, options?: ClockOptions);
+    get userId(): string;
+    registerShared(type: SharedType): void;
+    getShared(name: string): SharedType | undefined;
+    listShared(): SharedType[];
+    tick(): Timestamp;
+    transact<T>(fn: () => T, origin?: unknown): T;
+    addOp(op: Op): void;
+    applyRemote(ops: ReadonlyArray<Op>, origin?: unknown): void;
+    on(event: 'update', listener: UpdateListener): void;
+    off(event: 'update', listener: UpdateListener): void;
+    private run;
+}

package/dist/types/components/grid/core/sync/id.d.ts

@@ -0,0 +1,11 @@
+import { type Timestamp } from './clock.ts';
+export interface OpId {
+    readonly userId: string;
+    readonly seq: number;
+}
+export declare function makeOpId(userId: string, seq: number): OpId;
+export declare function opIdFromTimestamp(ts: Timestamp): OpId;
+export declare function compareOpId(a: OpId, b: OpId): number;
+export declare function opIdEqual(a: OpId, b: OpId): boolean;
+export declare function encodeOpId(id: OpId): string;
+export declare function decodeOpId(key: string): OpId;