@syidax/advanced 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,33 @@
+import { type Timestamp } from './clock.ts';
+import { type Op, type SharedType, SyncDoc } from './doc.ts';
+export interface MapOp<V = unknown> extends Op {
+    readonly key: string;
+    readonly value?: V;
+}
+export interface MapSnapshotEntry<V = unknown> {
+    readonly key: string;
+    readonly value: V | undefined;
+    readonly ts: Timestamp;
+    readonly deleted: boolean;
+}
+export declare class SyncMap<V = unknown> implements SharedType {
+    readonly name: string;
+    private readonly doc;
+    private readonly state;
+    constructor(doc: SyncDoc, name: string);
+    set(key: string, value: V): void;
+    delete(key: string): boolean;
+    get(key: string): V | undefined;
+    has(key: string): boolean;
+    get size(): number;
+    entries(): IterableIterator<[
+        string,
+        V
+    ]>;
+    keys(): IterableIterator<string>;
+    applyOp(op: Op): void;
+    exportEntries(): MapSnapshotEntry<V>[];
+    loadEntries(entries: ReadonlyArray<MapSnapshotEntry<V>>): void;
+    gc(minSeen: ReadonlyMap<string, number>): number;
+    private integrate;
+}

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

@@ -0,0 +1,11 @@
+import { SyncDoc } from './doc.ts';
+export declare class SyncText {
+    readonly name: string;
+    private readonly doc;
+    private readonly seq;
+    constructor(doc: SyncDoc, name: string);
+    insert(index: number, str: string): void;
+    delete(index: number, len: number): void;
+    get length(): number;
+    toString(): string;
+}

package/dist/types/components/grid/core/sync/undo-manager.d.ts

@@ -0,0 +1,23 @@
+import { SyncDoc } from './doc.ts';
+import { SyncMap } from './map.ts';
+export declare class UndoManager<V = unknown> {
+    private readonly doc;
+    private readonly map;
+    private readonly captureTimeoutMs;
+    private readonly now;
+    private readonly current;
+    private readonly undoStack;
+    private readonly redoStack;
+    private readonly listener;
+    constructor(doc: SyncDoc, map: SyncMap<V>, options?: {
+        captureTimeoutMs?: number;
+        now?: () => number;
+    });
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+    destroy(): void;
+    undo(): boolean;
+    redo(): boolean;
+    private observe;
+}

package/dist/types/components/grid/core/theme/apply.d.ts

@@ -0,0 +1,12 @@
+import type { TokenMap } from './tokens';
+import type { GridThemePresetName, GridTokenOverrides } from './presets';
+export interface GridThemeObject {
+    extends?: GridTheme;
+    tokens?: GridTokenOverrides;
+}
+export type GridTheme = GridThemePresetName | GridThemeObject | null | undefined;
+export type GridThemeDataAttribute = GridThemePresetName | 'custom' | undefined;
+export declare function resolveTheme(theme: GridTheme): TokenMap;
+export declare function themeDataAttribute(theme: GridTheme): GridThemeDataAttribute;
+export declare function applyTheme(host: HTMLElement | null, theme: GridTheme): void;
+export declare function isGridTheme(value: unknown): value is GridTheme;

package/dist/types/components/grid/core/theme/presets.d.ts

@@ -0,0 +1,9 @@
+import type { GridTokenName } from './tokens';
+export type GridTokenOverrides = Partial<Record<GridTokenName, string>>;
+export declare const alpineTokens: GridTokenOverrides;
+export declare const balhamTokens: GridTokenOverrides;
+export declare const darkAlpineTokens: GridTokenOverrides;
+export declare const darkBalhamTokens: GridTokenOverrides;
+export type GridThemePresetName = 'alpine' | 'balham' | 'alpine-dark' | 'balham-dark';
+export declare const GRID_THEME_PRESET_NAMES: readonly GridThemePresetName[];
+export declare function isGridThemePresetName(name: string): name is GridThemePresetName;

package/dist/types/components/grid/core/theme/tokens.d.ts

