nuxt-ui-tools 0.1.0

package/dist/runtime/spreadsheet/types/columns.d.ts

@@ -0,0 +1,298 @@
+import type { LazyTextValue, MaybePromise } from '#ui-tools/shared/types/utils';
+import type { InferSpreadsheetOptionValue, InferSpreadsheetOptionsSourceValue, SpreadsheetOptionItem, SpreadsheetOptionsSource } from './options.js';
+import type { SpreadsheetColumnResolveDefinition, SpreadsheetResolvedSelectionValue } from './resolution.js';
+import type { SpreadsheetCellValue, SpreadsheetMatchDefinition, SpreadsheetModifier } from './shared.js';
+import type { SpreadsheetFieldRulesInput } from './validation.js';
+export interface SpreadsheetColumnDefinition<TKey extends string = string, TValue = unknown, TRequired extends boolean = boolean, TContext = unknown, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = undefined, TSourceValue = TValue, TResolve = undefined> {
+    kind: 'text' | 'email' | 'number' | 'date' | 'boolean' | 'enum' | 'option';
+    key: TKey;
+    label?: LazyTextValue;
+    required?: TRequired;
+    match?: SpreadsheetMatchDefinition;
+    from?: string | RegExp | readonly (string | RegExp)[];
+    modifiers?: readonly SpreadsheetModifier[];
+    multiple?: boolean | {
+        separator?: string;
+        matchBy?: 'label' | 'value';
+        itemModifiers?: readonly SpreadsheetModifier[];
+    };
+    parse?: (params: {
+        cell: SpreadsheetCellValue;
+        context: TContext;
+    }) => MaybePromise<TSourceValue>;
+    resolve?: TResolve;
+    rules?: SpreadsheetFieldRulesInput<TValue>;
+    __rulesInput?: TRulesInput;
+    __valueType?: TValue;
+    __sourceValueType?: TSourceValue;
+    __resolveType?: TResolve;
+}
+export interface SpreadsheetColumnGroupDefinition<TKey extends string = string, TColumns extends readonly unknown[] = readonly unknown[]> {
+    kind: 'group';
+    key: TKey;
+    columns: TColumns;
+}
+export type SpreadsheetStaticColumnEntry = SpreadsheetColumnDefinition<string, unknown, boolean, unknown> | SpreadsheetColumnGroupDefinition<string, readonly unknown[]>;
+type ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple> = TParse extends (...args: infer _Args) => infer TResult ? Awaited<TResult> : TMultiple extends false | undefined ? TDefault : TDefault[];
+export interface SpreadsheetColumnMultipleOptions {
+    separator?: string;
+    itemModifiers?: readonly SpreadsheetModifier[];
+}
+export interface SpreadsheetEnumColumnMultipleOptions extends SpreadsheetColumnMultipleOptions {
+}
+export interface SpreadsheetOptionColumnMultipleOptions extends SpreadsheetColumnMultipleOptions {
+    matchBy?: 'label' | 'value';
+}
+export interface SpreadsheetColumnBaseOptions<TContext, TSourceValue, TRequired extends boolean, TMultiple = boolean | SpreadsheetColumnMultipleOptions> {
+    label?: LazyTextValue;
+    required?: TRequired;
+    match?: SpreadsheetMatchDefinition;
+    from?: string | RegExp | readonly (string | RegExp)[];
+    modifiers?: readonly SpreadsheetModifier[];
+    multiple?: TMultiple;
+    parse?: (params: {
+        cell: SpreadsheetCellValue;
+        context: TContext;
+    }) => MaybePromise<TSourceValue>;
+    rules?: SpreadsheetFieldRulesInput<TSourceValue>;
+}
+export type SpreadsheetEnumColumnOptions<TContext, TOptionValue, TRequired extends boolean, TMultiple = boolean | SpreadsheetEnumColumnMultipleOptions, TResolvedValue = TOptionValue> = SpreadsheetColumnBaseOptions<TContext, TResolvedValue, TRequired, TMultiple> & {
+    options: readonly TOptionValue[];
+};
+export type SpreadsheetOptionColumnOptions<TContext, TOption extends SpreadsheetOptionItem, TRequired extends boolean, TMultiple = boolean | SpreadsheetOptionColumnMultipleOptions, TResolvedValue = InferSpreadsheetOptionValue<TOption>> = SpreadsheetColumnBaseOptions<TContext, TResolvedValue, TRequired, TMultiple> & {
+    options: SpreadsheetOptionsSource<{
+        context: TContext;
+    }, TOption>;
+};
+export interface SpreadsheetScalarColumnBuilder<TContext = unknown, TDefault = unknown, TMultipleConfig = SpreadsheetColumnMultipleOptions> {
+    <TKey extends string, TRequired extends boolean = false, TMultiple extends boolean | TMultipleConfig | undefined = undefined, TParse extends SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<TDefault, undefined, TMultiple>, TRequired, Exclude<TMultiple, undefined>>['parse'] | undefined = undefined, TRulesInput extends SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>> | undefined = SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>> | undefined>(key: TKey, options?: SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>, TRequired, Exclude<TMultiple, undefined>> & {
+        rules?: TRulesInput;
+    }): SpreadsheetColumnDefinition<TKey, ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>, TRequired, TContext, TRulesInput>;
+}
+export interface SpreadsheetResolvableScalarColumnBuilder<TContext = unknown, TDefault = unknown, TMultipleConfig = SpreadsheetColumnMultipleOptions> {
+    <TKey extends string, TRequired extends boolean = false, TMultiple extends boolean | TMultipleConfig | undefined = undefined, TParse extends SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<TDefault, undefined, TMultiple>, TRequired, Exclude<TMultiple, undefined>>['parse'] | undefined = undefined, TSourceValue = ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>, TRulesInput extends SpreadsheetFieldRulesInput<TSourceValue> | undefined = SpreadsheetFieldRulesInput<TSourceValue> | undefined>(key: TKey, options?: Omit<SpreadsheetColumnBaseOptions<TContext, TSourceValue, TRequired, Exclude<TMultiple, undefined>>, 'rules'> & {
+        rules?: TRulesInput;
+    }): SpreadsheetColumnDefinition<TKey, TSourceValue, TRequired, TContext, TRulesInput, TSourceValue>;
+    <TKey extends string, TRequired extends boolean = false, TMultiple extends boolean | TMultipleConfig | undefined = undefined, TParse extends SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<TDefault, undefined, TMultiple>, TRequired, Exclude<TMultiple, undefined>>['parse'] | undefined = undefined, TSourceValue = ResolveSpreadsheetColumnValue<TDefault, TParse, TMultiple>, const TResolveOptions = readonly SpreadsheetOptionItem[], TResolveValue = SpreadsheetResolvedSelectionValue<TSourceValue, InferSpreadsheetOptionsSourceValue<TResolveOptions>>, TRulesInput extends SpreadsheetFieldRulesInput<TResolveValue> | undefined = SpreadsheetFieldRulesInput<TResolveValue> | undefined>(key: TKey, options: Omit<SpreadsheetColumnBaseOptions<TContext, TSourceValue, TRequired, Exclude<TMultiple, undefined>>, 'rules'> & {
+        resolve: {
+            options: TResolveOptions & SpreadsheetOptionsSource<{
+                context: TContext;
+            }, SpreadsheetOptionItem>;
+            getOptions?: SpreadsheetColumnResolveDefinition<TContext, TSourceValue, SpreadsheetOptionItem, TResolveValue>['getOptions'];
+        };
+        rules?: TRulesInput;
+    }): SpreadsheetColumnDefinition<TKey, TResolveValue, TRequired, TContext, TRulesInput, TSourceValue, SpreadsheetColumnResolveDefinition<TContext, TSourceValue, SpreadsheetOptionItem, TResolveValue>>;
+}
+export interface SpreadsheetOptionColumnBuilder<TContext = unknown> {
+    <TKey extends string, const TOption extends SpreadsheetOptionItem, TRequired extends boolean = false, TMultiple extends boolean | SpreadsheetOptionColumnMultipleOptions | undefined = undefined, TParse extends SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<InferSpreadsheetOptionValue<TOption>, undefined, TMultiple>, TRequired, Exclude<TMultiple, undefined>>['parse'] | undefined = undefined, TRulesInput extends SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<InferSpreadsheetOptionValue<TOption>, TParse, TMultiple>> | undefined = SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<InferSpreadsheetOptionValue<TOption>, TParse, TMultiple>> | undefined>(key: TKey, options: SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<InferSpreadsheetOptionValue<TOption>, TParse, TMultiple>, TRequired, Exclude<TMultiple, undefined>> & {
+        rules?: TRulesInput;
+        options: SpreadsheetOptionsSource<{
+            context: TContext;
+        }, TOption>;
+    }): SpreadsheetColumnDefinition<TKey, ResolveSpreadsheetColumnValue<InferSpreadsheetOptionValue<TOption>, TParse, TMultiple>, TRequired, TContext, TRulesInput>;
+}
+export interface SpreadsheetColumnBuilder<TContext = unknown> {
+    text: SpreadsheetResolvableScalarColumnBuilder<TContext, string>;
+    email: SpreadsheetScalarColumnBuilder<TContext, string>;
+    number: SpreadsheetResolvableScalarColumnBuilder<TContext, number>;
+    date: SpreadsheetScalarColumnBuilder<TContext, string>;
+    boolean: SpreadsheetScalarColumnBuilder<TContext, boolean>;
+    enum: <TKey extends string, const TOptions extends readonly unknown[], TRequired extends boolean = false, TMultiple extends boolean | SpreadsheetEnumColumnMultipleOptions | undefined = undefined, TParse extends SpreadsheetColumnBaseOptions<TContext, ResolveSpreadsheetColumnValue<TOptions[number], undefined, TMultiple>, TRequired, Exclude<TMultiple, undefined>>['parse'] | undefined = undefined, TRulesInput extends SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<TOptions[number], TParse, TMultiple>> | undefined = SpreadsheetFieldRulesInput<ResolveSpreadsheetColumnValue<TOptions[number], TParse, TMultiple>> | undefined>(key: TKey, options: SpreadsheetEnumColumnOptions<TContext, TOptions[number], TRequired, Exclude<TMultiple, undefined>, ResolveSpreadsheetColumnValue<TOptions[number], TParse, TMultiple>> & {
+        rules?: TRulesInput;
+        options: TOptions;
+    }) => SpreadsheetColumnDefinition<TKey, ResolveSpreadsheetColumnValue<TOptions[number], TParse, TMultiple>, TRequired, TContext, TRulesInput>;
+    option: SpreadsheetOptionColumnBuilder<TContext>;
+}
+export interface SpreadsheetGroupBuilder {
+    <TKey extends string, TColumns extends readonly SpreadsheetStaticColumnEntry[]>(key: TKey, columns: TColumns): SpreadsheetColumnGroupDefinition<TKey, TColumns>;
+}
+type ArrayElement<TValue> = TValue extends readonly (infer TItem)[] ? TItem : never;
+type SpreadsheetDynamicCollectionCallback<TParams, TResult> = (params: TParams) => TResult;
+type SpreadsheetDynamicCallback<TParams, TResult> = (params: TParams) => TResult;
+type SpreadsheetDynamicItemCallback<TResult> = SpreadsheetDynamicCallback<unknown, TResult>;
+export interface SpreadsheetDynamicTextValueDefinition {
+    kind: 'text';
+    modifiers?: readonly SpreadsheetModifier[];
+}
+export interface SpreadsheetDynamicNumberValueDefinition {
+    kind: 'number';
+}
+export interface SpreadsheetDynamicDateValueDefinition {
+    kind: 'date';
+}
+export interface SpreadsheetDynamicBooleanValueDefinition {
+    kind: 'boolean';
+}
+export interface SpreadsheetDynamicOptionsValueDefinition<TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem, TMode extends 'single' | 'multiple' = 'single'> {
+    kind: 'options';
+    from: readonly TOption[];
+    mode: TMode;
+    separator?: string;
+    matchBy: 'label' | 'value';
+    itemModifiers?: readonly SpreadsheetModifier[];
+}
+export type SpreadsheetDynamicValueDefinition = SpreadsheetDynamicTextValueDefinition | SpreadsheetDynamicNumberValueDefinition | SpreadsheetDynamicDateValueDefinition | SpreadsheetDynamicBooleanValueDefinition | SpreadsheetDynamicOptionsValueDefinition<SpreadsheetOptionItem, 'single' | 'multiple'>;
+type SpreadsheetDynamicResolvedValue<TValueDefinition> = TValueDefinition extends SpreadsheetDynamicTextValueDefinition ? string : TValueDefinition extends SpreadsheetDynamicNumberValueDefinition ? number : TValueDefinition extends SpreadsheetDynamicDateValueDefinition ? string : TValueDefinition extends SpreadsheetDynamicBooleanValueDefinition ? boolean : TValueDefinition extends SpreadsheetDynamicOptionsValueDefinition<infer TOption, infer TMode> ? TMode extends 'multiple' ? InferSpreadsheetOptionValue<TOption>[] : InferSpreadsheetOptionValue<TOption> : never;
+type SpreadsheetDynamicDefaultArrayItem<TId extends string, TValueDefinition extends SpreadsheetDynamicValueDefinition> = SpreadsheetDynamicResolvedValue<TValueDefinition> extends infer TResult ? TResult extends readonly unknown[] ? {
+    id: TId;
+    values: TResult;
+} : {
+    id: TId;
+    value: TResult;
+} : never;
+type SpreadsheetDynamicDefaultRecordValue<TValueDefinition extends SpreadsheetDynamicValueDefinition> = SpreadsheetDynamicResolvedValue<TValueDefinition>;
+type SpreadsheetDynamicBuildParams<TSource, TId extends string, TValueDefinition extends SpreadsheetDynamicValueDefinition> = {
+    id: TId;
+    source: TSource;
+    value?: SpreadsheetDynamicResolvedValue<TValueDefinition>;
+    values?: SpreadsheetDynamicResolvedValue<TValueDefinition>;
+};
+export interface SpreadsheetDynamicValueBuilder {
+    text: (config?: {
+        modifiers?: readonly SpreadsheetModifier[];
+    }) => SpreadsheetDynamicTextValueDefinition;
+    number: () => SpreadsheetDynamicNumberValueDefinition;
+    date: () => SpreadsheetDynamicDateValueDefinition;
+    boolean: () => SpreadsheetDynamicBooleanValueDefinition;
+    options<const TOption extends SpreadsheetOptionItem, TMode extends 'single' | 'multiple' = 'single'>(config: {
+        from: readonly TOption[];
+        mode?: TMode;
+        separator?: string;
+        matchBy: 'label' | 'value';
+        itemModifiers?: readonly SpreadsheetModifier[];
+    }): SpreadsheetDynamicOptionsValueDefinition<TOption, TMode>;
+}
+type SpreadsheetDynamicValueInput = SpreadsheetDynamicValueDefinition | ((value: SpreadsheetDynamicValueBuilder) => unknown);
+type ResolveSpreadsheetDynamicValueInput<TValueInput> = TValueInput extends (...args: infer _Args) => infer TValueDefinition ? TValueDefinition extends SpreadsheetDynamicValueDefinition ? TValueDefinition : never : TValueInput extends SpreadsheetDynamicValueDefinition ? TValueInput : never;
+type SpreadsheetDynamicCollectionItemShape<TSource = unknown> = {
+    id: string;
+    match: SpreadsheetMatchDefinition;
+    value: SpreadsheetDynamicValueInput;
+    build?: SpreadsheetDynamicCollectionCallback<SpreadsheetDynamicBuildParams<TSource, string, SpreadsheetDynamicValueDefinition>, unknown>;
+};
+export interface SpreadsheetDynamicCollectionItemDefinition<TId extends string = string, TValueInput extends SpreadsheetDynamicValueInput = SpreadsheetDynamicValueInput, TSource = unknown, TBuild = unknown> {
+    id: TId;
+    match: SpreadsheetMatchDefinition;
+    value: TValueInput;
+    build?: SpreadsheetDynamicCollectionCallback<SpreadsheetDynamicBuildParams<TSource, TId, ResolveSpreadsheetDynamicValueInput<TValueInput>>, TBuild>;
+    source?: TSource;
+}
+export interface SpreadsheetDynamicCollectionDefinition<TRootKey extends string = string, TAs extends 'array' | 'record' = 'record', TItems = readonly unknown[], TOutput = unknown> {
+    kind: 'collection';
+    rootKey: TRootKey;
+    as: TAs;
+    items: TItems;
+    __outputType?: TOutput;
+}
+export interface SpreadsheetDynamicOptionGroupsDefinition<TKey extends string = string, TInto extends string = string, TValue = unknown> {
+    kind: 'option-groups';
+    key: TKey;
+    source?: readonly unknown[];
+    itemKey?: SpreadsheetDynamicItemCallback<string>;
+    itemLabel?: SpreadsheetDynamicItemCallback<string>;
+    targetKey?: SpreadsheetDynamicItemCallback<string>;
+    header?: {
+        strategy: 'exact' | 'template' | 'patterns';
+        template?: SpreadsheetDynamicCallback<{
+            source: unknown;
+        }, string>;
+        patterns?: SpreadsheetDynamicCallback<{
+            source: unknown;
+        }, readonly (string | RegExp)[]>;
+    };
+    options?: readonly SpreadsheetOptionItem<TValue>[] | SpreadsheetDynamicCollectionCallback<unknown, readonly SpreadsheetOptionItem<TValue>[]>;
+    values?: {
+        mode: 'single' | 'csv';
+        separator?: string;
+        resolve: 'label' | 'value';
+        itemModifiers?: readonly SpreadsheetModifier[];
+    };
+    output: {
+        into: TInto;
+    };
+    __valueType?: TValue;
+}
+export type SpreadsheetBuiltDynamicOptionGroupsDefinition<TKey extends string, TSource extends readonly unknown[], TOption extends SpreadsheetOptionItem, TValue, TInto extends string> = Omit<SpreadsheetDynamicOptionGroupsDefinition<TKey, TInto, TValue>, 'source' | 'itemKey' | 'itemLabel' | 'targetKey' | 'header' | 'options' | 'values'> & {
+    source: TSource;
+    itemKey: (item: ArrayElement<TSource>) => string;
+    itemLabel: (item: ArrayElement<TSource>) => string;
+    targetKey?: (item: ArrayElement<TSource>) => string;
+    header: {
+        strategy: 'exact' | 'template' | 'patterns';
+        template?: (params: {
+            source: ArrayElement<TSource>;
+        }) => string;
+        patterns?: (params: {
+            source: ArrayElement<TSource>;
+        }) => readonly (string | RegExp)[];
+    };
+    options: readonly TOption[] | ((item: ArrayElement<TSource>) => readonly TOption[]);
+    values: {
+        mode: 'single' | 'csv';
+        separator?: string;
+        resolve: 'label' | 'value';
+        itemModifiers?: readonly SpreadsheetModifier[];
+    };
+};
+export type SpreadsheetDynamicColumnEntry = SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown> | SpreadsheetDynamicCollectionDefinition<string, 'array' | 'record', readonly SpreadsheetDynamicCollectionItemDefinition[], unknown>;
+export interface SpreadsheetDynamicBuilder<TContext = unknown> {
+    optionGroups: <TKey extends string, TSource extends readonly unknown[], const TOption extends SpreadsheetOptionItem, TInto extends string>(config: {
+        key: TKey;
+        source: TSource;
+        itemKey: (item: ArrayElement<TSource>) => string;
+        itemLabel: (item: ArrayElement<TSource>) => string;
+        targetKey?: (item: ArrayElement<TSource>) => string;
+        header: {
+            strategy: 'exact' | 'template' | 'patterns';
+            template?: (params: {
+                source: ArrayElement<TSource>;
+            }) => string;
+            patterns?: (params: {
+                source: ArrayElement<TSource>;
+            }) => readonly (string | RegExp)[];
+        };
+        options: readonly TOption[] | ((item: ArrayElement<TSource>) => readonly TOption[]);
+        values: {
+            mode: 'single' | 'csv';
+            separator?: string;
+            resolve: 'label' | 'value';
+            itemModifiers?: readonly SpreadsheetModifier[];
+        };
+        output: {
+            into: TInto;
+        };
+    }) => SpreadsheetBuiltDynamicOptionGroupsDefinition<TKey, TSource, TOption, InferSpreadsheetOptionValue<TOption>, TInto>;
+    arrayFromCollection: <TRootKey extends string, TSource extends readonly unknown[], TItem extends SpreadsheetDynamicCollectionItemShape<TSource[number]>>(rootKey: TRootKey, config: {
+        from: SpreadsheetDynamicCollectionCallback<{
+            context: TContext;
+        }, TSource>;
+        each: SpreadsheetDynamicCollectionCallback<TSource[number], TItem>;
+    }) => SpreadsheetDynamicCollectionDefinition<TRootKey, 'array', readonly TItem[], TItem extends {
+        id: infer TId extends string;
+        value: infer TValueInput;
+        build?: infer TBuild;
+    } ? [TBuild] extends [unknown] ? SpreadsheetDynamicDefaultArrayItem<TId, ResolveSpreadsheetDynamicValueInput<TValueInput>> : TBuild : never>;
+    recordFromCollection: <TRootKey extends string, TSource extends readonly unknown[], TItem extends SpreadsheetDynamicCollectionItemShape<TSource[number]>>(rootKey: TRootKey, config: {
+        from: SpreadsheetDynamicCollectionCallback<{
+            context: TContext;
+        }, TSource>;
+        each: SpreadsheetDynamicCollectionCallback<TSource[number], TItem>;
+    }) => SpreadsheetDynamicCollectionDefinition<TRootKey, 'record', readonly TItem[], TItem extends {
+        value: infer TValueInput;
+        build?: infer TBuild;
+    } ? [TBuild] extends [unknown] ? SpreadsheetDynamicDefaultRecordValue<ResolveSpreadsheetDynamicValueInput<TValueInput>> : TBuild : never>;
+}
+export interface SpreadsheetColumnsDefinition<TContext = unknown> {
+    static?: readonly unknown[] | ((column: SpreadsheetColumnBuilder<TContext>, group: SpreadsheetGroupBuilder) => readonly unknown[]);
+    dynamic?: (params: {
+        dynamic: SpreadsheetDynamicBuilder<TContext>;
+        context: TContext;
+    }) => readonly unknown[];
+}
+type ResolveSpreadsheetCollection<TCollection> = TCollection extends (...args: infer _Args) => infer TResult ? TResult : TCollection;
+export type SpreadsheetResolvedColumns<TColumns> = TColumns extends {
+    static?: infer TStatic;
+} ? Omit<TColumns, 'static'> & {
+    static?: ResolveSpreadsheetCollection<TStatic>;
+} : TColumns;
+export {};

