@syidax/advanced 0.0.0-stage → 1.0.1

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

@@ -0,0 +1,90 @@
+import { GridComponentError, type GridComponentDefinition, type GridComponentKind, type GridComponentParams, type GridGuiComponent } from './contracts';
+export type GridComponentMountParams<TParams extends GridComponentParams> = Omit<TParams, 'componentKind' | 'instanceId' | 'signal'> & {
+    readonly signal?: AbortSignal;
+};
+export interface GridComponentMountRequest<TInstance, TParams extends GridComponentParams> {
+    readonly key: string;
+    readonly componentName?: string;
+    readonly definition: GridComponentDefinition<TInstance, TParams>;
+    readonly params: GridComponentMountParams<TParams>;
+}
+export interface GridComponentRuntimeOptions<TParams, TGui> {
+    readonly kind: GridComponentKind;
+    readonly timeoutMs?: number;
+    readonly isGuiElement?: (value: unknown) => value is HTMLElement;
+    readonly onError?: (error: GridComponentError) => void;
+    readonly fallback?: (error: GridComponentError, params: TParams) => TGui | undefined;
+}
+export type GridComponentMountResult<TInstance, TGui> = {
+    readonly status: 'mounted';
+    readonly key: string;
+    readonly generation: number;
+    readonly instance: TInstance;
+    readonly gui: TGui;
+} | {
+    readonly status: 'stale';
+    readonly key: string;
+    readonly generation: number;
+} | {
+    readonly status: 'failed';
+    readonly key: string;
+    readonly generation: number;
+    readonly error: GridComponentError;
+    readonly fallbackGui?: TGui;
+};
+export type GridComponentRefreshResult<TInstance, TGui> = {
+    readonly status: 'refreshed';
+    readonly key: string;
+    readonly generation: number;
+    readonly instance: TInstance;
+    readonly gui: TGui;
+} | {
+    readonly status: 'recreated';
+    readonly key: string;
+    readonly generation: number;
+    readonly instance: TInstance;
+    readonly gui: TGui;
+} | {
+    readonly status: 'not-mounted';
+    readonly key: string;
+} | {
+    readonly status: 'stale';
+    readonly key: string;
+    readonly generation: number;
+} | {
+    readonly status: 'failed';
+    readonly key: string;
+    readonly generation: number;
+    readonly error: GridComponentError;
+    readonly fallbackGui?: TGui;
+};
+export type GridMountedComponentLookup<TInstance, TParams, TGui> = {
+    readonly status: 'mounted';
+    readonly key: string;
+    readonly generation: number;
+    readonly instance: TInstance;
+    readonly params: TParams;
+    readonly gui: TGui;
+} | {
+    readonly status: 'unmounted';
+    readonly key: string;
+};
+export interface GridComponentRuntimeStats {
+    readonly mounted: number;
+    readonly inFlight: number;
+    readonly destroyed: number;
+    readonly disposed: boolean;
+}
+export interface GridComponentRuntime<TInstance, TParams extends GridComponentParams, TGui> {
+    mount(request: GridComponentMountRequest<TInstance, TParams>): Promise<GridComponentMountResult<TInstance, TGui>>;
+    refresh(key: string, params: GridComponentMountParams<TParams>): Promise<GridComponentRefreshResult<TInstance, TGui>>;
+    lookup(key: string): GridMountedComponentLookup<TInstance, TParams, TGui>;
+    listMounted(): ReadonlyArray<Exclude<GridMountedComponentLookup<TInstance, TParams, TGui>, {
+        readonly status: 'unmounted';
+    }>>;
+    destroy(key: string): Promise<boolean>;
+    destroyAll(): Promise<void>;
+    dispose(): Promise<void>;
+    stats(): GridComponentRuntimeStats;
+}
+export declare function createGridComponentRuntime<TInstance extends GridGuiComponent<TParams, TGui>, TParams extends GridComponentParams, TGui>(options: GridComponentRuntimeOptions<TParams, TGui>): GridComponentRuntime<TInstance, TParams, TGui>;

package/dist/types/components/grid/core/conditional-format/cf-builder-chunk.d.ts