@@ -0,0 +1,13 @@
+export type GridTokenCategory = 'surface' | 'border' | 'text' | 'header' | 'row' | 'cell' | 'focus' | 'scrollbar' | 'sort-arrow' | 'filter' | 'pagination' | 'loading';
+export interface GridTokenEntry {
+    readonly name: string;
+    readonly defaultValue: string;
+    readonly category: GridTokenCategory;
+    readonly description: string;
+}
+export declare const GRID_TOKEN_CATALOGUE: readonly GridTokenEntry[];
+export type GridTokenName = (typeof GRID_TOKEN_CATALOGUE)[number]['name'];
+export type TokenMap = Record<GridTokenName, string>;
+export declare const defaultTokens: Readonly<TokenMap>;
+export declare const GRID_TOKEN_NAMES: readonly GridTokenName[];
+export declare function isGridTokenName(name: string): name is GridTokenName;

package/dist/types/components/grid/core/tree/reparent.d.ts

@@ -0,0 +1,159 @@
+export interface ReparentNode {
+    readonly id: string;
+    readonly parentId: string | null;
+    readonly parentKnown?: boolean;
+    readonly childrenLoaded?: boolean;
+    readonly visible?: boolean;
+    readonly revision?: number;
+}
+export interface ReparentTree {
+    readonly nodes: readonly ReparentNode[];
+    readonly byId: ReadonlyMap<string, ReparentNode>;
+    readonly childrenOf: ReadonlyMap<string | null, readonly string[]>;
+    readonly duplicateIds: readonly string[];
+}
+export declare function buildReparentTree(nodes: readonly ReparentNode[]): ReparentTree;
+export declare const ANCESTRY_RESULTS: readonly [
+    "rooted",
+    "unresolved",
+    "cyclic"
+];
+export type AncestryResultKind = (typeof ANCESTRY_RESULTS)[number];
+export interface AncestryWalk {
+    readonly kind: AncestryResultKind;
+    readonly chain: readonly string[];
+    readonly unresolvedAt: string | null;
+    readonly cycleAt: string | null;
+}
+export declare function walkAncestry(tree: ReparentTree, startId: string): AncestryWalk;
+export declare function collectDescendants(tree: ReparentTree, rootId: string): readonly string[];
+export declare function topmostNodes(tree: ReparentTree, nodeIds: readonly string[]): readonly string[];
+export declare const REPARENT_ATOMICITIES: readonly [
+    "all-or-nothing",
+    "best-effort"
+];
+export type ReparentAtomicity = (typeof REPARENT_ATOMICITIES)[number];
+export declare const REPARENT_REFUSAL_REASONS: readonly [
+    "unknown-node",
+    "unknown-parent",
+    "self-drop",
+    "descendant-drop",
+    "unresolved-ancestry",
+    "existing-cycle",
+    "filtered-parent",
+    "unloaded-parent",
+    "no-op",
+    "stale-revision",
+    "duplicate-node",
+    "depth-limit",
+    "ambiguous-id",
+    "partial-failure",
+    "empty-request",
+    "index-out-of-range"
+];
+export type ReparentRefusalReason = (typeof REPARENT_REFUSAL_REASONS)[number];
+export declare const REPARENT_ENTRY_STATUSES: readonly [
+    "moved",
+    "refused"
+];
+export type ReparentEntryStatus = (typeof REPARENT_ENTRY_STATUSES)[number];
+export interface ReparentRequest {
+    readonly nodeIds: readonly string[];
+    readonly newParentId: string | null;
+    readonly childIndex?: number;
+    readonly atomicity?: ReparentAtomicity;
+    readonly expectedRevisions?: Readonly<Record<string, number>>;
+    readonly maxDepth?: number;
+    readonly allowFilteredParent?: boolean;
+    readonly allowUnloadedParent?: boolean;
+}
+export interface ReparentEntry {
+    readonly nodeId: string;
+    readonly status: ReparentEntryStatus;
+    readonly reason: ReparentRefusalReason | null;
+    readonly detail: string;
+    readonly previousParentId: string | null;
+    readonly descendantCount: number;
+}
+export interface ReparentPlan {
+    readonly newParentId: string | null;
+    readonly childIndex: number;
+    readonly atomicity: ReparentAtomicity;
+    readonly entries: readonly ReparentEntry[];
+    readonly moving: readonly string[];
+    readonly absorbed: readonly string[];
+}
+export type ReparentPlanResult = {
+    readonly outcome: 'planned';
+    readonly plan: ReparentPlan;
+} | {
+    readonly outcome: 'refused';
+    readonly reason: ReparentRefusalReason;
+    readonly detail: string;
+    readonly entries: readonly ReparentEntry[];
+};
+export type ReparentApplyResult = {
+    readonly outcome: 'applied';
+    readonly nodes: readonly ReparentNode[];
+    readonly moved: readonly ReparentEntry[];
+    readonly refused: readonly ReparentEntry[];
+    readonly bumped: readonly string[];
+} | {
+    readonly outcome: 'refused';
+    readonly reason: ReparentRefusalReason;
+    readonly detail: string;
+    readonly nodes: readonly ReparentNode[];
+};
+export declare function nodeDepth(tree: ReparentTree, nodeId: string): number | null;
+export declare function subtreeHeight(tree: ReparentTree, nodeId: string): number;
+export declare function planReparent(tree: ReparentTree, request: ReparentRequest): ReparentPlanResult;
+export declare function applyReparent(tree: ReparentTree, plan: ReparentPlan, options?: {
+    readonly bumpRevisions?: boolean;
+}): ReparentApplyResult;
+export declare const HOVER_EXPAND_DECISIONS: readonly [
+    "waiting",
+    "expand",
+    "idle",
+    "refuse"
+];
+export type HoverExpandDecisionKind = (typeof HOVER_EXPAND_DECISIONS)[number];
+export declare const HOVER_EXPAND_REFUSALS: readonly [
+    "leaf",
+    "already-expanded",
+    "inside-dragged-subtree",
+    "unknown-node",
+    "unloaded-children",
+    "filtered"
+];
+export type HoverExpandRefusal = (typeof HOVER_EXPAND_REFUSALS)[number];
+export interface HoverExpandState {
+    readonly nodeId: string | null;
+    readonly dwell: number;
+    readonly autoExpanded: readonly string[];
+}
+export declare const EMPTY_HOVER_EXPAND_STATE: HoverExpandState;
+export interface HoverExpandDecision {
+    readonly kind: HoverExpandDecisionKind;
+    readonly nodeId: string | null;
+    readonly reason: HoverExpandRefusal | null;
+    readonly detail: string;
+    readonly state: HoverExpandState;
+}
+export interface HoverExpandConfig {
+    readonly dwellTicks?: number;
+    readonly expanded: ReadonlySet<string>;
+    readonly draggedNodeId: string | null;
+    readonly allowUnloaded?: boolean;
+}
+export declare const DEFAULT_HOVER_DWELL_TICKS = 6;
+export declare function hoverExpandTick(tree: ReparentTree, state: HoverExpandState, nodeId: string | null, config: HoverExpandConfig): HoverExpandDecision;
+export declare function hoverExpandRestore(state: HoverExpandState, userExpanded: ReadonlySet<string>): readonly string[];
+export interface ReparentReport {
+    readonly nodes: number;
+    readonly roots: number;
+    readonly duplicateIds: number;
+    readonly unresolved: readonly string[];
+    readonly cyclic: readonly string[];
+    readonly maxDepth: number;
+}
+export declare function reparentReport(tree: ReparentTree): ReparentReport;