package/dist/runtime/spreadsheet/types/context.d.ts

@@ -0,0 +1,9 @@
+import type { DeepPrettify, PathToObject, UnionToIntersection } from '../../shared/types/utils.js';
+import type { SpreadsheetQueryDefinition } from './shared.js';
+export interface SpreadsheetContextItem<TKey extends string = string, TResult = unknown> {
+    key: TKey;
+    query: () => SpreadsheetQueryDefinition<TResult>;
+}
+type InferContextItemData<TItem> = TItem extends SpreadsheetContextItem<infer TKey, infer TResult> ? PathToObject<TKey, TResult> : never;
+export type SpreadsheetContextDataFromItems<TItems extends readonly SpreadsheetContextItem<string, unknown>[]> = DeepPrettify<UnionToIntersection<InferContextItemData<TItems[number]>>>;
+export {};

package/dist/runtime/spreadsheet/types/import.d.ts

@@ -0,0 +1,55 @@
+import type { ComputedRef, ShallowRef } from 'vue';
+import type { ExtractSpreadsheetRow, ExtractSpreadsheetSubmitPayload } from './inference.js';
+import type { SpreadsheetReferenceResolution, SpreadsheetResolvedReferenceRow } from './reference-session.js';
+import type { SpreadsheetHeaderCell, SpreadsheetParsedRow, SpreadsheetRowSummary } from './rows.js';
+import type { SpreadsheetBinarySource, SpreadsheetWorkbookData, SpreadsheetWorkbookSelection, SpreadsheetWorkbookSheet } from './source.js';
+export interface SpreadsheetImportStatus {
+    initialized: boolean;
+    isParsingSource: boolean;
+    isLoadingContext: boolean;
+    isParsingRows: boolean;
+    isReady: boolean;
+}
+export interface SpreadsheetImportApi<TSchema> {
+    schema: ComputedRef<TSchema>;
+    workbook: ShallowRef<SpreadsheetWorkbookData | null>;
+    selection: ShallowRef<SpreadsheetWorkbookSelection>;
+    activeSheet: ComputedRef<SpreadsheetWorkbookSheet | null>;
+    headers: ComputedRef<readonly unknown[]>;
+    headerCells: ComputedRef<SpreadsheetHeaderCell[]>;
+    rows: ComputedRef<readonly (readonly unknown[])[]>;
+    parsedRows: ComputedRef<readonly SpreadsheetParsedRow<ExtractSpreadsheetRow<TSchema>>[]>;
+    resolvedRows: ComputedRef<readonly SpreadsheetResolvedReferenceRow<ExtractSpreadsheetRow<TSchema>>[]>;
+    rowData: ComputedRef<readonly ExtractSpreadsheetRow<TSchema>[]>;
+    submitPayloads: ComputedRef<readonly ExtractSpreadsheetSubmitPayload<TSchema>[]>;
+    rowSummary: ShallowRef<SpreadsheetRowSummary>;
+    referenceResolutions: ComputedRef<readonly SpreadsheetReferenceResolution[]>;
+    unresolvedReferenceResolutions: ComputedRef<readonly SpreadsheetReferenceResolution[]>;
+    status: ComputedRef<SpreadsheetImportStatus>;
+    sourceError: ShallowRef<unknown>;
+    contextError: ComputedRef<unknown>;
+    rowError: ShallowRef<unknown>;
+    loadSource: (params: {
+        source: SpreadsheetBinarySource;
+        fileName?: string;
+    }) => void;
+    clearSource: () => void;
+    setSheetName: (sheetName: string) => void;
+    setHeaderRowIndex: (headerRowIndex: number) => void;
+    assignColumn: (params: {
+        headerIndex: number;
+        columnKey: string;
+    }) => void;
+    clearColumnAssignment: (headerIndex: number) => void;
+    selectReference: (params: {
+        referenceField: string;
+        sourceValue: string;
+        selectedValue: unknown;
+        selectedLabel: string;
+    }) => void;
+    clearReference: (params: {
+        referenceField: string;
+        sourceValue: string;
+    }) => void;
+    refresh: () => Promise<void>;
+}