@@ -0,0 +1,19 @@
+import { type CfDraftRule } from './cf-builder.ts';
+import type { ConditionalFormatRule } from './conditional-format.ts';
+import type { GridVNodeFactory } from '../vnode-factory.ts';
+export interface GridCfBuilderElement {
+    cfBuilderOpen: boolean;
+    cfDraftRules: CfDraftRule[];
+    conditionalFormats?: ConditionalFormatRule[];
+    readonly conditionalFormatsChanged: {
+        emit(detail: {
+            rules: ConditionalFormatRule[];
+        }): unknown;
+    };
+    resolvedColumnDefs(): ReadonlyArray<{
+        readonly field: string;
+        readonly headerName?: string;
+    }>;
+}
+export declare function toggleCfBuilder(grid: GridCfBuilderElement): void;
+export declare function renderConditionalFormatBuilder(grid: GridCfBuilderElement, h: GridVNodeFactory): unknown;

package/dist/types/components/grid/core/conditional-format/cf-builder.d.ts

@@ -0,0 +1,23 @@
+import type { CfConditionType, ConditionalFormatRule } from './conditional-format.ts';
+export interface CfConditionMeta {
+    type: CfConditionType;
+    label: string;
+    needsValue: boolean;
+    needsValue2: boolean;
+}
+export declare const CF_CONDITION_META: readonly CfConditionMeta[];
+export declare function cfConditionMeta(type: CfConditionType): CfConditionMeta;
+export interface CfDraftRule {
+    field?: string;
+    type: CfConditionType;
+    value?: string;
+    value2?: string;
+    backgroundColor?: string;
+    color?: string;
+    bold?: boolean;
+}
+export declare function emptyDraftRule(field?: string): CfDraftRule;
+export declare function patchDraftRule(rules: readonly CfDraftRule[], index: number, patch: Partial<CfDraftRule>): CfDraftRule[];
+export declare function removeDraftRule(rules: readonly CfDraftRule[], index: number): CfDraftRule[];
+export declare function compileDraftRule(draft: CfDraftRule): ConditionalFormatRule | null;
+export declare function compileDraftRules(drafts: readonly CfDraftRule[]): ConditionalFormatRule[];

package/dist/types/components/grid/core/conditional-format/conditional-format.d.ts

@@ -0,0 +1,32 @@
+export type CfConditionType = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank';
+export interface CfCondition {
+    type: CfConditionType;
+    value?: unknown;
+    value2?: unknown;
+    caseSensitive?: boolean;
+}
+export interface CfStyle {
+    backgroundColor?: string;
+    color?: string;
+    fontWeight?: 'bold' | 'normal';
+    fontStyle?: 'italic' | 'normal';
+    textDecoration?: 'underline' | 'line-through' | 'none';
+}
+export interface ConditionalFormatRule {
+    field?: string;
+    condition: CfCondition;
+    style: CfStyle;
+    stopIfTrue?: boolean;
+}
+export interface CfCellContext {
+    field: string;
+    value: unknown;
+    rowIndex: number;
+    data: Record<string, unknown>;
+}
+export declare function evaluateCfCondition(cond: CfCondition, value: unknown): boolean;
+export declare function ruleMatches(rule: ConditionalFormatRule, ctx: CfCellContext): boolean;
+export declare function evaluateConditionalFormats(rules: readonly ConditionalFormatRule[] | null | undefined, ctx: CfCellContext): CfStyle | null;
+export declare function isSafeCssColor(value: unknown): value is string;
+export declare function cfStyleToCss(style: CfStyle | null | undefined): Record<string, string>;
+export declare function resolveConditionalFormatCss(rules: readonly ConditionalFormatRule[] | null | undefined, ctx: CfCellContext): Record<string, string>;

package/dist/types/components/grid/core/context-menu/clipboard.d.ts

@@ -0,0 +1,9 @@
+import type { ColumnDef } from '../types.ts';
+import { type SpreadsheetTextOptions } from '../spreadsheet-text.ts';
+export interface FormatCellOptions extends SpreadsheetTextOptions {
+    locale?: string;
+}
+export declare function formatCellForClipboard<TRow = Record<string, unknown>>(row: TRow, rowIndex: number, column: Pick<ColumnDef, 'field' | 'valueGetter' | 'valueFormatter'>, options?: FormatCellOptions): string;
+export declare function formatRowAsTsv<TRow = Record<string, unknown>>(row: TRow, rowIndex: number, columns: ReadonlyArray<Pick<ColumnDef, 'field' | 'valueGetter' | 'valueFormatter' | 'hidden' | 'hide'>>, options?: FormatCellOptions): string;
+export declare function escapeForTsv(value: unknown, options?: SpreadsheetTextOptions): string;
+export declare function copyTextToClipboard(text: string): Promise<boolean>;