package/dist/types/components/grid/core/tree/tree-data-chunk.d.ts

@@ -0,0 +1,4 @@
+export { createTreeDataStage, INVALID_TREE_PATH_LABEL } from '../pipeline/tree.ts';
+export { buildPathsFromParentIds, NO_ID_LABEL } from './tree-data.ts';
+export * from './reparent.ts';
+export * from '../row-drag/reparent-facade.ts';

package/dist/types/components/grid/core/tree/tree-data.d.ts

@@ -0,0 +1,19 @@
+export declare const NO_ID_LABEL = "(no id)";
+export interface ParentIdTreeSpec<TRow = unknown> {
+    getId: (row: TRow) => unknown;
+    getParentId: (row: TRow) => unknown;
+    getLabel?: (row: TRow) => unknown;
+}
+export interface ParentIdTreeStats {
+    orphanCount: number;
+    cycleCount: number;
+    duplicateIdCount: number;
+    invalidIdCount: number;
+}
+export interface ParentIdTreeResult<TRow = unknown> {
+    pathOf: (row: TRow) => readonly string[];
+    labelOf: (row: TRow) => string;
+    segmentLabelOf: (segment: string) => string;
+    stats: ParentIdTreeStats;
+}
+export declare function buildPathsFromParentIds<TRow = unknown>(rows: readonly TRow[], spec: ParentIdTreeSpec<TRow>): ParentIdTreeResult<TRow>;

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