package/dist/runtime/spreadsheet/types/index.d.ts

@@ -0,0 +1,15 @@
+export type * from './shared';
+export type * from './source';
+export type * from './context';
+export type * from './columns';
+export type * from './options';
+export type * from './resolution';
+export type * from './references';
+export type * from './reference-session';
+export type * from './import';
+export type * from './pipeline';
+export type * from './inference';
+export type * from './rows';
+export type * from './schema';
+export type * from './normalized';
+export type * from './validation';

package/dist/runtime/spreadsheet/types/inference.d.ts

@@ -0,0 +1,83 @@
+import type { DeepPartial, DeepPrettify, DeepTransformNestedPaths, PathToObject, UnionToIntersection } from '../../shared/types/utils.js';
+import type { SpreadsheetColumnDefinition, SpreadsheetColumnGroupDefinition, SpreadsheetDynamicCollectionDefinition, SpreadsheetDynamicCollectionItemDefinition, SpreadsheetDynamicOptionGroupsDefinition, SpreadsheetDynamicValueDefinition, SpreadsheetResolvedColumns } from './columns.js';
+import type { SpreadsheetContextDataFromItems, SpreadsheetContextItem } from './context.js';
+import type { InferSpreadsheetOptionValue } from './options.js';
+import type { InferSpreadsheetReferenceValue, SpreadsheetReferenceDefinition } from './references.js';
+import type { SpreadsheetFieldRules, SpreadsheetRule } from './validation.js';
+type IntersectionOrEmpty<TValue> = [TValue] extends [never] ? {} : UnionToIntersection<TValue>;
+type StaticEntriesFromColumns<TColumns> = TColumns extends {
+    static?: (...args: infer _Args) => infer TResult;
+} ? TResult : TColumns extends {
+    static?: infer TResult;
+} ? TResult : readonly [];
+type DynamicEntriesFromColumns<TColumns> = TColumns extends {
+    dynamic?: (...args: infer _Args) => infer TResult;
+} ? TResult : readonly [];
+type FlattenStaticColumns<TEntries> = TEntries extends readonly (infer TEntry)[] ? TEntry extends SpreadsheetColumnGroupDefinition<any, infer TColumns> ? FlattenStaticColumns<TColumns> : TEntry : never;
+type ColumnRulesOutput<TColumn> = TColumn extends {
+    __rulesInput?: infer TRules extends SpreadsheetFieldRules<any>;
+} ? TRules : TColumn extends {
+    __rulesInput?: (...args: infer _Args) => infer TResult;
+} ? TResult : TColumn extends {
+    rules?: (...args: infer _Args) => infer TResult;
+} ? TResult : TColumn extends {
+    rules?: infer TRules extends SpreadsheetFieldRules<any>;
+} ? TRules : readonly [];
+type HasRequiredRule<TRules> = TRules extends readonly SpreadsheetRule<any, any>[] ? Extract<TRules[number], SpreadsheetRule<any, {
+    required: true;
+}>> extends never ? false : true : false;
+type StaticColumnOutput<TColumn> = TColumn extends SpreadsheetColumnDefinition<infer TKey, infer TValue, infer TRequired, infer _TContext, infer _TRules, infer _TSourceValue, infer _TResolve> ? TRequired extends true ? PathToObject<TKey, TValue> : HasRequiredRule<ColumnRulesOutput<TColumn>> extends true ? PathToObject<TKey, TValue> : DeepPartial<PathToObject<TKey, TValue>> : never;
+type StaticRowOutput<TColumns> = DeepPrettify<DeepTransformNestedPaths<IntersectionOrEmpty<StaticColumnOutput<FlattenStaticColumns<StaticEntriesFromColumns<TColumns>>>>>>;
+type ResolveDynamicValue<TValueDefinition extends SpreadsheetDynamicValueDefinition> = TValueDefinition extends {
+    kind: 'text';
+} ? string : TValueDefinition extends {
+    kind: 'number';
+} ? number : TValueDefinition extends {
+    kind: 'date';
+} ? string : TValueDefinition extends {
+    kind: 'boolean';
+} ? boolean : TValueDefinition extends {
+    kind: 'options';
+    mode: infer TMode;
+} ? TMode extends 'multiple' ? TValueDefinition extends {
+    from: readonly (infer TOption)[];
+} ? InferSpreadsheetOptionValue<TOption>[] : never : TValueDefinition extends {
+    from: readonly (infer TOption)[];
+} ? InferSpreadsheetOptionValue<TOption> : never : never;
+type ResolveDynamicItemValue<TItem> = TItem extends SpreadsheetDynamicCollectionItemDefinition<any, infer TValueInput, any, any> ? TValueInput extends (...args: infer _Args) => infer TValueDefinition ? TValueDefinition extends SpreadsheetDynamicValueDefinition ? ResolveDynamicValue<TValueDefinition> : never : TValueInput extends SpreadsheetDynamicValueDefinition ? ResolveDynamicValue<TValueInput> : never : never;
+type CollectionItemOutput<TItem> = TItem extends SpreadsheetDynamicCollectionItemDefinition<infer TId, infer _TValueInput, infer _TSource, infer TBuild> ? [TBuild] extends [unknown] ? ResolveDynamicItemValue<TItem> extends infer TResult ? TResult extends readonly unknown[] ? {
+    id: TId;
+    values: TResult;
+} : {
+    id: TId;
+    value: TResult;
+} : never : TBuild : never;
+type CollectionRecordOutput<TItems> = TItems extends readonly (infer TItem)[] ? IntersectionOrEmpty<TItem extends SpreadsheetDynamicCollectionItemDefinition<infer TId, infer _TValueInput, infer _TSource, infer TBuild> ? [TBuild] extends [unknown] ? PathToObject<TId, ResolveDynamicItemValue<TItem>> : PathToObject<TId, TBuild> : never> : {};
+type DynamicCollectionOutput<TColumn> = TColumn extends SpreadsheetDynamicCollectionDefinition<infer TRootKey, infer TAs, infer TItems, infer _TOutput> ? TItems extends readonly unknown[] ? TAs extends 'array' ? Partial<PathToObject<TRootKey, readonly CollectionItemOutput<TItems[number]>[]>> : Partial<PathToObject<TRootKey, DeepTransformNestedPaths<CollectionRecordOutput<TItems>>>> : never : never;
+type DynamicOptionGroupsOutput<TDynamicColumn> = TDynamicColumn extends SpreadsheetDynamicOptionGroupsDefinition<any, infer TInto, infer TValue> ? Partial<PathToObject<TInto, Record<string, TValue[]>>> : never;
+type DynamicColumnOutput<TDynamicColumn> = DynamicOptionGroupsOutput<TDynamicColumn> | DynamicCollectionOutput<TDynamicColumn>;
+type DynamicRowOutput<TColumns> = DeepPrettify<DeepTransformNestedPaths<DynamicEntriesFromColumns<TColumns> extends readonly (infer TEntry)[] ? IntersectionOrEmpty<DynamicColumnOutput<TEntry>> : {}>>;
+type ResolveSchemaReferences<TSchema> = TSchema extends {
+    references?: (...args: infer _Args) => infer TReferences;
+} ? Exclude<TReferences, undefined> : TSchema extends {
+    references?: infer TReferences;
+} ? Exclude<TReferences, undefined> : readonly [];
+type ReferenceField<TReference> = TReference extends SpreadsheetReferenceDefinition<infer TField, any, any> ? TField : never;
+type ReferenceOutput<TReference> = [ReferenceField<TReference>] extends [never] ? never : DeepPartial<PathToObject<ReferenceField<TReference>, InferSpreadsheetReferenceValue<TReference>>>;
+type ReferenceRowOutput<TReferences> = TReferences extends readonly unknown[] ? DeepPrettify<DeepTransformNestedPaths<IntersectionOrEmpty<ReferenceOutput<TReferences[number]>>>> : {};
+export type SpreadsheetRowData<TColumns, TReferences = readonly []> = DeepPrettify<StaticRowOutput<TColumns> & DynamicRowOutput<TColumns> & ReferenceRowOutput<TReferences>>;
+type SchemaColumns<TSchema> = TSchema extends {
+    __columnsInput?: infer TColumns;
+} ? Exclude<TColumns, undefined> : TSchema extends {
+    columns?: infer TColumns;
+} ? Exclude<TColumns, undefined> : never;
+export type SpreadsheetData<TSchema> = SpreadsheetRowData<SpreadsheetResolvedColumns<SchemaColumns<TSchema>>, ResolveSchemaReferences<TSchema>>;
+export type ExtractSpreadsheetRow<TSchema> = SpreadsheetData<TSchema>;
+export type ExtractSpreadsheetContextData<TSchema> = TSchema extends {
+    context?: infer TContextItems extends readonly SpreadsheetContextItem<string, unknown>[];
+} ? SpreadsheetContextDataFromItems<TContextItems> : {};
+export type ExtractSpreadsheetSubmitPayload<TSchema> = TSchema extends {
+    buildRow?: (...args: infer _Args) => infer TResult;
+} ? [Awaited<TResult>] extends [never] ? SpreadsheetData<TSchema> : Awaited<TResult> : SpreadsheetData<TSchema>;
+export type ExtractSpreadsheetValidationRow<TSchema> = ExtractSpreadsheetSubmitPayload<TSchema>;
+export {};