package/dist/types/components/grid/core/context-menu/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './menu';
+export * from './clipboard';

package/dist/types/components/grid/core/context-menu/menu.d.ts

@@ -0,0 +1,6 @@
+import type { ContextMenuContext, ContextMenuItem, ContextMenuLocale } from './types.ts';
+export declare const DEFAULT_CONTEXT_MENU_LOCALE: ContextMenuLocale;
+export interface BuildContextMenuOptions {
+    locale?: Partial<ContextMenuLocale>;
+}
+export declare function buildContextMenuItems<TRow = Record<string, unknown>>(ctx: ContextMenuContext<TRow>, options?: BuildContextMenuOptions): ContextMenuItem[];

package/dist/types/components/grid/core/context-menu/types.d.ts

@@ -0,0 +1,22 @@
+import type { ColumnDef } from '../types.ts';
+export type ContextMenuActionId = 'copy-cell' | 'copy-row' | 'export-csv' | (string & {});
+export interface ContextMenuItem<TRow = Record<string, unknown>> {
+    id: ContextMenuActionId;
+    label: string;
+    disabled?: boolean;
+    separator?: boolean;
+    action?: (ctx: ContextMenuContext<TRow>) => void;
+    icon?: string;
+}
+export interface ContextMenuContext<TRow = Record<string, unknown>> {
+    rowIndex: number;
+    field?: string;
+    row?: TRow;
+    columns: ReadonlyArray<ColumnDef>;
+    rows: ReadonlyArray<TRow>;
+}
+export interface ContextMenuLocale {
+    copyCell: string;
+    copyRow: string;
+    exportCsv: string;
+}

package/dist/types/components/grid/core/edit/autocomplete-editor.d.ts

@@ -0,0 +1,21 @@
+import type { SelectOption } from './select-editor.ts';
+export type { SelectOption };
+export interface AutocompleteEditorState<TValue = unknown> {
+    query: string;
+    options: ReadonlyArray<SelectOption<TValue>>;
+    open: boolean;
+    value: TValue | null;
+    highlightedIndex: number | null;
+    composing: boolean;
+}
+export declare function filterOptionIndices<TValue>(options: ReadonlyArray<SelectOption<TValue>>, query: string): number[];
+export declare function createAutocompleteState<TValue>(initialValue: TValue | null, options: ReadonlyArray<SelectOption<TValue>>): AutocompleteEditorState<TValue>;
+export declare function applyQueryChange<TValue>(state: AutocompleteEditorState<TValue>, query: string): AutocompleteEditorState<TValue>;
+export declare function applyCompositionStart<TValue>(state: AutocompleteEditorState<TValue>): AutocompleteEditorState<TValue>;
+export declare function applyCompositionEnd<TValue>(state: AutocompleteEditorState<TValue>, finalQuery: string): AutocompleteEditorState<TValue>;
+export declare function applyHighlightChange<TValue>(state: AutocompleteEditorState<TValue>, direction: 1 | -1): AutocompleteEditorState<TValue>;
+export declare function applyOptionPick<TValue>(state: AutocompleteEditorState<TValue>, optionIndex: number): AutocompleteEditorState<TValue>;
+export declare function applyDropdownToggle<TValue>(state: AutocompleteEditorState<TValue>, opening?: boolean): AutocompleteEditorState<TValue>;
+export declare function shouldCommitOnKey<TValue>(state: AutocompleteEditorState<TValue>, key: string): boolean;
+export declare function shouldCancelOnKey<TValue>(state: AutocompleteEditorState<TValue>, key: string): boolean;
+export declare function shouldCloseDropdownOnKey<TValue>(state: AutocompleteEditorState<TValue>, key: string): boolean;

package/dist/types/components/grid/core/edit/batch-edit.d.ts

