@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/component/editor-facade-controller.d.ts

@@ -0,0 +1,172 @@
+import { GridComponentError, type GridComponentLocalDefinitions, type GridEditorDefinition, type GridEditorParams, type GridEditorValidationError, type GridMaybePromise } from './contracts';
+import type { GridEditorCommitContext, GridEditorStopReason, GridEditorStopResult, GridInvalidEditMode } from './editor-adapter';
+import type { GridComponentManager } from './component-runtime-chunk';
+import type { GridRichSelectEditorOptions } from './rich-select-editor';
+import type { GridComponentMountParams } from './runtime';
+type DefaultData = Record<string, unknown>;
+export type GridEditorFacadeDeclaration<TData = DefaultData, TValue = unknown, TContext = unknown> = string | GridEditorDefinition<TData, TValue, TContext> | ({
+    readonly type: 'rich-select';
+} & GridRichSelectEditorOptions<TValue>);
+export interface GridEditorFacadeRef {
+    readonly key: string;
+    readonly generation: number;
+}
+export type GridEditorFacadeParams<TData = DefaultData, TValue = unknown, TContext = unknown> = Omit<GridComponentMountParams<GridEditorParams<TData, TValue, TContext>>, 'stopEditing'>;
+export interface GridEditorFacadeCommitOptions<TData, TValue, TContext> {
+    readonly invalidMode?: GridInvalidEditMode;
+    readonly parseValue?: (value: TValue, context: GridEditorCommitContext<TData, TValue, TContext>) => GridMaybePromise<TValue>;
+    readonly validate?: (value: TValue, context: GridEditorCommitContext<TData, TValue, TContext>) => GridMaybePromise<ReadonlyArray<GridEditorValidationError> | null>;
+    readonly canCommit?: (value: TValue, context: GridEditorCommitContext<TData, TValue, TContext>) => GridMaybePromise<boolean>;
+    readonly prepareCommit?: (value: TValue, context: GridEditorCommitContext<TData, TValue, TContext>) => GridMaybePromise<void>;
+    readonly commitPrepared: (value: TValue, context: GridEditorCommitContext<TData, TValue, TContext>) => void | boolean;
+}
+export interface GridEditorFacadeBeginRequest<TData = DefaultData, TValue = unknown, TContext = unknown> extends GridEditorFacadeCommitOptions<TData, TValue, TContext> {
+    readonly key: string;
+    readonly declaration: GridEditorFacadeDeclaration<TData, TValue, TContext>;
+    readonly local?: GridComponentLocalDefinitions<TData, TValue, unknown, TContext>;
+    readonly params: GridEditorFacadeParams<TData, TValue, TContext>;
+    readonly onStopResult?: GridEditorFacadeStopResultListener<TValue>;
+}
+export interface GridEditorFacadePopupContext<TData, TValue, TContext> {
+    readonly ref: GridEditorFacadeRef;
+    readonly gui: HTMLElement;
+    readonly preferred: 'over' | 'under';
+    readonly cellElement: HTMLElement | undefined;
+    readonly params: Readonly<GridEditorFacadeParams<TData, TValue, TContext>>;
+    readonly signal: AbortSignal;
+}
+export interface GridEditorFacadeHostAttachContext<TData, TValue, TContext, TPlacement> {
+    readonly ref: GridEditorFacadeRef;
+    readonly gui: HTMLElement;
+    readonly mode: 'inline' | 'popup';
+    readonly popupPosition: 'over' | 'under';
+    readonly placement: TPlacement | undefined;
+    readonly cellElement: HTMLElement | undefined;
+    readonly params: Readonly<GridEditorFacadeParams<TData, TValue, TContext>>;
+    readonly signal: AbortSignal;
+}
+export type GridEditorFacadeDetachReason = GridEditorStopReason | 'attach-failed' | 'stale';
+export interface GridEditorFacadeHostDetachContext<TData, TValue, TContext> {
+    readonly ref: GridEditorFacadeRef;
+    readonly gui: HTMLElement;
+    readonly reason: GridEditorFacadeDetachReason;
+    readonly params: Readonly<GridEditorFacadeParams<TData, TValue, TContext>>;
+}
+export interface GridEditorFacadeHost<TData = DefaultData, TValue = unknown, TContext = unknown, TPlacement = unknown, TAttachment = unknown> {
+    calculatePopupPlacement?(context: GridEditorFacadePopupContext<TData, TValue, TContext>): GridMaybePromise<TPlacement>;
+    attach(context: GridEditorFacadeHostAttachContext<TData, TValue, TContext, TPlacement>): GridMaybePromise<TAttachment>;
+    detach?(attachment: TAttachment, context: GridEditorFacadeHostDetachContext<TData, TValue, TContext>): GridMaybePromise<void>;
+}
+export type GridEditorFacadeBeginResult<TData, TValue, TContext> = {
+    readonly status: 'started';
+    readonly ref: GridEditorFacadeRef;
+    readonly gui: HTMLElement;
+    readonly popup: boolean;
+    readonly popupPosition: 'over' | 'under';
+    readonly instance: import('./contracts').GridEditorInstance<TData, TValue, TContext>;
+} | {
+    readonly status: 'blocked-by-active';
+    readonly active: GridEditorFacadeRef;
+    readonly stopResult: GridEditorStopResult<TValue>;
+} | {
+    readonly status: 'cancelled-before-start';
+    readonly ref: GridEditorFacadeRef;
+} | {
+    readonly status: 'stopped-before-attach';
+    readonly ref: GridEditorFacadeRef;
+    readonly stopResult: GridEditorStopResult<TValue>;
+} | {
+    readonly status: 'stale';
+    readonly key: string;
+} | {
+    readonly status: 'failed';
+    readonly key: string;
+    readonly error: GridComponentError;
+};
+export type GridEditorFacadeAttachResult = {
+    readonly status: 'attached';
+    readonly ref: GridEditorFacadeRef;
+    readonly mode: 'inline' | 'popup';
+} | {
+    readonly status: 'stale';
+    readonly ref: GridEditorFacadeRef;
+} | {
+    readonly status: 'failed';
+    readonly ref: GridEditorFacadeRef;
+    readonly error: GridComponentError;
+};
+export type GridEditorFacadeStopResult<TValue> = GridEditorStopResult<TValue> | {
+    readonly status: 'cancelled-before-start';
+    readonly key: string;
+} | {
+    readonly status: 'not-active';
+};
+export type GridEditorFacadeStopOrigin = 'component' | 'controller' | 'replacement' | 'owner-abort' | 'disconnect' | 'lifecycle';
+export type GridEditorFacadeTransactionOutcome = 'committed' | 'cancelled' | 'retained';
+export interface GridEditorFacadeStopNotification<TValue> {
+    readonly key: string;
+    readonly ref: GridEditorFacadeRef | undefined;
+    readonly reason: GridEditorStopReason;
+    readonly origin: GridEditorFacadeStopOrigin;
+    readonly result: GridEditorFacadeStopResult<TValue>;
+    readonly transactionOutcome: GridEditorFacadeTransactionOutcome;
+    readonly terminal: boolean;
+}
+export type GridEditorFacadeStopResultListener<TValue> = (notification: GridEditorFacadeStopNotification<TValue>) => void;
+export type GridEditorFacadeLookup<TData, TValue, TContext> = {
+    readonly status: 'idle';
+} | {
+    readonly status: 'starting';
+    readonly key: string;
+} | {
+    readonly status: 'mounted';
+    readonly ref: GridEditorFacadeRef;
+    readonly gui: HTMLElement;
+    readonly popup: boolean;
+    readonly popupPosition: 'over' | 'under';
+    readonly attached: boolean;
+    readonly params: Readonly<GridEditorFacadeParams<TData, TValue, TContext>>;
+};
+export interface GridEditorFacadeKeyEvent {
+    readonly key: string;
+    readonly shiftKey?: boolean;
+    readonly isComposing?: boolean;
+    preventDefault?(): void;
+}
+export type GridEditorFacadeKeyResult<TValue> = {
+    readonly handled: false;
+} | {
+    readonly handled: true;
+    readonly reason: 'enter' | 'tab' | 'escape';
+    readonly navigation?: 'next-cell' | 'previous-cell';
+    readonly result: GridEditorFacadeStopResult<TValue>;
+};
+export interface GridEditorFacadeControllerOptions<TData, TValue, TContext> {
+    readonly manager: Pick<GridComponentManager<TData, TValue, unknown, TContext>, 'resolve' | 'editor' | 'createRichSelectEditor'>;
+    readonly onError?: (error: GridComponentError) => void;
+}
+export interface GridEditorFacadeStats {
+    readonly active: 0 | 1;
+    readonly attached: 0 | 1;
+    readonly starting: 0 | 1;
+    readonly disposed: boolean;
+    readonly revision: number;
+}
+export interface GridEditorFacadeController<TData = DefaultData, TValue = unknown, TContext = unknown, TPlacement = unknown, TAttachment = unknown> {
+    begin(request: GridEditorFacadeBeginRequest<TData, TValue, TContext>): Promise<GridEditorFacadeBeginResult<TData, TValue, TContext>>;
+    attach(ref: GridEditorFacadeRef, host: GridEditorFacadeHost<TData, TValue, TContext, TPlacement, TAttachment>): Promise<GridEditorFacadeAttachResult>;
+    stop(reason: GridEditorStopReason, options?: {
+        readonly cancel?: boolean;
+    }): Promise<GridEditorFacadeStopResult<TValue>>;
+    handleKey(event: GridEditorFacadeKeyEvent): Promise<GridEditorFacadeKeyResult<TValue>>;
+    handleBlur(): Promise<GridEditorFacadeStopResult<TValue>>;
+    handleMouseStop(): Promise<GridEditorFacadeStopResult<TValue>>;
+    lookup(): GridEditorFacadeLookup<TData, TValue, TContext>;
+    focusIn(ref?: GridEditorFacadeRef): boolean;
+    focusOut(ref?: GridEditorFacadeRef): boolean;
+    destroy(ref?: GridEditorFacadeRef): Promise<boolean>;
+    disconnect(): Promise<void>;
+    stats(): GridEditorFacadeStats;
+}
+export declare function createGridEditorFacadeController<TData = DefaultData, TValue = unknown, TContext = unknown, TPlacement = unknown, TAttachment = unknown>(options: GridEditorFacadeControllerOptions<TData, TValue, TContext>): GridEditorFacadeController<TData, TValue, TContext, TPlacement, TAttachment>;
+export {};