@@ -0,0 +1,247 @@
+import type { ColumnGroupDef } from './column/column-groups';
+import type { GridData, GridFieldPath, GridPathValue, SyGridApi } from './api';
+import type { CellRenderer } from './cell/renderer-registry';
+import type { GridEditorDefinition, GridFilterDefinition, GridFloatingFilterDefinition, GridRendererDefinition } from './component/contracts';
+import type { GridRichSelectEditorOptions } from './component/rich-select-editor';
+export type GridCellEditorDeclaration<TData = GridData, TValue = unknown, TContext = unknown> = string | GridEditorDefinition<TData, TValue, TContext> | ({
+    readonly type: 'rich-select';
+} & GridRichSelectEditorOptions<TValue>);
+export type GridColumnGroupDef<TData = GridData, TContext = unknown, TValue = unknown> = ColumnGroupDef<ColumnDef<TData, TValue, TContext>>;
+export type GridSortDirection = 'asc' | 'desc';
+export interface GridColumnDef {
+    key: string;
+    label: string;
+    width?: number;
+}
+export interface GridRow {
+    [key: string]: string | number | boolean | null;
+}
+export interface GridSortSpec {
+    column: string;
+    direction: GridSortDirection;
+}
+export interface GridFilterSpec {
+    query?: string;
+}
+export interface GridQueryResult {
+    totalRows: number;
+    visibleRows: GridRow[];
+    computeMs: number;
+}
+export type GridEngineTier = 'standard' | 'pro';
+export type GridEngineMode = 'auto' | GridEngineTier;
+export type GridUnavailableBehaviour = 'fallback' | 'error';
+export interface ValueGetterParams<TData = GridData, TValue = unknown, TContext = unknown> {
+    data: Readonly<TData>;
+    colDef: ColumnDef<TData, TValue, TContext>;
+    rowIndex: number;
+    context: TContext;
+    api: SyGridApi<TData, TContext>;
+    node: {
+        rowIndex: number;
+        rowId?: string | number;
+    };
+    colId: string;
+    getValue: (otherColId: string) => unknown;
+}
+export interface ValueFormatterParams<TData = GridData, TValue = unknown, TContext = unknown> {
+    value: TValue;
+    data: Readonly<TData>;
+    colDef: ColumnDef<TData, TValue, TContext>;
+    context: TContext;
+    api: SyGridApi<TData, TContext>;
+    node: {
+        rowIndex: number;
+    };
+    colId: string;
+    locale: string;
+}
+export interface CellCallbackParams<TData = GridData, TValue = unknown, TContext = unknown> {
+    data: Readonly<TData>;
+    value: TValue;
+    colDef: ColumnDef<TData, TValue, TContext>;
+    rowIndex: number;
+    context: TContext;
+    api: SyGridApi<TData, TContext>;
+    node: {
+        rowIndex: number;
+    };
+    colId: string;
+    formatted?: string;
+}
+export interface ValueParserParams<TData = GridData, TValue = unknown, TContext = unknown> {
+    value: string;
+    oldValue: TValue;
+    field: GridFieldPath<TData>;
+    row: Readonly<TData>;
+    colDef: ColumnDef<TData, TValue, TContext>;
+    context: TContext;
+    api: SyGridApi<TData, TContext>;
+}
+export interface ValueSetterParams<TData = GridData, TValue = unknown, TContext = unknown> {
+    newValue: TValue;
+    oldValue: TValue;
+    field: GridFieldPath<TData>;
+    data: TData;
+    colDef: ColumnDef<TData, TValue, TContext>;
+    context: TContext;
+    api: SyGridApi<TData, TContext>;
+    rowIndex: number;
+    sourceRowIndex?: number;
+    colId: string;
+}
+export type GridCallback<TArgs extends readonly unknown[], TResult> = {
+    bivarianceHack(...args: TArgs): TResult;
+}['bivarianceHack'];
+export type BuiltInCellEditor = 'text' | 'number' | 'date' | 'select' | 'checkbox' | 'textarea';
+export type ColumnFilterKind = 'text' | 'number' | 'date' | 'set';
+export type ColumnFilterType = ColumnFilterKind | boolean;
+export type ColumnFilterDecl = ColumnFilterType | ReadonlyArray<ColumnFilterKind>;
+export interface ColumnDef<TData = GridData, TValue = unknown, TContext = unknown> {
+    field: GridFieldPath<TData>;
+    colId?: string;
+    headerName?: string;
+    headerTooltip?: string;
+    sortable?: boolean;
+    sort?: 'asc' | 'desc' | null;
+    sortIndex?: number;
+    filter?: ColumnFilterDecl | string | GridFilterDefinition<TData, TValue, unknown, TContext>;
+    valueGetter?: GridCallback<[
+        ValueGetterParams<TData, TValue, TContext>
+    ], TValue> | string;
+    formula?: string;
+    valueFormatter?: GridCallback<[
+        ValueFormatterParams<TData, TValue, TContext>
+    ], string> | string;
+    tooltipField?: GridFieldPath<TData>;
+    tooltipValueGetter?: GridCallback<[
+        ValueGetterParams<TData, TValue, TContext>
+    ], unknown> | string;
+    cellRenderer?: string | CellRenderer<TData, TValue> | GridRendererDefinition<TData, TValue, TContext>;
+    cellRendererMeta?: Record<string, unknown>;
+    cellEditor?: GridCellEditorDeclaration<TData, TValue, TContext>;
+    floatingFilterComponent?: string | GridFloatingFilterDefinition<unknown, TContext>;
+    cellClass?: string | string[] | GridCallback<[
+        CellCallbackParams<TData, TValue, TContext>
+    ], string>;
+    cellClassRules?: Record<string, GridCallback<[
+        CellCallbackParams<TData, TValue, TContext>
+    ], boolean> | string>;
+    cellStyle?: Record<string, string | number> | GridCallback<[
+        CellCallbackParams<TData, TValue, TContext>
+    ], Record<string, string | number> | null | undefined> | ReadonlyArray<Record<string, string | number> | GridCallback<[
+        CellCallbackParams<TData, TValue, TContext>
+    ], Record<string, string | number> | null | undefined>>;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    flex?: number;
+    resizable?: boolean;
+    reorderable?: boolean;
+    pinned?: 'left' | 'right' | null;
+    columnGroupShow?: 'open' | 'closed';
+    aggFunc?: 'sum' | 'avg' | 'min' | 'max' | 'count' | string;
+    hidden?: boolean;
+    hide?: boolean;
+    editable?: boolean;
+    editor?: 'text' | 'number' | 'date' | 'select' | 'checkbox' | 'textarea' | 'autocomplete' | 'largeText';
+    valueParser?: GridCallback<[
+        ValueParserParams<TData, TValue, TContext>
+    ], TValue>;
+    valueSetter?: GridCallback<[
+        ValueSetterParams<TData, TValue, TContext>
+    ], boolean | void>;
+    comparator?: GridCallback<[
+        TValue,
+        TValue,
+        Readonly<TData>,
+        Readonly<TData>
+    ], number>;
+    options?: ReadonlyArray<{
+        value: unknown;
+        label: string;
+        disabled?: boolean;
+    }>;
+    min?: number | Date | string;
+    max?: number | Date | string;
+    step?: number;
+    decimals?: number;
+    nullable?: boolean;
+    allowEmpty?: boolean;
+    storeAs?: 'date' | 'iso';
+    rows?: number;
+    maxRows?: number;
+    cols?: number;
+    maxLength?: number;
+    rowDrag?: boolean;
+    wrapText?: boolean;
+    autoHeight?: boolean;
+    rowSpan?: (params: SyGridRowSpanParams<TData>) => number;
+    colSpan?: (params: SyGridColSpanParams<TData>) => number;
+}
+export interface SyGridRowSpanParams<TData = GridData> {
+    readonly row: TData;
+    readonly index: number;
+    readonly column: ColumnDef<TData>;
+    readonly sectionKey: string | number | null;
+}
+export interface SyGridColSpanParams<TData = GridData> {
+    readonly row: TData;
+    readonly rowIndex: number;
+    readonly column: ColumnDef<TData>;
+    readonly colIndex: number;
+    readonly container: 'left' | 'middle' | 'right';
+}
+export declare namespace ColumnDef {
+    type ForField<TData, TField extends GridFieldPath<TData>, TContext = unknown, TValue = GridPathValue<TData, TField>> = Omit<ColumnDef<TData, TValue, TContext>, 'field'> & {
+        field: TField;
+    };
+}
+export type Comparator<T> = (a: T, b: T) => number;
+export interface RowTransaction<TRow = unknown> {
+    add?: TRow[];
+    update?: Array<{
+        index?: number;
+        row: TRow;
+    }>;
+    remove?: number[];
+}
+export interface RowTransactionResult<TRow = unknown> {
+    added: TRow[];
+    updated: TRow[];
+    removed: TRow[];
+    ignored: number;
+}
+export interface DetailRowDataParams {
+    row: Record<string, unknown>;
+    rowId: string | number;
+}
+export interface DetailGridOptions {
+    columnDefs: Array<ColumnDef | GridColumnGroupDef>;
+    masterDetail?: boolean;
+    getDetailRowData?: (params: DetailRowDataParams) => unknown[] | Promise<unknown[]>;
+    detailGridOptions?: DetailGridOptions;
+    height?: string;
+    detailRowHeight?: number;
+    pagination?: boolean;
+    pageSize?: number;
+    formulas?: boolean;
+    showFormulas?: boolean;
+}
+export type RowModelEvent<TRow = unknown> = {
+    type: 'set';
+    rows: readonly TRow[];
+    affected: readonly TRow[];
+} | {
+    type: 'add';
+    rows: readonly TRow[];
+    affected: readonly TRow[];
+} | {
+    type: 'update';
+    rows: readonly TRow[];
+    affected: readonly TRow[];
+} | {
+    type: 'remove';
+    rows: readonly TRow[];
+    affected: readonly TRow[];
+};