@@ -0,0 +1,237 @@
+import type { FillRbacVerdict, FillRejectionReason, FillTransactionAtomicity, FillTransactionStatus, FillValidationVerdict } from '../selection/fill-transaction.ts';
+import type { GridMutationId } from '../api/contracts.ts';
+export type BatchTransactionAtomicity = FillTransactionAtomicity;
+export type BatchTransactionStatus = FillTransactionStatus;
+export type BatchRbacVerdict = FillRbacVerdict;
+export type BatchValidationVerdict = FillValidationVerdict;
+export type BatchRejectionReason = Exclude<FillRejectionReason, 'formula-protected'>;
+export type BatchRowKey = string | number;
+export type BatchColKey = string | number;
+export type BatchEditIgnoreReason = 'batch-live' | 'no-batch' | 'not-pending' | 'invalid-cell';
+export interface BatchPendingCell {
+    readonly key: string;
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly value: unknown;
+    readonly oldValue: unknown;
+    readonly sequence: number;
+}
+export interface BatchEditSession {
+    readonly sessionId: number;
+    readonly joinCount: number;
+    readonly pending: ReadonlyMap<string, BatchPendingCell>;
+    readonly nextSequence: number;
+}
+export interface BatchEditState {
+    readonly session: BatchEditSession | null;
+    readonly nextSessionId: number;
+}
+export type BatchReentrantPolicy = 'reject' | 'join';
+export interface BatchStartOptions {
+    readonly reentrant?: BatchReentrantPolicy;
+}
+export type BatchStartOutcome = {
+    readonly kind: 'started';
+    readonly session: BatchEditSession;
+} | {
+    readonly kind: 'joined';
+    readonly session: BatchEditSession;
+    readonly joinCount: number;
+} | {
+    readonly kind: 'ignored';
+    readonly ignored: 'batch-live';
+};
+export interface BatchStartResult {
+    readonly state: BatchEditState;
+    readonly result: BatchStartOutcome;
+}
+export interface BatchStageInput {
+    readonly row: number;
+    readonly col: number;
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly value: unknown;
+    readonly oldValue?: unknown;
+}
+export type BatchStageOutcome = {
+    readonly kind: 'staged';
+    readonly cell: BatchPendingCell;
+    readonly replaced: boolean;
+} | {
+    readonly kind: 'ignored';
+    readonly ignored: 'no-batch' | 'invalid-cell';
+};
+export interface BatchStageResult {
+    readonly state: BatchEditState;
+    readonly staged: BatchStageOutcome;
+}
+export type BatchUnstageOutcome = {
+    readonly kind: 'unstaged';
+    readonly cell: BatchPendingCell;
+} | {
+    readonly kind: 'ignored';
+    readonly ignored: 'no-batch' | 'not-pending' | 'invalid-cell';
+};
+export interface BatchUnstageResult {
+    readonly state: BatchEditState;
+    readonly removed: BatchUnstageOutcome;
+}
+export type BatchCancelOutcome = {
+    readonly kind: 'cancelled';
+    readonly sessionId: number;
+    readonly droppedCount: number;
+} | {
+    readonly kind: 'ignored';
+    readonly ignored: 'no-batch';
+};
+export interface BatchCancelResult {
+    readonly state: BatchEditState;
+    readonly result: BatchCancelOutcome;
+}
+export interface BatchPendingLookup {
+    readonly has: boolean;
+    readonly value: unknown;
+}
+export interface BatchTransactionContext {
+    readonly mintMutationId: () => GridMutationId;
+    readonly readCurrent: (rowId: BatchRowKey, colId: BatchColKey) => unknown;
+    readonly rbac?: ((rowId: BatchRowKey, colId: BatchColKey) => BatchRbacVerdict) | null;
+    readonly validate?: ((rowId: BatchRowKey, colId: BatchColKey, newValue: unknown) => BatchValidationVerdict) | null;
+    readonly atomicity?: BatchTransactionAtomicity;
+}
+export interface BatchRejectedCell {
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly reason: BatchRejectionReason;
+}
+export interface BatchCommitWrite {
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly value: unknown;
+    readonly oldValue: unknown;
+}
+export interface BatchUndoWrite {
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly value: unknown;
+}
+export interface BatchEditStartEventDetail {
+    readonly mutationId: GridMutationId;
+    readonly sessionId: number;
+    readonly stagedCount: number;
+}
+export interface BatchCellValueChangedEventDetail {
+    readonly mutationId: GridMutationId;
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+    readonly excludedReason: null;
+}
+export interface BatchEditEndEventDetail {
+    readonly mutationId: GridMutationId;
+    readonly status: BatchTransactionStatus;
+    readonly writtenCount: number;
+    readonly rejectedCells: readonly BatchRejectedCell[];
+    readonly reason?: unknown;
+    readonly droppedCount?: number;
+}
+export type BatchTransactionEvent = {
+    readonly type: 'batchEditStart';
+    readonly detail: BatchEditStartEventDetail;
+} | {
+    readonly type: 'cellValueChanged';
+    readonly detail: BatchCellValueChangedEventDetail;
+} | {
+    readonly type: 'batchEditEnd';
+    readonly detail: BatchEditEndEventDetail;
+};
+export interface BatchMutationRecordWrite {
+    readonly rowId: BatchRowKey;
+    readonly colId: BatchColKey;
+    readonly row: number;
+    readonly col: number;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+}
+export interface BatchMutationRecord {
+    readonly mutationId: GridMutationId;
+    readonly kind: 'batch-edit';
+    readonly sessionId: number;
+    readonly writes: readonly BatchMutationRecordWrite[];
+    readonly rejectedCells: readonly BatchRejectedCell[];
+    readonly timestampSlot: null;
+}
+export interface BatchTransactionPlan {
+    readonly status: BatchTransactionStatus;
+    readonly mutationId: GridMutationId;
+    readonly events: readonly BatchTransactionEvent[];
+    readonly commit: {
+        readonly writes: readonly BatchCommitWrite[];
+    };
+    readonly undo: {
+        readonly writes: readonly BatchUndoWrite[];
+    };
+    readonly rejectedCells: readonly BatchRejectedCell[];
+    readonly mutationRecord: BatchMutationRecord;
+}
+export type BatchCommitOutcome = {
+    readonly kind: 'planned';
+    readonly plan: BatchTransactionPlan;
+} | {
+    readonly kind: 'ignored';
+    readonly ignored: 'no-batch';
+};
+export interface BatchCommitResult {
+    readonly state: BatchEditState;
+    readonly result: BatchCommitOutcome;
+}
+export interface BatchFinalizeContext {
+    readonly mintMutationId: () => GridMutationId;
+}
+export type BatchFinalizeOutcome = {
+    readonly kind: 'cancelled';
+    readonly droppedCount: number;
+    readonly plan: BatchTransactionPlan;
+} | {
+    readonly kind: 'idle';
+};
+export interface BatchFinalizeResult {
+    readonly state: BatchEditState;
+    readonly result: BatchFinalizeOutcome;
+}
+export interface SealBatchInput {
+    readonly status: BatchTransactionStatus;
+    readonly mutationId: GridMutationId;
+    readonly sessionId: number;
+    readonly stagedCount: number;
+    readonly accepted: readonly BatchPendingCell[];
+    readonly rejectedCells: readonly BatchRejectedCell[];
+    readonly readCurrent?: (rowId: BatchRowKey, colId: BatchColKey) => unknown;
+    readonly cancel?: {
+        readonly reason: unknown;
+        readonly droppedCount: number;
+    };
+}
+export declare const sealBatchPlan: (input: SealBatchInput) => BatchTransactionPlan;
+export declare function createBatchEditState(): BatchEditState;
+export declare function isBatchEditing(state: BatchEditState): boolean;
+export declare function startBatchEdit(state: BatchEditState, options?: BatchStartOptions): BatchStartResult;
+export declare function cancelBatchEdit(state: BatchEditState): BatchCancelResult;
+export declare function batchCellKey(rowId: BatchRowKey, colId: BatchColKey): string;
+export declare function stageBatchCell(state: BatchEditState, input: BatchStageInput): BatchStageResult;
+export declare function unstageBatchCell(state: BatchEditState, rowId: BatchRowKey, colId: BatchColKey): BatchUnstageResult;
+export declare function pendingBatchCells(state: BatchEditState): readonly BatchPendingCell[];
+export declare function pendingBatchValue(state: BatchEditState, rowId: BatchRowKey, colId: BatchColKey): BatchPendingLookup;
+export declare function commitBatchEdit(state: BatchEditState, context: BatchTransactionContext): BatchCommitResult;
+export declare function finalizeBatchOnDisconnect(state: BatchEditState, context: BatchFinalizeContext): BatchFinalizeResult;