package/dist/types/components/grid/core/component/editor-validation-presentation.d.ts

@@ -0,0 +1,6 @@
+export interface GridEditorValidationPresentation {
+    readonly wrapper: HTMLElement;
+    readonly element: HTMLElement;
+    clear(): void;
+}
+export declare function renderGridEditorValidation(wrapper: HTMLElement, message: string): GridEditorValidationPresentation | null;

package/dist/types/components/grid/core/component/filter-adapter.d.ts

@@ -0,0 +1,107 @@
+import { GridComponentError, type GridExternalFilterCallbacks, type GridExternalFilterInstance, type GridFilterDefinition, type GridFilterInstance, type GridFilterParams, type GridFloatingFilterDefinition, type GridFloatingFilterInstance, type GridFloatingFilterParams } from './contracts';
+import { type GridAsyncValueLoader, type GridAsyncValueSource } from './async-value-source';
+import { type GridComponentMountParams, type GridComponentMountResult, type GridComponentRefreshResult, type GridComponentRuntime, type GridComponentRuntimeOptions } from './runtime';
+export type GridFilterOperationResult<T> = {
+    readonly status: 'ok';
+    readonly key: string;
+    readonly generation: number;
+    readonly value: T;
+} | {
+    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;
+};
+export interface GridFilterMountRequest<TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown> {
+    readonly key: string;
+    readonly componentName?: string;
+    readonly definition: GridFilterDefinition<TData, TValue, TModel, TContext>;
+    readonly params: GridComponentMountParams<GridFilterParams<TData, TValue, TContext>>;
+}
+export type GridFilterMountResult<TData, TValue, TModel, TContext> = GridComponentMountResult<GridFilterInstance<TData, TValue, TModel, TContext>, HTMLElement>;
+export interface GridFilterAdapterOptions<TData, TValue, TModel, TContext> extends Omit<GridComponentRuntimeOptions<GridFilterParams<TData, TValue, TContext>, HTMLElement>, 'kind'> {
+    readonly modelsEqual?: (left: TModel | null, right: TModel | null) => boolean;
+}
+export interface GridFilterAdapter<TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown> {
+    readonly runtime: GridComponentRuntime<GridFilterInstance<TData, TValue, TModel, TContext>, GridFilterParams<TData, TValue, TContext>, HTMLElement>;
+    mount(request: GridFilterMountRequest<TData, TValue, TModel, TContext>): Promise<GridFilterMountResult<TData, TValue, TModel, TContext>>;
+    afterAttach(key: string, generation: number): Promise<GridFilterOperationResult<void>>;
+    afterDetach(key: string, generation: number): Promise<GridFilterOperationResult<void>>;
+    refresh(key: string, params: GridComponentMountParams<GridFilterParams<TData, TValue, TContext>>): Promise<GridComponentRefreshResult<GridFilterInstance<TData, TValue, TModel, TContext>, HTMLElement>>;
+    getActive(key: string): GridFilterOperationResult<boolean>;
+    isActive(key: string): boolean;
+    doesPass(key: string, data: Readonly<TData>): boolean;
+    getModel(key: string): Promise<GridFilterOperationResult<TModel | null>>;
+    setModel(key: string, model: TModel | null): Promise<GridFilterOperationResult<void>>;
+    modelAsString(key: string, model?: TModel | null): Promise<GridFilterOperationResult<string | undefined>>;
+    onNewRowsLoaded(key: string): Promise<GridFilterOperationResult<void>>;
+    onAnyFilterChanged(key: string): Promise<GridFilterOperationResult<void>>;
+    destroy(key: string): Promise<boolean>;
+    recreate(key: string, replacement?: Omit<GridFilterMountRequest<TData, TValue, TModel, TContext>, 'key'>, options?: GridFilterRecreateOptions): Promise<GridFilterMountResult<TData, TValue, TModel, TContext> | {
+        readonly status: 'not-mounted';
+        readonly key: string;
+    }>;
+    destroyAll(): Promise<void>;
+    createValueSource<TOption>(loader: GridAsyncValueLoader<TOption>): GridAsyncValueSource<TOption>;
+    disconnect(): Promise<void>;
+}
+export interface GridFilterRecreateOptions {
+    readonly preserveModel?: boolean;
+}
+export declare function createGridFilterAdapter<TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown>(options?: GridFilterAdapterOptions<TData, TValue, TModel, TContext>): GridFilterAdapter<TData, TValue, TModel, TContext>;
+export interface GridFloatingFilterMountRequest<TModel = unknown, TContext = unknown> {
+    readonly key: string;
+    readonly componentName?: string;
+    readonly definition: GridFloatingFilterDefinition<TModel, TContext>;
+    readonly params: GridComponentMountParams<GridFloatingFilterParams<TModel, TContext>>;
+}
+export type GridFloatingFilterParentSource = 'api' | 'ui' | 'restore';
+export interface GridFloatingFilterAdapterOptions<TModel, TContext> extends Omit<GridComponentRuntimeOptions<GridFloatingFilterParams<TModel, TContext>, HTMLElement>, 'kind'> {
+    readonly modelsEqual?: (left: TModel | null, right: TModel | null) => boolean;
+}
+export interface GridFloatingFilterAdapter<TModel = unknown, TContext = unknown> {
+    readonly runtime: GridComponentRuntime<GridFloatingFilterInstance<TModel, TContext>, GridFloatingFilterParams<TModel, TContext>, HTMLElement>;
+    mount(request: GridFloatingFilterMountRequest<TModel, TContext>): Promise<GridComponentMountResult<GridFloatingFilterInstance<TModel, TContext>, HTMLElement>>;
+    afterAttach(key: string, generation: number): Promise<GridFilterOperationResult<void>>;
+    afterDetach(key: string, generation: number): Promise<GridFilterOperationResult<void>>;
+    parentModelChanged(key: string, model: TModel | null, source: GridFloatingFilterParentSource, force?: boolean): Promise<GridFilterOperationResult<void>>;
+    destroy(key: string): Promise<boolean>;
+    destroyAll(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export declare function createGridFloatingFilterAdapter<TModel = unknown, TContext = unknown>(options?: GridFloatingFilterAdapterOptions<TModel, TContext>): GridFloatingFilterAdapter<TModel, TContext>;
+export type GridExternalFilterSource<TData, TContext> = GridExternalFilterCallbacks<TData> | GridExternalFilterInstance<TData, TContext>;
+export type GridExternalFilterRefreshResult = {
+    readonly status: 'refreshed';
+    readonly generation: number;
+} | {
+    readonly status: 'stale';
+    readonly generation: number;
+} | {
+    readonly status: 'failed';
+    readonly generation: number;
+    readonly error: GridComponentError;
+};
+export interface GridExternalFilterControllerOptions {
+    readonly key?: string;
+    readonly timeoutMs?: number;
+    readonly onError?: (error: GridComponentError) => void;
+}
+export interface GridExternalFilterController<TData, TContext> {
+    getPredicateError(): GridComponentError | null;
+    isPresent(): boolean;
+    doesPass(data: Readonly<TData>): boolean;
+    refresh(context: TContext, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<GridExternalFilterRefreshResult>;
+    destroy(): Promise<void>;
+}
+export declare function subscribeGridExternalFilterAvailability(source: GridExternalFilterSource<unknown, unknown>, callback: () => void): () => void;
+export declare function createGridExternalFilterController<TData = Record<string, unknown>, TContext = unknown>(source: GridExternalFilterSource<TData, TContext>, options?: GridExternalFilterControllerOptions): GridExternalFilterController<TData, TContext>;

package/dist/types/components/grid/core/component/filter-facade-controller.d.ts

@@ -0,0 +1,118 @@
+import { GridComponentError, type GridComponentLocalDefinitions, type GridExternalFilterCallbacks, type GridExternalFilterInstance, type GridFilterDefinition, type GridFilterInstance, type GridFilterParams, type GridFloatingFilterDefinition, type GridFloatingFilterInstance, type GridFloatingFilterParams } from './contracts';
+import type { GridExternalFilterController, GridExternalFilterRefreshResult, GridFilterOperationResult, GridFloatingFilterParentSource } from './filter-adapter';
+import type { GridComponentManager } from './component-runtime-chunk';
+import type { GridMountedComponentLookup } from './runtime';
+type AnyData = Record<string, unknown>;
+export type GridFilterExecutionMode = 'client' | 'server' | 'infinite';
+export type GridFilterDeclaration<TData = AnyData, TValue = unknown, TModel = unknown, TContext = unknown> = string | GridFilterDefinition<TData, TValue, TModel, TContext>;
+export type GridFloatingFilterDeclaration<TModel = unknown, TContext = unknown> = string | GridFloatingFilterDefinition<TModel, TContext>;
+export interface GridFilterFacadeColumn<TData = AnyData, TValue = unknown, TModel = unknown, TContext = unknown> {
+    readonly colId: string;
+    readonly filter: GridFilterDeclaration<TData, TValue, TModel, TContext> | null | undefined;
+    readonly floatingFilter?: GridFloatingFilterDeclaration<TModel, TContext> | null;
+    readonly getValue: (data: Readonly<TData>) => TValue;
+    readonly local?: GridComponentLocalDefinitions<TData, TValue, TModel, TContext>;
+    readonly version?: unknown;
+    readonly resolutionVersion?: unknown;
+}
+export type GridSerializableValue = null | boolean | number | string | ReadonlyArray<GridSerializableValue> | {
+    readonly [key: string]: GridSerializableValue;
+};
+export interface GridFilterSerializableSnapshot {
+    readonly revision: number;
+    readonly models: Readonly<Record<string, GridSerializableValue>>;
+    readonly errors: ReadonlyArray<GridComponentError>;
+}
+export interface GridFilterModelSnapshot<TModel> {
+    readonly revision: number;
+    readonly models: Readonly<Record<string, TModel | null>>;
+    readonly errors: ReadonlyArray<GridComponentError>;
+}
+export type GridFilterFacadeAttachResult = {
+    readonly status: 'mounted' | 'attached' | 'already-attached';
+    readonly colId: string;
+    readonly generation: number;
+    readonly gui: HTMLElement;
+} | {
+    readonly status: 'detached-host' | 'not-mounted' | 'stale' | 'failed' | 'disconnected';
+    readonly colId: string;
+    readonly error?: GridComponentError;
+};
+export type GridFilterFacadeDetachResult = {
+    readonly status: 'detached' | 'already-detached';
+    readonly colId: string;
+} | {
+    readonly status: 'stale' | 'failed' | 'disconnected';
+    readonly colId: string;
+    readonly error?: GridComponentError;
+};
+export interface GridFilterFacadeReconcileResult {
+    readonly status: 'applied' | 'stale' | 'disconnected';
+    readonly revision: number;
+    readonly mounted: ReadonlyArray<string>;
+    readonly refreshed: ReadonlyArray<string>;
+    readonly unchanged: ReadonlyArray<string>;
+    readonly destroyed: ReadonlyArray<string>;
+    readonly errors: ReadonlyArray<GridComponentError>;
+}
+export interface GridFilterFacadeStats {
+    readonly columns: number;
+    readonly mountedFilters: number;
+    readonly mountedFloatingFilters: number;
+    readonly attachedFilterGuis: number;
+    readonly attachedFloatingFilterGuis: number;
+    readonly modelRevision: number;
+    readonly reconcileRevision: number;
+    readonly disconnected: boolean;
+}
+export interface GridFilterFacadeChangedEvent<TModel> {
+    readonly colId: string;
+    readonly source: GridFloatingFilterParentSource;
+    readonly model: TModel | null;
+    readonly revision: number;
+}
+export interface GridFilterFacadeControllerOptions<TData, TValue, TModel, TContext> {
+    readonly manager: Pick<GridComponentManager<TData, TValue, TModel, TContext>, 'resolve' | 'filter' | 'floatingFilter' | 'setExternalFilter' | 'getExternalFilter'>;
+    readonly context?: TContext;
+    readonly getContext?: () => TContext;
+    readonly executionMode?: GridFilterExecutionMode | (() => GridFilterExecutionMode);
+    readonly ownerId?: string;
+    readonly modelsEqual?: (left: TModel | null, right: TModel | null) => boolean;
+    readonly isHostConnected?: (host: HTMLElement) => boolean;
+    readonly onFilterChanged?: (event: GridFilterFacadeChangedEvent<TModel>) => void;
+    readonly onFilterModified?: (colId: string) => void;
+    readonly onError?: (error: GridComponentError) => void;
+}
+export interface GridFilterFacadeController<TData = AnyData, TValue = unknown, TModel = unknown, TContext = unknown> {
+    reconcileColumns(columns: ReadonlyArray<GridFilterFacadeColumn<TData, TValue, TModel, TContext>>): Promise<GridFilterFacadeReconcileResult>;
+    attachFilterGui(colId: string, host: HTMLElement): Promise<GridFilterFacadeAttachResult>;
+    detachFilterGui(colId: string): Promise<GridFilterFacadeDetachResult>;
+    attachFloatingFilterGui(colId: string, host: HTMLElement): Promise<GridFilterFacadeAttachResult>;
+    detachFloatingFilterGui(colId: string): Promise<GridFilterFacadeDetachResult>;
+    doesPass(data: Readonly<TData>, mode?: GridFilterExecutionMode): boolean;
+    isFilterActive(colId: string): boolean;
+    onAnyFilterChanged(exceptColId?: string): Promise<ReadonlyArray<GridFilterOperationResult<void>>>;
+    synchronizeFilterModels(source?: GridFloatingFilterParentSource): Promise<ReadonlyArray<GridFilterOperationResult<TModel | null>>>;
+    getSerializableModels(): GridFilterSerializableSnapshot;
+    getFilterModels(): Promise<GridFilterModelSnapshot<TModel>>;
+    getFilterModel(colId: string): Promise<GridFilterOperationResult<TModel | null>>;
+    setFilterModel(colId: string, model: TModel | null, source?: GridFloatingFilterParentSource): Promise<GridFilterOperationResult<void>>;
+    setFilterModels(models: Readonly<Record<string, TModel | null>>, options?: {
+        readonly clearUnspecified?: boolean;
+        readonly source?: GridFloatingFilterParentSource;
+    }): Promise<ReadonlyArray<GridFilterOperationResult<void>>>;
+    destroyFilter(colId: string): Promise<boolean>;
+    recreateFilter(colId: string, options?: {
+        readonly preserveModel?: boolean;
+    }): Promise<GridFilterFacadeAttachResult>;
+    lookupFilterInstance(colId: string): GridMountedComponentLookup<GridFilterInstance<TData, TValue, TModel, TContext>, GridFilterParams<TData, TValue, TContext>, HTMLElement>;
+    lookupFloatingFilterInstance(colId: string): GridMountedComponentLookup<GridFloatingFilterInstance<TModel, TContext>, GridFloatingFilterParams<TModel, TContext>, HTMLElement>;
+    setExternalFilter(source: GridExternalFilterCallbacks<TData> | GridExternalFilterInstance<TData, TContext> | null): Promise<GridExternalFilterController<TData, TContext> | null>;
+    refreshExternalFilter(context?: TContext): Promise<GridExternalFilterRefreshResult | null>;
+    getExternalFilter(): GridExternalFilterController<TData, TContext> | null;
+    onNewRowsLoaded(): Promise<ReadonlyArray<GridFilterOperationResult<void>>>;
+    stats(): GridFilterFacadeStats;
+    disconnect(): Promise<void>;
+}
+export declare function createGridFilterFacadeController<TData = AnyData, TValue = unknown, TModel = unknown, TContext = unknown>(options: GridFilterFacadeControllerOptions<TData, TValue, TModel, TContext>): GridFilterFacadeController<TData, TValue, TModel, TContext>;
+export {};

package/dist/types/components/grid/core/component/framework-bridge.d.ts

@@ -0,0 +1,17 @@
+import { type GridComponentFactoryDefinition, type GridComponentParams, type GridGuiComponent, type GridMaybePromise } from './contracts';
+export interface GridFrameworkHandle<TParams, TGui> {
+    readonly gui: TGui;
+    update?(params: TParams): GridMaybePromise<boolean | void>;
+    focusIn?(): void;
+    focusOut?(): void;
+    destroy?(): GridMaybePromise<void>;
+}
+export interface GridFrameworkBridge<TFrameworkComponent, TParams extends GridComponentParams, TGui> {
+    mount(component: TFrameworkComponent, params: TParams, signal: AbortSignal): GridMaybePromise<GridFrameworkHandle<TParams, TGui>>;
+}
+export interface GridFrameworkComponentInstance<TParams extends GridComponentParams, TGui> extends GridGuiComponent<TParams, TGui> {
+    refresh(params: TParams): GridMaybePromise<boolean>;
+    focusIn(): void;
+    focusOut(): void;
+}
+export declare function adaptGridFrameworkComponent<TFrameworkComponent, TParams extends GridComponentParams, TGui>(component: TFrameworkComponent, bridge: GridFrameworkBridge<TFrameworkComponent, TParams, TGui>): GridComponentFactoryDefinition<GridFrameworkComponentInstance<TParams, TGui>, TParams>;

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

@@ -0,0 +1,12 @@
+export * from './contracts';
+export * from './registry';
+export * from './runtime';
+export * from './renderer-adapter';
+export * from './renderer-controller';
+export * from './editor-adapter';
+export * from './editor-validation-presentation';
+export * from './filter-adapter';
+export * from './framework-bridge';
+export * from './async-value-source';
+export * from './popup-placement';
+export * from './rich-select-editor';

package/dist/types/components/grid/core/component/popup-placement.d.ts

@@ -0,0 +1,29 @@
+export interface GridPopupRect {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly width: number;
+    readonly height: number;
+}
+export interface GridPopupSize {
+    readonly width: number;
+    readonly height: number;
+}
+export interface GridEditorPopupPlacementOptions {
+    readonly preferred?: 'over' | 'under';
+    readonly rtl?: boolean;
+    readonly touch?: boolean;
+    readonly gap?: number;
+    readonly margin?: number;
+}
+export interface GridEditorPopupPlacement {
+    readonly position: 'fixed';
+    readonly placement: 'over' | 'under' | 'above';
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+}
+export declare function placeGridEditorPopup(anchor: GridPopupRect, popup: GridPopupSize, viewport: GridPopupRect, options?: GridEditorPopupPlacementOptions): GridEditorPopupPlacement;

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

@@ -0,0 +1,39 @@
+import { type GridComponentDefinition, type GridComponentDefinitionFor, type GridComponentKind, type GridComponentLocalDefinitions, type GridEagerComponentDefinition } from './contracts';
+export type GridComponentRegistrationScope = 'local' | 'global';
+export type GridComponentResolutionOrigin = 'direct' | 'local' | 'global';
+export interface GridComponentLookupRequest<TKind extends GridComponentKind, TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown> {
+    readonly kind: TKind;
+    readonly definition?: GridComponentDefinitionFor<TKind, TData, TValue, TModel, TContext>;
+    readonly name?: string;
+    readonly local?: GridComponentLocalDefinitions<TData, TValue, TModel, TContext>;
+    readonly signal?: AbortSignal;
+}
+export interface GridResolvedComponent<TKind extends GridComponentKind, TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown> {
+    readonly kind: TKind;
+    readonly name: string | undefined;
+    readonly origin: GridComponentResolutionOrigin;
+    readonly definition: Exclude<GridComponentDefinitionFor<TKind, TData, TValue, TModel, TContext>, {
+        readonly type: 'lazy';
+    }>;
+}
+export interface GridComponentRegistry<TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown> {
+    register<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, TData, TValue, TModel, TContext>): void;
+    replace<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, TData, TValue, TModel, TContext>): void;
+    unregister(scope: GridComponentRegistrationScope, kind: GridComponentKind, name: string): boolean;
+    has(scope: GridComponentRegistrationScope, kind: GridComponentKind, name: string): boolean;
+    list(scope: GridComponentRegistrationScope, kind: GridComponentKind): ReadonlyArray<string>;
+    resolve<TKind extends GridComponentKind>(request: GridComponentLookupRequest<TKind, TData, TValue, TModel, TContext>): Promise<GridResolvedComponent<TKind, TData, TValue, TModel, TContext>>;
+    invalidateLazy(scope: GridComponentRegistrationScope, kind: GridComponentKind, name: string): boolean;
+    clear(scope?: GridComponentRegistrationScope): void;
+}
+export declare function isGridEagerComponentDefinition(value: unknown): value is GridEagerComponentDefinition<unknown, unknown>;
+export declare function isGridLazyComponentDefinition(value: unknown): value is Extract<GridComponentDefinition<unknown, unknown>, {
+    readonly type: 'lazy';
+}>;
+export declare function getCapturedGridEagerDefinition<TInstance, TParams>(definition: GridEagerComponentDefinition<TInstance, TParams>): GridEagerComponentDefinition<TInstance, TParams>;
+export declare function resolveGridComponentDefinition<TInstance, TParams>(definition: GridComponentDefinition<TInstance, TParams>, options: {
+    readonly kind: GridComponentKind;
+    readonly name?: string;
+    readonly signal?: AbortSignal;
+}): Promise<GridEagerComponentDefinition<TInstance, TParams>>;
+export declare function createGridComponentRegistry<TData = Record<string, unknown>, TValue = unknown, TModel = unknown, TContext = unknown>(): GridComponentRegistry<TData, TValue, TModel, TContext>;

package/dist/types/components/grid/core/component/renderer-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { CellRenderer } from '../cell/renderer-registry';
+import { type GridRendererDefinition, type GridRendererGui, type GridRendererInstance, type GridRendererParams, type GridRendererSource } from './contracts';
+import { type GridComponentMountParams, type GridComponentMountResult, type GridComponentRefreshResult, type GridComponentRuntime, type GridComponentRuntimeOptions } from './runtime';
+export declare function adaptPureCellRenderer<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown>(renderer: CellRenderer<TRow, TValue>): GridRendererDefinition<TRow, TValue, TContext>;
+export declare function normalizeGridRendererSource<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown>(source: GridRendererSource<TRow, TValue, TContext>): GridRendererDefinition<TRow, TValue, TContext>;
+export interface GridRendererMountRequest<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly key: string;
+    readonly componentName?: string;
+    readonly source: GridRendererSource<TRow, TValue, TContext>;
+    readonly params: GridComponentMountParams<GridRendererParams<TRow, TValue, TContext>>;
+}
+export interface GridRendererAdapter<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly runtime: GridComponentRuntime<GridRendererInstance<TRow, TValue, TContext>, GridRendererParams<TRow, TValue, TContext>, GridRendererGui>;
+    mount(request: GridRendererMountRequest<TRow, TValue, TContext>): Promise<GridComponentMountResult<GridRendererInstance<TRow, TValue, TContext>, GridRendererGui>>;
+    refresh(key: string, params: GridComponentMountParams<GridRendererParams<TRow, TValue, TContext>>): Promise<GridComponentRefreshResult<GridRendererInstance<TRow, TValue, TContext>, GridRendererGui>>;
+}
+export declare function createGridRendererAdapter<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown>(options?: Omit<GridComponentRuntimeOptions<GridRendererParams<TRow, TValue, TContext>, GridRendererGui>, 'kind'>): GridRendererAdapter<TRow, TValue, TContext>;