package/dist/runtime/spreadsheet/types/normalized.d.ts

@@ -0,0 +1,50 @@
+import type { SpreadsheetDynamicBuilder, SpreadsheetResolvedColumns } from './columns.js';
+import type { SpreadsheetContextItem } from './context.js';
+import type { SpreadsheetResolutionDefinition } from './resolution.js';
+type SchemaContextItems<TSchema> = TSchema extends {
+    context?: infer TContextItems extends readonly SpreadsheetContextItem<string, unknown>[];
+} ? TContextItems : readonly [];
+type SchemaColumns<TSchema> = TSchema extends {
+    columns?: infer TColumns;
+} ? TColumns : undefined;
+type SchemaReferences<TSchema> = TSchema extends {
+    references?: (...args: infer _Args) => infer TReferences extends readonly unknown[];
+} ? TReferences : TSchema extends {
+    references?: infer TReferences extends readonly unknown[];
+} ? TReferences : readonly [];
+type SchemaBuildRow<TSchema> = TSchema extends {
+    buildRow?: infer TBuildRow;
+} ? TBuildRow : undefined;
+type SchemaRelations<TSchema> = TSchema extends {
+    relations?: infer TRelations;
+} ? Exclude<TRelations, undefined> extends readonly unknown[] ? Exclude<TRelations, undefined> : readonly [] : readonly [];
+export type SpreadsheetNormalizedStaticColumns<TSchema> = SpreadsheetResolvedColumns<SchemaColumns<TSchema>> extends {
+    static?: infer TStaticColumns extends readonly unknown[];
+} ? TStaticColumns : readonly [];
+export type SpreadsheetNormalizedDynamicColumns<TSchema> = SpreadsheetResolvedColumns<SchemaColumns<TSchema>> extends {
+    dynamic?: (...args: infer _Args) => infer TResult;
+} ? TResult : readonly [];
+export interface SpreadsheetNormalizedColumns<TContext = unknown, TStaticColumns = readonly unknown[], TDynamicColumns = readonly unknown[]> {
+    static: TStaticColumns;
+    dynamic: (params: {
+        context: TContext;
+        dynamic: SpreadsheetDynamicBuilder<TContext>;
+    }) => TDynamicColumns;
+}
+export interface SpreadsheetNormalizedSchema<TContextItems extends readonly SpreadsheetContextItem<string, unknown>[] = readonly SpreadsheetContextItem<string, unknown>[], TColumns = SpreadsheetNormalizedColumns, TReferences extends readonly unknown[] = readonly unknown[], TResolutions extends readonly SpreadsheetResolutionDefinition[] = readonly SpreadsheetResolutionDefinition[], TRelations extends readonly unknown[] = readonly unknown[], TBuildRow = unknown> {
+    importKey: string;
+    file?: import('./schema').SpreadsheetFileDefinition;
+    sheet?: import('./schema').SpreadsheetSheetStepDefinition;
+    header?: import('./schema').SpreadsheetHeaderStepDefinition;
+    matching?: import('./schema').SpreadsheetMatchingStepDefinition;
+    steps?: import('./schema').SpreadsheetStepsDefinition;
+    context: TContextItems;
+    columns: TColumns;
+    references: TReferences;
+    resolutions: TResolutions;
+    relations: TRelations;
+    buildRow?: TBuildRow;
+    review?: import('./schema').SpreadsheetReviewStepDefinition;
+}
+export type NormalizeSpreadsheetSchema<TSchema> = SpreadsheetNormalizedSchema<SchemaContextItems<TSchema>, SpreadsheetNormalizedColumns<import('./inference').ExtractSpreadsheetContextData<TSchema>, SpreadsheetNormalizedStaticColumns<TSchema>, SpreadsheetNormalizedDynamicColumns<TSchema>>, SchemaReferences<TSchema>, readonly SpreadsheetResolutionDefinition[], SchemaRelations<TSchema>, SchemaBuildRow<TSchema>>;
+export {};