package/dist/types/components/grid/core/edit/checkbox-editor-render.d.ts

@@ -0,0 +1,27 @@
+import type { CheckboxEditorState } from './checkbox-editor';
+export declare const CHECKBOX_EDITOR_CLASS = "sy-grid__cell-editor sy-grid__cell-editor--checkbox";
+export declare const CHECKBOX_INDETERMINATE_CLASS = "sy-grid__cell-editor--indeterminate";
+export interface CheckboxEditorProps {
+    type: 'checkbox';
+    checked: boolean;
+    class: string;
+    'data-row-index': number;
+    'data-col-index': number;
+    'aria-label': string;
+    'aria-checked': 'true' | 'false' | 'mixed';
+    onChange: (event: Event) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onBlur: () => void;
+}
+export interface BuildCheckboxEditorPropsInput {
+    state: CheckboxEditorState;
+    rowIndex: number;
+    colIndex: number;
+    ariaLabel: string;
+    onToggle: () => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    onBlur: () => void;
+}
+export declare function buildCheckboxEditorProps(input: BuildCheckboxEditorPropsInput): CheckboxEditorProps;
+export declare function applyIndeterminateToInput(el: HTMLInputElement | null, state: CheckboxEditorState): void;

package/dist/types/components/grid/core/edit/checkbox-editor.d.ts