package/dist/types/components/grid/core/component/renderer-controller.d.ts

@@ -0,0 +1,88 @@
+import { GridComponentError, type GridRendererGui, type GridRendererInstance, type GridRendererParams, type GridRendererSource } from './contracts';
+import { type GridRendererAdapter } from './renderer-adapter';
+import type { GridComponentMountParams, GridComponentRuntimeOptions } from './runtime';
+export interface GridRendererCellIdentity {
+    readonly rowId: string | number;
+    readonly colId: string;
+}
+export declare function createGridRendererCellKey(identity: GridRendererCellIdentity): string;
+export type GridRendererHost = Pick<HTMLElement, 'innerHTML' | 'replaceChildren' | 'textContent'> & Partial<Pick<HTMLElement, 'firstChild' | 'childNodes'>>;
+export interface GridRendererControllerRenderRequest<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly identity: GridRendererCellIdentity;
+    readonly host: GridRendererHost;
+    readonly componentName?: string;
+    readonly source: GridRendererSource<TRow, TValue, TContext>;
+    readonly params: GridComponentMountParams<GridRendererParams<TRow, TValue, TContext>>;
+}
+export interface GridRendererPaintContext<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly key: string;
+    readonly generation: number;
+    readonly request: GridRendererControllerRenderRequest<TRow, TValue, TContext>;
+}
+export interface GridRendererControllerOptions<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly runtime?: Omit<GridComponentRuntimeOptions<GridRendererParams<TRow, TValue, TContext>, GridRendererGui>, 'kind'>;
+    readonly isElement?: (value: unknown) => value is HTMLElement;
+    readonly isHostConnected?: (host: GridRendererHost) => boolean;
+    readonly logicalExists?: (identity: GridRendererCellIdentity, key: string) => boolean;
+    readonly maxRetainedOffscreenRecords?: number;
+    readonly paintVNode?: (host: GridRendererHost, vnode: unknown, context: GridRendererPaintContext<TRow, TValue, TContext>) => void;
+    readonly fallback?: (error: GridComponentError, context: GridRendererPaintContext<TRow, TValue, TContext>) => GridRendererGui | undefined;
+    readonly onError?: (error: GridComponentError) => void;
+}
+export type GridRendererControllerRenderResult<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> = {
+    readonly status: 'mounted' | 'refreshed' | 'recreated';
+    readonly key: string;
+    readonly generation: number;
+    readonly instance: GridRendererInstance<TRow, TValue, TContext>;
+    readonly gui: GridRendererGui;
+} | {
+    readonly status: 'stale';
+    readonly key: string;
+    readonly generation?: number;
+} | {
+    readonly status: 'failed';
+    readonly key: string;
+    readonly generation: number;
+    readonly error: GridComponentError;
+    readonly fallbackPainted: boolean;
+};
+export type GridRendererDiscovery<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> = {
+    readonly status: 'mounted';
+    readonly key: string;
+    readonly identity: GridRendererCellIdentity;
+    readonly generation: number;
+    readonly host: GridRendererHost;
+    readonly instance: GridRendererInstance<TRow, TValue, TContext>;
+    readonly gui: GridRendererGui;
+    readonly params: GridRendererParams<TRow, TValue, TContext>;
+} | {
+    readonly status: 'logical-offscreen';
+    readonly key: string;
+    readonly identity: GridRendererCellIdentity;
+    readonly lastGeneration?: number;
+} | {
+    readonly status: 'unavailable';
+    readonly key: string;
+} | {
+    readonly status: 'stale';
+    readonly key: string;
+    readonly requestedGeneration: number;
+    readonly currentGeneration?: number;
+};
+export interface GridRendererControllerStats {
+    readonly logical: number;
+    readonly mounted: number;
+    readonly disposed: boolean;
+}
+export interface GridRendererController<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown> {
+    readonly adapter: GridRendererAdapter<TRow, TValue, TContext>;
+    render(request: GridRendererControllerRenderRequest<TRow, TValue, TContext>): Promise<GridRendererControllerRenderResult<TRow, TValue, TContext>>;
+    lookup(identityOrKey: GridRendererCellIdentity | string, expectedGeneration?: number): GridRendererDiscovery<TRow, TValue, TContext>;
+    reconcileMounted(active: ReadonlyArray<GridRendererCellIdentity | string>): Promise<void>;
+    destroy(identityOrKey: GridRendererCellIdentity | string, expectedGeneration?: number): Promise<boolean>;
+    focusIn(identityOrKey: GridRendererCellIdentity | string, expectedGeneration?: number): boolean;
+    focusOut(identityOrKey: GridRendererCellIdentity | string, expectedGeneration?: number): boolean;
+    dispose(): Promise<void>;
+    stats(): GridRendererControllerStats;
+}
+export declare function createGridRendererController<TRow = Record<string, unknown>, TValue = unknown, TContext = unknown>(options?: GridRendererControllerOptions<TRow, TValue, TContext>): GridRendererController<TRow, TValue, TContext>;

package/dist/types/components/grid/core/component/rich-select-editor.d.ts

@@ -0,0 +1,16 @@
+import { type GridEditorDefinition } from './contracts';
+import { type GridAsyncValueLoader } from './async-value-source';
+export interface GridRichSelectOption<TValue = unknown> {
+    readonly value: TValue;
+    readonly label: string;
+    readonly disabled?: boolean;
+}
+export interface GridRichSelectEditorOptions<TValue = unknown> {
+    readonly values: ReadonlyArray<GridRichSelectOption<TValue>> | GridAsyncValueLoader<GridRichSelectOption<TValue>>;
+    readonly placeholder?: string;
+    readonly loadingText?: string;
+    readonly emptyText?: string;
+    readonly errorText?: string;
+    readonly allowCommitWhileLoading?: boolean;
+}
+export declare function createGridRichSelectEditorDefinition<TData = Record<string, unknown>, TValue = unknown, TContext = unknown>(options: GridRichSelectEditorOptions<TValue>): GridEditorDefinition<TData, TValue, TContext>;