package/dist/types/components/grid/core/utils/structural.d.ts

@@ -0,0 +1,2 @@
+export declare function structuralClone<T>(value: T): T;
+export declare function structuralEqual(a: unknown, b: unknown): boolean;

package/dist/types/components/grid/core/validation/validation.d.ts

@@ -0,0 +1,24 @@
+export type ValidationRuleType = 'required' | 'number' | 'integer' | 'min' | 'max' | 'range' | 'minLength' | 'maxLength' | 'pattern' | 'oneOf' | 'custom';
+export interface ValidationRule {
+    field: string;
+    type: ValidationRuleType;
+    value?: unknown;
+    value2?: unknown;
+    values?: readonly unknown[];
+    pattern?: string;
+    validator?: (value: unknown, data: Record<string, unknown>) => boolean | string;
+    message?: string;
+}
+export interface ValidationCellContext {
+    field: string;
+    value: unknown;
+    rowIndex: number;
+    data: Record<string, unknown>;
+}
+export interface ValidationResult {
+    valid: boolean;
+    message?: string;
+    ruleType?: ValidationRuleType;
+}
+export declare function evaluateValidationRule(rule: ValidationRule, ctx: ValidationCellContext): ValidationResult;
+export declare function evaluateValidation(rules: readonly ValidationRule[] | null | undefined, ctx: ValidationCellContext): ValidationResult;