@@ -0,0 +1,10 @@
+export interface CheckboxEditorState {
+    value: boolean;
+    indeterminate: boolean;
+}
+export declare function createCheckboxEditorState(initialValue: boolean | null | undefined): CheckboxEditorState;
+export declare function applyToggle(state: CheckboxEditorState): CheckboxEditorState;
+export declare function applySetValue(state: CheckboxEditorState, value: boolean): CheckboxEditorState;
+export declare function shouldCommitOnKey(state: CheckboxEditorState, key: string): boolean;
+export declare function shouldCancelOnKey(state: CheckboxEditorState, key: string): boolean;
+export declare function shouldToggleOnKey(state: CheckboxEditorState, key: string): boolean;

package/dist/types/components/grid/core/edit/date-editor-render.d.ts

@@ -0,0 +1,35 @@
+import type { DateConstraints, DateEditorState } from './date-editor';
+export interface DateEditorInputProps {
+    type: 'date';
+    min: string | undefined;
+    max: string | undefined;
+    value: string;
+    class: string;
+    'data-row-index': number;
+    'data-col-index': number;
+    'aria-label': string;
+    'aria-describedby'?: string;
+    'aria-invalid': 'true' | 'false';
+    onInput: (event: Event) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: (event: Event) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onBlur: () => void;
+}
+export interface BuildDateEditorPropsInput {
+    state: DateEditorState;
+    rowIndex: number;
+    colIndex: number;
+    ariaLabel: string;
+    ariaDescribedBy?: string;
+    constraints?: DateConstraints;
+    onInput: (text: string, selectionStart: number | null, selectionEnd: number | null) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: (finalText: string) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    onBlur: () => void;
+}
+export declare const DATE_EDITOR_CLASS = "sy-grid__cell-editor sy-grid__cell-editor--date";
+export declare const DATE_EDITOR_INVALID_CLASS = "sy-grid__cell-editor--invalid";
+export declare function buildDateEditorProps(input: BuildDateEditorPropsInput): DateEditorInputProps;

package/dist/types/components/grid/core/edit/date-editor.d.ts

@@ -0,0 +1,26 @@
+export interface DateConstraints {
+    min?: Date | string;
+    max?: Date | string;
+    nullable?: boolean;
+    allowEmpty?: boolean;
+    storeAs?: 'date' | 'iso';
+}
+export interface DateEditorState {
+    rawText: string;
+    parsedDate: Date | null;
+    composing: boolean;
+    selectionStart: number | null;
+    selectionEnd: number | null;
+    constraintViolation: 'min' | 'max' | 'invalid' | null;
+}
+export declare function parseDateText(text: string, constraints?: DateConstraints): {
+    value: Date | null;
+    violation: 'min' | 'max' | 'invalid' | null;
+};
+export declare function createDateEditorState(initialValue: Date | string | null | undefined, constraints?: DateConstraints): DateEditorState;
+export declare function applyInputText(state: DateEditorState, newText: string, constraints?: DateConstraints): DateEditorState;
+export declare function applyCompositionStart(state: DateEditorState): DateEditorState;
+export declare function applyCompositionEnd(state: DateEditorState, finalText: string, constraints?: DateConstraints): DateEditorState;
+export declare function applySelectionChange(state: DateEditorState, start: number | null, end: number | null): DateEditorState;
+export declare function shouldCommitOnKey(state: DateEditorState, key: string): boolean;
+export declare function shouldCancelOnKey(_state: DateEditorState, key: string): boolean;