package/dist/runtime/spreadsheet/types/options.d.ts

@@ -0,0 +1,15 @@
+import type { LazyTextValue } from '#ui-tools/shared/types/utils';
+export type SpreadsheetPrimitiveOption = string | number | boolean;
+export interface SpreadsheetOptionEntry<TValue = unknown> {
+    label: LazyTextValue;
+    value: TValue;
+}
+export type SpreadsheetOptionItem<TValue = unknown> = SpreadsheetPrimitiveOption | SpreadsheetOptionEntry<TValue>;
+export type InferSpreadsheetOptionValue<TOption> = TOption extends SpreadsheetOptionEntry<infer TValue> ? TValue : TOption extends SpreadsheetPrimitiveOption ? TOption : never;
+type InferSpreadsheetOptionsSourceItem<TSource> = TSource extends readonly (infer TOption)[] ? TOption : TSource extends (...args: infer _Args) => readonly (infer TOption)[] ? TOption : never;
+export type InferSpreadsheetOptionsSourceValue<TSource> = InferSpreadsheetOptionValue<InferSpreadsheetOptionsSourceItem<TSource>>;
+type SpreadsheetOptionsResolverFn<TParams, TOption extends SpreadsheetOptionItem> = {
+    bivarianceHack: (params: TParams) => readonly TOption[];
+}['bivarianceHack'];
+export type SpreadsheetOptionsSource<TParams, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem> = readonly TOption[] | SpreadsheetOptionsResolverFn<TParams, TOption>;
+export {};