package/dist/types/components/grid/core/virtualizer/cell-virtualizer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/grid/core/virtualizer/column-virtualizer.d.ts

@@ -0,0 +1,14 @@
+export interface ColumnWindowInput {
+    widths: readonly number[];
+    scrollLeft: number;
+    viewportWidth: number;
+    overscan?: number;
+}
+export interface ColumnWindowResult {
+    start: number;
+    end: number;
+    leadingPx: number;
+    trailingPx: number;
+    total: number;
+}
+export declare function computeColumnWindow(input: ColumnWindowInput): ColumnWindowResult;

package/dist/types/components/grid/core/virtualizer/index.d.ts

@@ -0,0 +1 @@
+export { computeVirtualWindow, attachVirtualScroll, DEFAULT_OVERSCAN, computeVariableVirtualWindow, createRowHeightCache, DEFAULT_ESTIMATED_ROW_HEIGHT, computeCachedVariableWindow, type RowVirtualizerOptions, type RowVirtualizerResult, type VariableRowVirtualizerOptions, type VariableRowVirtualizerResult, type CachedVariableWindowOptions, type RowHeightCache, } from './row-virtualizer';

package/dist/types/components/grid/core/virtualizer/row-virtualizer.d.ts

@@ -0,0 +1,52 @@
+export declare const DEFAULT_OVERSCAN = 3;
+export interface RowVirtualizerOptions {
+    totalRows: number;
+    rowHeight: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscan?: number;
+}
+export interface RowVirtualizerResult {
+    startIndex: number;
+    endIndex: number;
+    paddingTop: number;
+    paddingBottom: number;
+    totalHeight: number;
+    visibleCount: number;
+}
+export declare function computeVirtualWindow(options: RowVirtualizerOptions): RowVirtualizerResult;
+export declare function attachVirtualScroll(container: HTMLElement, options: Omit<RowVirtualizerOptions, 'scrollTop'>, onChange: (result: RowVirtualizerResult) => void): () => void;
+export declare const DEFAULT_ESTIMATED_ROW_HEIGHT = 30;
+export interface VariableRowVirtualizerOptions {
+    totalRows: number;
+    rowHeight: (index: number) => number;
+    estimatedRowHeight?: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscan?: number;
+}
+export interface VariableRowVirtualizerResult {
+    startIndex: number;
+    endIndex: number;
+    paddingTop: number;
+    paddingBottom: number;
+    totalHeight: number;
+    visibleCount: number;
+}
+export declare function computeVariableVirtualWindow(options: VariableRowVirtualizerOptions): VariableRowVirtualizerResult;
+export interface RowHeightCache {
+    getHeight(index: number): number;
+    setHeight(index: number, px: number): void;
+    reset(): void;
+    getOffset(index: number): number;
+    getTotalHeight(totalRows: number): number;
+    findRowAtOffset(y: number, totalRows: number): number;
+}
+export declare function createRowHeightCache(estimatedRowHeight?: number): RowHeightCache;
+export interface CachedVariableWindowOptions {
+    totalRows: number;
+    viewportHeight: number;
+    scrollTop: number;
+    overscan?: number;
+}
+export declare function computeCachedVariableWindow(cache: RowHeightCache, options: CachedVariableWindowOptions): VariableRowVirtualizerResult;