package/dist/types/components/grid/core/edit/date-picker.d.ts

@@ -0,0 +1,27 @@
+export interface CalendarDay {
+    date: Date;
+    iso: string;
+    day: number;
+    inMonth: boolean;
+}
+export interface CalendarState {
+    month: number;
+    year: number;
+    selected: Date | null;
+}
+export declare function utcDate(year: number, month0: number, day: number): Date;
+export declare function toISO(date: Date): string;
+export declare function parseISO(iso: string | null | undefined): Date | null;
+export declare function coerceBound(bound: Date | string | null | undefined): Date | null;
+export declare function isSameDay(a: Date | null, b: Date | null): boolean;
+export declare function isDisabledDay(date: Date, min: Date | null, max: Date | null): boolean;
+export declare function createCalendarState(initial: Date | string | null, fallback: Date): CalendarState;
+export declare function stepMonth(state: CalendarState, delta: number): CalendarState;
+export declare function showMonth(state: CalendarState, year: number, month0: number): CalendarState;
+export declare function selectDay(_state: CalendarState, date: Date): CalendarState;
+export declare function buildMonthMatrix(state: CalendarState, weekStart?: number): CalendarDay[][];
+export type CalendarNavAction = 'left' | 'right' | 'up' | 'down' | 'pageup' | 'pagedown' | 'home' | 'end';
+export declare function navigateCalendarDay(iso: string, action: CalendarNavAction, weekStart?: number): string | null;
+export declare function clampISOToBounds(iso: string, min: Date | null, max: Date | null): string;
+export declare const MONTH_NAMES: readonly string[];
+export declare const WEEKDAY_INITIALS: readonly string[];

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

@@ -0,0 +1,2 @@
+export * from './transaction-api';
+export * from './undo-redo';

package/dist/types/components/grid/core/edit/large-text-editor.d.ts

@@ -0,0 +1,20 @@
+export interface LargeTextConfig {
+    rows: number;
+    cols: number;
+    maxLength: number | null;
+}
+export declare const DEFAULT_LARGE_TEXT_ROWS = 10;
+export declare const DEFAULT_LARGE_TEXT_COLS = 60;
+export declare const DEFAULT_LARGE_TEXT_MAX_LENGTH = 200;
+export declare function codePointLength(value: string): number;
+export declare function resolveLargeTextConfig(input: {
+    rows?: number;
+    cols?: number;
+    maxLength?: number;
+}): LargeTextConfig;
+export declare function clampValueToMaxLength(value: string, maxLength: number | null): {
+    value: string;
+    clamped: boolean;
+};
+export declare function exceedsMaxLength(value: string, maxLength: number | null): boolean;
+export declare function charCountLabel(value: string, maxLength: number | null): string;

package/dist/types/components/grid/core/edit/number-editor-render.d.ts

@@ -0,0 +1,37 @@
+import type { NumberConstraints, NumberEditorState } from './number-editor';
+export interface NumberEditorInputProps {
+    type: 'number';
+    inputmode: 'numeric' | 'decimal';
+    min?: number;
+    max?: number;
+    step: number | 'any';
+    value: string;
+    class: string;
+    'data-row-index': number;
+    'data-col-index': number;
+    'aria-label': string;
+    'aria-describedby'?: string;
+    'aria-invalid': 'true' | 'false';
+    onInput: (event: Event) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: (event: Event) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onBlur: () => void;
+}
+export interface BuildNumberEditorPropsInput {
+    state: NumberEditorState;
+    rowIndex: number;
+    colIndex: number;
+    ariaLabel: string;
+    ariaDescribedBy?: string;
+    constraints?: NumberConstraints;
+    onInput: (text: string, selectionStart: number | null, selectionEnd: number | null) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: (finalText: string) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+    onBlur: () => void;
+}
+export declare const NUMBER_EDITOR_CLASS = "sy-grid__cell-editor sy-grid__cell-editor--number";
+export declare const NUMBER_EDITOR_INVALID_CLASS = "sy-grid__cell-editor--invalid";
+export declare function buildNumberEditorProps(input: BuildNumberEditorPropsInput): NumberEditorInputProps;