package/dist/runtime/spreadsheet/types/pipeline.d.ts

@@ -0,0 +1,7 @@
+import type { MaybePromise } from '../../shared/types/utils.js';
+export interface SpreadsheetPipelineDefinition<TContext = unknown, TRow = unknown> {
+    buildRow?: (params: {
+        context: TContext;
+        row: TRow;
+    }) => MaybePromise<unknown>;
+}

package/dist/runtime/spreadsheet/types/reference-session.d.ts

@@ -0,0 +1,42 @@
+import type { SpreadsheetReferenceDefinition } from './references.js';
+import type { SpreadsheetResolutionDefinition } from './resolution.js';
+import type { SpreadsheetRowIssue } from './rows.js';
+export interface SpreadsheetReferenceCandidate<TValue = unknown, TOption = unknown> {
+    value: TValue;
+    label: string;
+    option: TOption;
+    score: number;
+}
+export interface SpreadsheetReferenceSourceEntry {
+    value: string;
+    rowIndexes: number[];
+}
+export interface SpreadsheetReferenceResolution<TValue = unknown, TOption = unknown> {
+    scope?: SpreadsheetResolutionDefinition['scope'];
+    resolutionField?: string;
+    targetField?: string;
+    referenceField: string;
+    sourceField: string;
+    outputField: string;
+    sourceValue: string;
+    rowIndexes: number[];
+    status: 'matched' | 'unresolved';
+    selectedValue?: TValue;
+    selectedLabel?: string;
+    candidates: SpreadsheetReferenceCandidate<TValue, TOption>[];
+}
+export interface SpreadsheetResolvedReferenceRow<TRow = Record<string, unknown>> {
+    index: number;
+    source: readonly unknown[];
+    data: TRow;
+    issues: SpreadsheetRowIssue[];
+    isValid: boolean;
+}
+export interface SpreadsheetReferenceQueryRequest {
+    scope?: SpreadsheetResolutionDefinition['scope'];
+    resolutionField?: string;
+    targetField?: string;
+    referenceField: string;
+    sourceValue: string;
+    query: ReturnType<NonNullable<SpreadsheetReferenceDefinition['getOptions']>>;
+}