package/dist/types/components/grid/core/visual-regression/baseline.d.ts

@@ -0,0 +1,2 @@
+export declare const __BASELINE_SNAPSHOTS: Record<string, string>;
+export declare function listBaselineStories(): readonly string[];

package/dist/types/components/grid/core/visual-regression/dom-snapshot.d.ts

@@ -0,0 +1,14 @@
+export interface DomLikeNode {
+    readonly nodeType: number;
+    readonly tagName?: string;
+    readonly nodeValue?: string | null;
+    readonly attributes?: ArrayLike<{
+        name: string;
+        value: string;
+    }>;
+    readonly childNodes?: ArrayLike<DomLikeNode>;
+}
+export interface DomSnapshotOptions {
+    strip?: readonly string[];
+}
+export declare function domSnapshot(host: DomLikeNode, opts?: DomSnapshotOptions): string;

package/dist/types/components/grid/core/visual-regression/real-dom-canonicalise.d.ts

@@ -0,0 +1 @@
+export declare function canonicaliseRealDom(html: string): string;

package/dist/types/components/grid/core/vnode-factory.d.ts

@@ -0,0 +1 @@
+export type GridVNodeFactory = (tag: string, props?: Record<string, unknown> | null, ...children: unknown[]) => unknown;

package/dist/types/components/grid/engines/standard/index.d.ts

@@ -0,0 +1 @@
+export * from './sy-grid-standard';