nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/spreadsheet/composables/use-spreadsheet-view.js

@@ -4,66 +4,66 @@ export function useSpreadsheetView(params) {
   const activeStep = ref("upload");
   const steps = computed(() => [
     {
-      value: "upload",
-      title: resolveTextValue(
-        params.stepConfig?.()?.upload?.title,
-        params.t("spreadsheet.steps.upload.title")
-      ),
       description: resolveTextValue(
         params.stepConfig?.()?.upload?.description,
         params.t("spreadsheet.steps.upload.description")
       ),
-      icon: "i-lucide-upload"
-    },
-    {
-      value: "structure",
+      icon: "i-lucide-upload",
       title: resolveTextValue(
-        params.stepConfig?.()?.structure?.title,
-        params.t("spreadsheet.steps.structure.title")
+        params.stepConfig?.()?.upload?.title,
+        params.t("spreadsheet.steps.upload.title")
       ),
+      value: "upload"
+    },
+    {
       description: resolveTextValue(
         params.stepConfig?.()?.structure?.description,
         params.t("spreadsheet.steps.structure.description")
       ),
-      icon: "i-lucide-table-properties"
-    },
-    {
-      value: "matching",
+      icon: "i-lucide-table-properties",
       title: resolveTextValue(
-        params.stepConfig?.()?.matching?.title,
-        params.t("spreadsheet.steps.matching.title")
+        params.stepConfig?.()?.structure?.title,
+        params.t("spreadsheet.steps.structure.title")
       ),
+      value: "structure"
+    },
+    {
       description: resolveTextValue(
         params.stepConfig?.()?.matching?.description,
         params.t("spreadsheet.steps.matching.description")
       ),
-      icon: "i-lucide-columns-3"
+      icon: "i-lucide-columns-3",
+      title: resolveTextValue(
+        params.stepConfig?.()?.matching?.title,
+        params.t("spreadsheet.steps.matching.title")
+      ),
+      value: "matching"
     },
     ...params.hasReferences() ? [
       {
-        value: "references",
-        title: resolveTextValue(
-          params.stepConfig?.()?.references?.title,
-          params.t("spreadsheet.steps.references.title")
-        ),
         description: resolveTextValue(
           params.stepConfig?.()?.references?.description,
           params.t("spreadsheet.steps.references.description")
         ),
-        icon: "i-lucide-link-2"
+        icon: "i-lucide-link-2",
+        title: resolveTextValue(
+          params.stepConfig?.()?.references?.title,
+          params.t("spreadsheet.steps.references.title")
+        ),
+        value: "references"
       }
     ] : [],
     {
-      value: "review",
-      title: resolveTextValue(
-        params.stepConfig?.()?.review?.title,
-        params.t("spreadsheet.steps.review.title")
-      ),
       description: resolveTextValue(
         params.stepConfig?.()?.review?.description,
         params.t("spreadsheet.steps.review.description")
       ),
-      icon: "i-lucide-clipboard-check"
+      icon: "i-lucide-clipboard-check",
+      title: resolveTextValue(
+        params.stepConfig?.()?.review?.title,
+        params.t("spreadsheet.steps.review.title")
+      ),
+      value: "review"
     }
   ]);
   const activeStepIndex = computed(
@@ -74,17 +74,23 @@ export function useSpreadsheetView(params) {
     () => activeStepIndex.value >= 0 && activeStepIndex.value < steps.value.length - 1
   );
   function goToNextStep() {
-    if (!canGoNext.value) return;
+    if (!canGoNext.value) {
+      return;
+    }
     activeStep.value = steps.value[activeStepIndex.value + 1]?.value ?? activeStep.value;
   }
   function goToPrevStep() {
-    if (!canGoPrev.value) return;
+    if (!canGoPrev.value) {
+      return;
+    }
     activeStep.value = steps.value[activeStepIndex.value - 1]?.value ?? activeStep.value;
   }
   watch(
     steps,
     (nextSteps) => {
-      if (nextSteps.some((step) => step.value === activeStep.value)) return;
+      if (nextSteps.some((step) => step.value === activeStep.value)) {
+        return;
+      }
       activeStep.value = nextSteps[0]?.value ?? "upload";
     },
     {
@@ -92,12 +98,12 @@ export function useSpreadsheetView(params) {
     }
   );
   return {
-    steps,
     activeStep,
     activeStepIndex,
-    canGoPrev,
     canGoNext,
+    canGoPrev,
     goToNextStep,
-    goToPrevStep
+    goToPrevStep,
+    steps
   };
 }

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

@@ -4,7 +4,7 @@ type SpreadsheetResolvedColumnsInput<TColumns> = [TColumns] extends [
 ] ? SpreadsheetResolvedColumns<TColumns> : undefined;
 type SpreadsheetExtractedReference<TValue> = Extract<TValue, import('../types').SpreadsheetReferenceDefinition<any, any, any>>;
 type SpreadsheetResolvedReferences<TReferences> = TReferences extends (...args: infer _Args) => infer TResult ? TResult extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TResult[number]>[] : readonly [] : TReferences extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TReferences[number]>[] : readonly [];
-type SpreadsheetSchemaDefinition<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = {
+interface SpreadsheetSchemaDefinition<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> {
     importKey: TImportKey;
     file?: SpreadsheetFileDefinition;
     sheet?: SpreadsheetSheetStepDefinition;
@@ -16,7 +16,7 @@ type SpreadsheetSchemaDefinition<TImportKey extends string, TContextItems extend
     columns?: TColumns;
     references?: TReferences;
     buildRow?: TBuildRow;
-};
+}
 type SpreadsheetBuildRowInput<TContext, TRow, TResult> = (params: {
     context: TContext;
     row: TRow;

package/dist/runtime/spreadsheet/schema/index.js

@@ -11,7 +11,9 @@ function withSpreadsheetRefine(schema) {
   };
 }
 export function defineSpreadsheetSchema(schema) {
-  if (!schema.columns) return withSpreadsheetRefine(schema);
+  if (!schema.columns) {
+    return withSpreadsheetRefine(schema);
+  }
   return withSpreadsheetRefine({
     ...schema,
     columns: resolveSpreadsheetColumns(schema.columns)

package/dist/runtime/spreadsheet/schema/normalize.d.ts

@@ -1,4 +1,5 @@
-import type { NormalizeSpreadsheetSchema, SpreadsheetResolutionDefinition, SpreadsheetColumnsDefinition, SpreadsheetContextItem, SpreadsheetDynamicBuilder } from '../types/index.js';
+import type { SpreadsheetResolutionDefinition, SpreadsheetColumnsDefinition, SpreadsheetContextItem, SpreadsheetDynamicBuilder, SpreadsheetRecord } from '../types/index.js';
+export { type NormalizeSpreadsheetSchema } from '../types/index.js';
 export declare function resolveSpreadsheetDynamicColumns<TContext, TResult extends readonly unknown[]>(columns: {
     dynamic: (params: {
         dynamic: SpreadsheetDynamicBuilder<TContext>;
@@ -27,47 +28,46 @@ export declare function normalizeSpreadsheetSchema<TSchema extends {
     relations?: readonly unknown[];
     buildRow?: unknown;
 }>(schema: TSchema): TSchema & {
-    sheet: {
-        [x: string]: unknown;
+    buildRow: unknown;
+    columns: {
+        dynamic: (params: {
+            dynamic: SpreadsheetDynamicBuilder<any>;
+            context: any;
+        }) => readonly unknown[];
+        static: readonly unknown[];
     };
+    context: readonly SpreadsheetContextItem<string, unknown>[];
     header: {
         [x: string]: unknown;
     };
     matching: {
         [x: string]: unknown;
     };
+    references: any[];
+    relations: readonly unknown[];
+    resolutions: readonly SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, SpreadsheetRecord, SpreadsheetRecord, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[];
     review: {
         [x: string]: unknown;
     };
+    sheet: {
+        [x: string]: unknown;
+    };
     steps: {
-        upload: Record<string, unknown>;
-        structure: {
-            sheet: {
-                [x: string]: unknown;
-            };
-            header: {
-                [x: string]: unknown;
-            };
-        };
         matching: {
             [x: string]: unknown;
         };
-        references: Record<string, unknown>;
+        references: SpreadsheetRecord;
         review: {
             [x: string]: unknown;
         };
+        structure: {
+            header: {
+                [x: string]: unknown;
+            };
+            sheet: {
+                [x: string]: unknown;
+            };
+        };
+        upload: SpreadsheetRecord;
     };
-    context: readonly SpreadsheetContextItem<string, unknown>[];
-    columns: {
-        static: readonly unknown[];
-        dynamic: (params: {
-            dynamic: SpreadsheetDynamicBuilder<any>;
-            context: any;
-        }) => readonly unknown[];
-    };
-    references: any[];
-    resolutions: readonly SpreadsheetResolutionDefinition<"reference" | "column", string, string, unknown, unknown, import("../types/index.js").SpreadsheetOptionItem, Record<string, unknown>, Record<string, unknown>, import("../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>[];
-    relations: readonly unknown[];
-    buildRow: unknown;
 };
-export type { NormalizeSpreadsheetSchema };

package/dist/runtime/spreadsheet/schema/normalize.js

@@ -3,14 +3,15 @@ import {
   resolveSpreadsheetReferences,
   createSpreadsheetDynamicBuilder
 } from "../utils/builders/index.js";
+import { isSpreadsheetRecord } from "../utils/object.js";
 function isSpreadsheetColumnGroupDefinition(value) {
-  return value !== null && typeof value === "object" && "kind" in value && value.kind === "group" && "columns" in value;
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "group" && "columns" in value;
 }
 function isSpreadsheetResolvableColumnDefinition(value) {
-  return value !== null && typeof value === "object" && "kind" in value && value.kind !== "group" && "key" in value && "resolve" in value && Boolean(value.resolve);
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind !== "group" && "key" in value && "resolve" in value && Boolean(value.resolve);
 }
 function isSpreadsheetReferenceDefinition(value) {
-  return value !== null && typeof value === "object" && "kind" in value && value.kind === "select" && "field" in value && "source" in value;
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "select" && "field" in value && "source" in value;
 }
 function collectSpreadsheetResolutionColumns(entries) {
   const resolvedColumns = [];
@@ -19,7 +20,9 @@ function collectSpreadsheetResolutionColumns(entries) {
       resolvedColumns.push(...collectSpreadsheetResolutionColumns(entry.columns));
       continue;
     }
-    if (isSpreadsheetResolvableColumnDefinition(entry)) resolvedColumns.push(entry);
+    if (isSpreadsheetResolvableColumnDefinition(entry)) {
+      resolvedColumns.push(entry);
+    }
   }
   return resolvedColumns;
 }
@@ -27,36 +30,42 @@ function normalizeSpreadsheetResolutionDefinitions(params) {
   const columnResolutions = collectSpreadsheetResolutionColumns(
     params.columns
   ).flatMap((column) => {
-    if (!column.resolve) return [];
+    if (!column.resolve) {
+      return [];
+    }
     return [
       {
+        getOptions: column.resolve.getOptions,
         kind: "select",
+        options: column.resolve.options,
+        rules: column.rules,
         scope: "column",
-        targetField: column.key,
         sourceField: column.key,
-        options: column.resolve.options,
-        getOptions: column.resolve.getOptions,
-        rules: column.rules
+        targetField: column.key
       }
     ];
   });
   const referenceResolutions = [];
   for (const entry of params.references) {
-    if (!isSpreadsheetReferenceDefinition(entry)) continue;
+    if (!isSpreadsheetReferenceDefinition(entry)) {
+      continue;
+    }
     referenceResolutions.push({
+      getOptions: entry.getOptions,
       kind: "select",
+      options: entry.options,
+      rules: entry.rules,
       scope: "reference",
-      targetField: entry.field,
       sourceField: entry.source,
-      options: entry.options,
-      getOptions: entry.getOptions,
-      rules: entry.rules
+      targetField: entry.field
     });
   }
   return [...columnResolutions, ...referenceResolutions];
 }
 export function resolveSpreadsheetDynamicColumns(columns, context) {
-  if (!columns?.dynamic) return [];
+  if (!columns?.dynamic) {
+    return [];
+  }
   return columns.dynamic({
     context,
     dynamic: createSpreadsheetDynamicBuilder(context)
@@ -73,41 +82,29 @@ export function normalizeSpreadsheetSchema(schema) {
   const steps = normalizeSpreadsheetSteps(schema);
   return {
     ...schema,
-    sheet: steps.structure?.sheet,
-    header: steps.structure?.header,
-    matching: steps.matching,
-    review: steps.review,
-    steps,
-    context: schema.context ?? [],
+    buildRow: resolveSpreadsheetBuildRow(schema.buildRow),
     columns: {
-      static: staticColumns,
-      dynamic: resolvedColumns?.dynamic ?? (() => [])
+      dynamic: resolvedColumns?.dynamic ?? (() => []),
+      static: staticColumns
     },
+    context: schema.context ?? [],
+    header: steps.structure?.header,
+    matching: steps.matching,
     references,
+    relations: schema.relations ?? [],
     resolutions: normalizeSpreadsheetResolutionDefinitions({
       columns: staticColumns,
       references
     }),
-    relations: schema.relations ?? [],
-    buildRow: resolveSpreadsheetBuildRow(schema.buildRow)
+    review: steps.review,
+    sheet: steps.structure?.sheet,
+    steps
   };
 }
 function normalizeSpreadsheetSteps(schema) {
   const steps = toRecord(schema.steps);
   const structure = toRecord(steps.structure);
   return {
-    upload: toRecord(steps.upload),
-    structure: {
-      ...structure,
-      sheet: {
-        ...toRecord(schema.sheet),
-        ...toRecord(structure.sheet)
-      },
-      header: {
-        ...toRecord(schema.header),
-        ...toRecord(structure.header)
-      }
-    },
     matching: {
       ...toRecord(schema.matching),
       ...toRecord(steps.matching)
@@ -116,12 +113,24 @@ function normalizeSpreadsheetSteps(schema) {
     review: {
       ...toRecord(schema.review),
       ...toRecord(steps.review)
-    }
+    },
+    structure: {
+      ...structure,
+      header: {
+        ...toRecord(schema.header),
+        ...toRecord(structure.header)
+      },
+      sheet: {
+        ...toRecord(schema.sheet),
+        ...toRecord(structure.sheet)
+      }
+    },
+    upload: toRecord(steps.upload)
   };
 }
 function toRecord(value) {
   return isRecord(value) ? value : {};
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object";
+  return isSpreadsheetRecord(value);
 }

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

@@ -1,7 +1,7 @@
 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 { SpreadsheetCellValue, SpreadsheetMatchDefinition, SpreadsheetModifier, SpreadsheetValue } 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';
@@ -64,11 +64,9 @@ export type SpreadsheetOptionColumnOptions<TContext, TOption extends Spreadsheet
         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 type 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;
@@ -83,14 +81,12 @@ export interface SpreadsheetResolvableScalarColumnBuilder<TContext = unknown, TD
         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 type 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>;
@@ -103,9 +99,7 @@ export interface SpreadsheetColumnBuilder<TContext = unknown> {
     }) => 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>;
-}
+export type 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;
@@ -141,12 +135,12 @@ type SpreadsheetDynamicDefaultArrayItem<TId extends string, TValueDefinition ext
     value: TResult;
 } : never;
 type SpreadsheetDynamicDefaultRecordValue<TValueDefinition extends SpreadsheetDynamicValueDefinition> = SpreadsheetDynamicResolvedValue<TValueDefinition>;
-type SpreadsheetDynamicBuildParams<TSource, TId extends string, TValueDefinition extends SpreadsheetDynamicValueDefinition> = {
+interface 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[];
@@ -162,14 +156,14 @@ export interface SpreadsheetDynamicValueBuilder {
         itemModifiers?: readonly SpreadsheetModifier[];
     }): SpreadsheetDynamicOptionsValueDefinition<TOption, TMode>;
 }
-type SpreadsheetDynamicValueInput = SpreadsheetDynamicValueDefinition | ((value: SpreadsheetDynamicValueBuilder) => unknown);
+type SpreadsheetDynamicValueInput = SpreadsheetDynamicValueDefinition | ((value: SpreadsheetDynamicValueBuilder) => SpreadsheetValue);
 type ResolveSpreadsheetDynamicValueInput<TValueInput> = TValueInput extends (...args: infer _Args) => infer TValueDefinition ? TValueDefinition extends SpreadsheetDynamicValueDefinition ? TValueDefinition : never : TValueInput extends SpreadsheetDynamicValueDefinition ? TValueInput : never;
-type SpreadsheetDynamicCollectionItemShape<TSource = unknown> = {
+interface SpreadsheetDynamicCollectionItemContract<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;
@@ -262,7 +256,7 @@ export interface SpreadsheetDynamicBuilder<TContext = unknown> {
             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: {
+    arrayFromCollection: <TRootKey extends string, TSource extends readonly unknown[], TItem extends SpreadsheetDynamicCollectionItemContract<TSource[number]>>(rootKey: TRootKey, config: {
         from: SpreadsheetDynamicCollectionCallback<{
             context: TContext;
         }, TSource>;
@@ -272,7 +266,7 @@ export interface SpreadsheetDynamicBuilder<TContext = unknown> {
         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: {
+    recordFromCollection: <TRootKey extends string, TSource extends readonly unknown[], TItem extends SpreadsheetDynamicCollectionItemContract<TSource[number]>>(rootKey: TRootKey, config: {
         from: SpreadsheetDynamicCollectionCallback<{
             context: TContext;
         }, TSource>;

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

@@ -4,7 +4,7 @@ import type { SpreadsheetContextDataFromItems, SpreadsheetContextItem } from './
 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 IntersectionOrEmpty<TValue> = [TValue] extends [never] ? NonNullable<unknown> : UnionToIntersection<TValue>;
 type StaticEntriesFromColumns<TColumns> = TColumns extends {
     static?: (...args: infer _Args) => infer TResult;
 } ? TResult : TColumns extends {
@@ -52,11 +52,11 @@ type CollectionItemOutput<TItem> = TItem extends SpreadsheetDynamicCollectionIte
     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 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> : NonNullable<unknown>;
 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 DynamicRowOutput<TColumns> = DeepPrettify<DeepTransformNestedPaths<DynamicEntriesFromColumns<TColumns> extends readonly (infer TEntry)[] ? IntersectionOrEmpty<DynamicColumnOutput<TEntry>> : NonNullable<unknown>>>;
 type ResolveSchemaReferences<TSchema> = TSchema extends {
     references?: (...args: infer _Args) => infer TReferences;
 } ? Exclude<TReferences, undefined> : TSchema extends {
@@ -64,7 +64,7 @@ type ResolveSchemaReferences<TSchema> = TSchema extends {
 } ? 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]>>>> : {};
+type ReferenceRowOutput<TReferences> = TReferences extends readonly unknown[] ? DeepPrettify<DeepTransformNestedPaths<IntersectionOrEmpty<ReferenceOutput<TReferences[number]>>>> : NonNullable<unknown>;
 export type SpreadsheetRowData<TColumns, TReferences = readonly []> = DeepPrettify<StaticRowOutput<TColumns> & DynamicRowOutput<TColumns> & ReferenceRowOutput<TReferences>>;
 type SchemaColumns<TSchema> = TSchema extends {
     __columnsInput?: infer TColumns;
@@ -75,7 +75,7 @@ export type SpreadsheetData<TSchema> = SpreadsheetRowData<SpreadsheetResolvedCol
 export type ExtractSpreadsheetRow<TSchema> = SpreadsheetData<TSchema>;
 export type ExtractSpreadsheetContextData<TSchema> = TSchema extends {
     context?: infer TContextItems extends readonly SpreadsheetContextItem<string, unknown>[];
-} ? SpreadsheetContextDataFromItems<TContextItems> : {};
+} ? SpreadsheetContextDataFromItems<TContextItems> : NonNullable<unknown>;
 export type ExtractSpreadsheetSubmitPayload<TSchema> = TSchema extends {
     buildRow?: (...args: infer _Args) => infer TResult;
 } ? [Awaited<TResult>] extends [never] ? SpreadsheetData<TSchema> : Awaited<TResult> : SpreadsheetData<TSchema>;

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

@@ -1,6 +1,7 @@
 import type { SpreadsheetReferenceDefinition } from './references.js';
 import type { SpreadsheetResolutionDefinition } from './resolution.js';
 import type { SpreadsheetRowIssue } from './rows.js';
+import type { SpreadsheetRecord } from './shared.js';
 export interface SpreadsheetReferenceCandidate<TValue = unknown, TOption = unknown> {
     value: TValue;
     label: string;
@@ -25,7 +26,7 @@ export interface SpreadsheetReferenceResolution<TValue = unknown, TOption = unkn
     selectedLabel?: string;
     candidates: SpreadsheetReferenceCandidate<TValue, TOption>[];
 }
-export interface SpreadsheetResolvedReferenceRow<TRow = Record<string, unknown>> {
+export interface SpreadsheetResolvedReferenceRow<TRow = SpreadsheetRecord> {
     index: number;
     source: readonly unknown[];
     data: TRow;

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

@@ -1,21 +1,22 @@
 import type { InferSpreadsheetOptionValue, SpreadsheetOptionItem, SpreadsheetOptionsSource } from './options.js';
 import type { SpreadsheetReferenceSourcePath, SpreadsheetReferenceValueAtPath, SpreadsheetResolutionQueryResolver, SpreadsheetResolvedSelectionValue } from './resolution.js';
+import type { SpreadsheetRecord } from './shared.js';
 import type { SpreadsheetFieldRulesInput } from './validation.js';
-type SpreadsheetReferenceSelectBaseConfig<TOption extends SpreadsheetOptionItem> = {
+interface SpreadsheetReferenceSelectBaseConfig<TOption extends SpreadsheetOptionItem> {
     source: string;
     options?: SpreadsheetOptionsSource<{
-        context: Record<string, unknown>;
+        context: SpreadsheetRecord;
     }, TOption>;
-    getOptions?: SpreadsheetResolutionQueryResolver<Record<string, unknown>, Record<string, unknown>, TOption>;
-};
+    getOptions?: SpreadsheetResolutionQueryResolver<SpreadsheetRecord, SpreadsheetRecord, TOption>;
+}
 export interface SpreadsheetReferenceDefinition<TField extends string = string, TValue = unknown, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem, TSource extends string = string, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined> {
     kind: 'select';
     field: TField;
     source: TSource;
     options?: SpreadsheetOptionsSource<{
-        context: Record<string, unknown>;
+        context: SpreadsheetRecord;
     }, TOption>;
-    getOptions?: SpreadsheetResolutionQueryResolver<Record<string, unknown>, Record<string, unknown>, TOption>;
+    getOptions?: SpreadsheetResolutionQueryResolver<SpreadsheetRecord, SpreadsheetRecord, TOption>;
     rules?: SpreadsheetFieldRulesInput<TValue>;
     __rulesInput?: TRulesInput;
 }
@@ -24,7 +25,7 @@ export type SpreadsheetReferenceSelectConfig<TRow, TSource extends SpreadsheetRe
     rules?: TRulesInput;
 };
 export type SpreadsheetReferenceValue<TSourceValue, TValue> = SpreadsheetResolvedSelectionValue<TSourceValue, TValue>;
-export interface SpreadsheetReferenceBuilder<TRow = Record<string, unknown>> {
+export interface SpreadsheetReferenceBuilder<TRow = SpreadsheetRecord> {
     select: <TField extends string, TSource extends SpreadsheetReferenceSourcePath<TRow>, const TOption extends SpreadsheetOptionItem, TValue = SpreadsheetReferenceValue<SpreadsheetReferenceValueAtPath<TRow, TSource>, InferSpreadsheetOptionValue<TOption>>, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined>(field: TField, config: SpreadsheetReferenceSelectConfig<TRow, TSource, TOption, TValue, TRulesInput>) => SpreadsheetReferenceDefinition<TField, TValue, TOption, TSource, TRulesInput>;
 }
 export type InferSpreadsheetReferenceValue<TReference> = TReference extends SpreadsheetReferenceDefinition<string, infer TValue, SpreadsheetOptionItem> ? TValue : never;