nuxt-ui-tools 0.1.2 → 1.0.0

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

@@ -1,7 +1,7 @@
 import type { NestedPaths } from '../../shared/types/utils.js';
 import type { SpreadsheetContextDataFromItems, SpreadsheetContextItem } from './context.js';
 import type { InferSpreadsheetOptionValue, SpreadsheetOptionItem, SpreadsheetOptionsSource } from './options.js';
-import type { SpreadsheetQueryDefinition } from './shared.js';
+import type { SpreadsheetQueryDefinition, SpreadsheetRecord } from './shared.js';
 import type { SpreadsheetFieldRulesInput } from './validation.js';
 export type SpreadsheetResolvedSelectionValue<TSourceValue, TValue> = NonNullable<TSourceValue> extends readonly unknown[] ? TValue[] : TValue;
 export type SpreadsheetResolutionQueryResolver<TContext, TRow, TOption extends SpreadsheetOptionItem> = {
@@ -15,14 +15,14 @@ export interface SpreadsheetColumnResolveDefinition<TContext = unknown, TSourceV
     options: SpreadsheetOptionsSource<{
         context: TContext;
     }, TOption>;
-    getOptions?: SpreadsheetResolutionQueryResolver<TContext, Record<string, unknown>, TOption>;
+    getOptions?: SpreadsheetResolutionQueryResolver<TContext, SpreadsheetRecord, TOption>;
     __sourceValueType?: TSourceValue;
     __valueType?: TValue;
 }
 export type InferSpreadsheetColumnResolveValue<TResolve> = TResolve extends SpreadsheetColumnResolveDefinition<unknown, unknown, SpreadsheetOptionItem, infer TValue> ? TValue : never;
 type SpreadsheetReferencePath<TRow> = Extract<NestedPaths<TRow>, string>;
 export type SpreadsheetReferenceValueAtPath<TRow, TPath extends string> = TPath extends `${infer TKey}.${infer TRest}` ? TKey extends keyof TRow ? SpreadsheetReferenceValueAtPath<NonNullable<TRow[TKey]>, TRest> : never : TPath extends keyof TRow ? TRow[TPath] : never;
-export interface SpreadsheetResolutionDefinition<TScope extends 'column' | 'reference' = 'column' | 'reference', TTargetField extends string = string, TSourceField extends string = string, TSourceValue = unknown, TValue = unknown, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem, TContext = Record<string, unknown>, TRow = Record<string, unknown>, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined> {
+export interface SpreadsheetResolutionDefinition<TScope extends 'column' | 'reference' = 'column' | 'reference', TTargetField extends string = string, TSourceField extends string = string, TSourceValue = unknown, TValue = unknown, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem, TContext = SpreadsheetRecord, TRow = SpreadsheetRecord, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined> {
     kind: 'select';
     scope: TScope;
     targetField: TTargetField;
@@ -39,5 +39,5 @@ export interface SpreadsheetResolutionDefinition<TScope extends 'column' | 'refe
 export type SpreadsheetReferenceSourcePath<TRow> = SpreadsheetReferencePath<TRow>;
 export type SpreadsheetSchemaContextData<TSchema> = TSchema extends {
     context?: infer TContextItems extends readonly SpreadsheetContextItem<string, unknown>[];
-} ? SpreadsheetContextDataFromItems<TContextItems> : Record<string, unknown>;
+} ? SpreadsheetContextDataFromItems<TContextItems> : SpreadsheetRecord;
 export {};

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

@@ -1,5 +1,5 @@
 import type { SpreadsheetColumnDefinition, SpreadsheetColumnGroupDefinition, SpreadsheetDynamicCollectionDefinition, SpreadsheetDynamicCollectionItemDefinition, SpreadsheetDynamicOptionGroupsDefinition } from './columns.js';
-import type { SpreadsheetIssueLevel } from './shared.js';
+import type { SpreadsheetIssueLevel, SpreadsheetRecord } from './shared.js';
 export interface SpreadsheetHeaderCell {
     index: number;
     raw: unknown;
@@ -40,7 +40,7 @@ export interface SpreadsheetRowIssue {
     columnIndex?: number;
     header?: string;
 }
-export interface SpreadsheetParsedRow<TRow = Record<string, unknown>> {
+export interface SpreadsheetParsedRow<TRow = SpreadsheetRecord> {
     index: number;
     source: readonly unknown[];
     data: TRow;

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

@@ -2,6 +2,7 @@ import type { LazyTextValue, NestedPaths } from '#ui-tools/shared/types/utils';
 import type { SpreadsheetColumnsDefinition, SpreadsheetResolvedColumns } from './columns.js';
 import type { SpreadsheetContextDataFromItems, SpreadsheetContextItem } from './context.js';
 import type { ExtractSpreadsheetValidationRow, SpreadsheetRowData } from './inference.js';
+import type { SpreadsheetValue } from './shared.js';
 import type { SpreadsheetFieldRules, SpreadsheetRuleBuilder } from './validation.js';
 export interface SpreadsheetFileDefinition {
     accept?: readonly string[];
@@ -47,7 +48,7 @@ export type SpreadsheetRelationsDefinition<TRow> = readonly {
 export type SpreadsheetBuildRowDefinition<TContext = unknown, TRow = unknown> = (params: {
     context: TContext;
     row: TRow;
-}) => unknown | Promise<unknown>;
+}) => SpreadsheetValue | Promise<SpreadsheetValue>;
 export interface SpreadsheetSchema<TContextItems extends readonly SpreadsheetContextItem<string, unknown>[] = readonly [], TColumns extends SpreadsheetColumnsDefinition<SpreadsheetContextDataFromItems<TContextItems>> = SpreadsheetColumnsDefinition<SpreadsheetContextDataFromItems<TContextItems>>, TReferences = readonly unknown[], TRelations = SpreadsheetRelationsDefinition<SpreadsheetRowData<SpreadsheetResolvedColumns<TColumns>, TReferences>>, TBuildRow = SpreadsheetBuildRowDefinition<SpreadsheetContextDataFromItems<TContextItems>, SpreadsheetRowData<SpreadsheetResolvedColumns<TColumns>, TReferences>>> {
     importKey: string;
     file?: SpreadsheetFileDefinition;

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

@@ -1,4 +1,11 @@
 import type { QueryFunction, QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import type { GenericObject } from '#ui-tools/shared/types/utils';
+/** Runtime values decoded from spreadsheet cells, rows, and external references. */
+export type SpreadsheetValue = GenericObject[string];
+/** Named row/context contract for spreadsheet data that is decoded at runtime. */
+export type SpreadsheetRecord = {
+    [key: string]: SpreadsheetValue;
+};
 export type SpreadsheetQueryDefinition<TData = unknown> = Omit<UseQueryOptions<TData>, 'queryFn'> & {
     queryKey: QueryKey;
     queryFn?: QueryFunction<TData>;

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

@@ -1,21 +1,21 @@
-import type { SpreadsheetIssueLevel } from './shared.js';
-export type SpreadsheetLazyMessage<TValue, TParams extends unknown[] = [], TMeta extends Record<string, unknown> = {}> = string | (() => string) | ((ctx: SpreadsheetMessageContext<TValue, TParams, TMeta>) => string);
-export type SpreadsheetValidatorResult<TMeta extends Record<string, unknown> = {}> = boolean | ({
+import type { SpreadsheetIssueLevel, SpreadsheetRecord } from './shared.js';
+export type SpreadsheetLazyMessage<TValue, TParams extends unknown[] = [], TMeta extends SpreadsheetRecord = NonNullable<unknown>> = string | (() => string) | ((ctx: SpreadsheetMessageContext<TValue, TParams, TMeta>) => string);
+export type SpreadsheetValidatorResult<TMeta extends SpreadsheetRecord = NonNullable<unknown>> = boolean | ({
     $valid: boolean;
 } & TMeta);
-export type SpreadsheetMessageContext<TValue, TParams extends unknown[] = [], TMeta extends Record<string, unknown> = {}> = {
-    [key: string]: unknown;
+export type SpreadsheetMessageContext<TValue, TParams extends unknown[] = [], TMeta extends SpreadsheetRecord = NonNullable<unknown>> = {
+    [key: string]: SpreadsheetRecord[string];
     $valid?: boolean;
     value: TValue;
     params: TParams;
 } & Partial<TMeta>;
-export interface SpreadsheetRuleOverrides<TValue, TParams extends unknown[] = [], TMeta extends Record<string, unknown> = {}> {
+export interface SpreadsheetRuleOverrides<TValue, TParams extends unknown[] = [], TMeta extends SpreadsheetRecord = NonNullable<unknown>> {
     message?: SpreadsheetLazyMessage<TValue, TParams, TMeta>;
 }
 export interface SpreadsheetRuleFlags {
     required?: true;
 }
-export interface SpreadsheetRuleExecutionResult<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+export interface SpreadsheetRuleExecutionResult<TMeta extends SpreadsheetRecord = SpreadsheetRecord> {
     $valid: boolean;
     $message: string | null;
     $meta: TMeta;
@@ -31,12 +31,12 @@ export interface SpreadsheetRule<TValue, TFlags extends SpreadsheetRuleFlags = S
 }
 export type SpreadsheetFieldRules<TValue> = readonly SpreadsheetRule<TValue, SpreadsheetRuleFlags>[];
 export interface SpreadsheetRuleBuilder {
-    validate: <TValue, TMeta extends Record<string, unknown> = {}>(options: {
+    validate: <TValue, TMeta extends SpreadsheetRecord = NonNullable<unknown>>(options: {
         name?: string;
         validator: (value: TValue) => SpreadsheetValidatorResult<TMeta>;
         message: SpreadsheetLazyMessage<TValue, [], TMeta>;
     }) => SpreadsheetRule<TValue>;
-    required: CreateSpreadsheetRuleReturn<unknown, [], {}, {
+    required: CreateSpreadsheetRuleReturn<unknown, [], NonNullable<unknown>, {
         required: true;
     }>;
     maxLength: CreateSpreadsheetRuleReturn<string, [max: number], {
@@ -45,7 +45,7 @@ export interface SpreadsheetRuleBuilder {
     minLength: CreateSpreadsheetRuleReturn<string, [min: number], {
         min: number;
     }>;
-    number: CreateSpreadsheetRuleReturn<number, [], {}>;
+    number: CreateSpreadsheetRuleReturn<number, [], NonNullable<unknown>>;
     min: CreateSpreadsheetRuleReturn<number, [min: number], {
         min: number;
     }>;
@@ -66,9 +66,9 @@ export interface SpreadsheetRuleBuilder {
     }>) => SpreadsheetRule<SpreadsheetWidenLiteral<TValues[number]>>;
 }
 export type SpreadsheetFieldRulesInput<TValue> = SpreadsheetFieldRules<TValue> | ((rules: SpreadsheetRuleBuilder) => SpreadsheetFieldRules<TValue>);
-export type CreateSpreadsheetRuleReturn<TValue, TParams extends unknown[], TMeta extends Record<string, unknown>, TFlags extends SpreadsheetRuleFlags = {}> = TParams extends [] ? (overrides?: SpreadsheetRuleOverrides<TValue, TParams, TMeta>) => SpreadsheetRule<TValue, TFlags> : (...args: [...TParams, overrides?: SpreadsheetRuleOverrides<TValue, TParams, TMeta>]) => SpreadsheetRule<TValue, TFlags>;
+export type CreateSpreadsheetRuleReturn<TValue, TParams extends unknown[], TMeta extends SpreadsheetRecord, TFlags extends SpreadsheetRuleFlags = NonNullable<unknown>> = TParams extends [] ? (overrides?: SpreadsheetRuleOverrides<TValue, TParams, TMeta>) => SpreadsheetRule<TValue, TFlags> : (...args: [...TParams, overrides?: SpreadsheetRuleOverrides<TValue, TParams, TMeta>]) => SpreadsheetRule<TValue, TFlags>;
 export type SpreadsheetWidenLiteral<TValue> = TValue extends string ? string : TValue extends number ? number : TValue extends boolean ? boolean : TValue;
-export type CreateSpreadsheetRule = <TValue, TParams extends unknown[], TMeta extends Record<string, unknown> = {}, TFlags extends SpreadsheetRuleFlags = {}>(options: {
+export type CreateSpreadsheetRule = <TValue, TParams extends unknown[], TMeta extends SpreadsheetRecord = NonNullable<unknown>, TFlags extends SpreadsheetRuleFlags = NonNullable<unknown>>(options: {
     name?: string;
     flags?: TFlags;
     validator: (value: TValue, ...params: TParams) => SpreadsheetValidatorResult<TMeta>;

package/dist/runtime/spreadsheet/utils/builders/core.js

@@ -1,10 +1,11 @@
+import { isFunction, isObject } from "#ui-tools/shared/utils/predicate";
 import { resolveSpreadsheetRules } from "../validation/index.js";
 export function createSpreadsheetColumnBuilder() {
   const textColumn = (key, options = {}) => {
     const rules = resolveSpreadsheetRules(options.rules);
     return {
-      kind: "text",
       key,
+      kind: "text",
       ...options,
       rules
     };
@@ -12,106 +13,101 @@ export function createSpreadsheetColumnBuilder() {
   const enumColumn = (key, options) => {
     const rules = resolveSpreadsheetRules(options.rules);
     return {
-      kind: "enum",
+      from: options.from,
       key,
+      kind: "enum",
       label: options.label,
-      required: options.required,
       match: options.match,
-      from: options.from,
       multiple: options.multiple,
-      parse: options.parse,
       options: options.options,
+      parse: options.parse,
+      required: options.required,
       rules
     };
   };
   const numberColumn = (key, options = {}) => {
     const rules = resolveSpreadsheetRules(options.rules);
     return {
-      kind: "number",
       key,
+      kind: "number",
       ...options,
       rules
     };
   };
   return {
-    text: textColumn,
-    email(key, options = {}) {
+    boolean(key, options = {}) {
       const rules = resolveSpreadsheetRules(options.rules);
       return {
-        kind: "email",
         key,
+        kind: "boolean",
         ...options,
         rules
       };
     },
-    number: numberColumn,
     date(key, options = {}) {
       const rules = resolveSpreadsheetRules(options.rules);
       return {
-        kind: "date",
         key,
+        kind: "date",
         ...options,
         rules
       };
     },
-    boolean(key, options = {}) {
+    email(key, options = {}) {
       const rules = resolveSpreadsheetRules(options.rules);
       return {
-        kind: "boolean",
         key,
+        kind: "email",
         ...options,
         rules
       };
     },
     enum: enumColumn,
+    number: numberColumn,
     option(key, options) {
       const rules = resolveSpreadsheetRules(options.rules);
       return {
-        kind: "option",
         key,
+        kind: "option",
         ...options,
         rules
       };
-    }
+    },
+    text: textColumn
   };
 }
 export function createSpreadsheetGroupBuilder() {
   return (key, columns) => ({
-    kind: "group",
+    columns,
     key,
-    columns
+    kind: "group"
   });
 }
 function createSpreadsheetDynamicValueBuilder() {
   function options(config) {
-    if (config.mode === "multiple")
+    if (config.mode === "multiple") {
       return {
-        kind: "options",
         from: config.from,
-        mode: "multiple",
-        separator: config.separator,
+        itemModifiers: config.itemModifiers,
+        kind: "options",
         matchBy: config.matchBy,
-        itemModifiers: config.itemModifiers
+        mode: "multiple",
+        separator: config.separator
       };
+    }
     return {
-      kind: "options",
       from: config.from,
-      mode: "single",
-      separator: config.separator,
+      itemModifiers: config.itemModifiers,
+      kind: "options",
       matchBy: config.matchBy,
-      itemModifiers: config.itemModifiers
+      mode: "single",
+      separator: config.separator
     };
   }
   const builder = {
-    text(config = {}) {
-      return {
-        kind: "text",
-        modifiers: config.modifiers
-      };
-    },
-    number() {
+    boolean() {
       return {
-        kind: "number"
+        kind: "boolean"
       };
     },
     date() {
@@ -119,75 +115,82 @@ function createSpreadsheetDynamicValueBuilder() {
         kind: "date"
       };
     },
-    boolean() {
+    number() {
       return {
-        kind: "boolean"
+        kind: "number"
       };
     },
-    options
+    options,
+    text(config = {}) {
+      return {
+        kind: "text",
+        modifiers: config.modifiers
+      };
+    }
   };
   return builder;
 }
 function isSpreadsheetDynamicValueResolver(definition) {
-  return typeof definition === "function";
+  return isFunction(definition);
 }
 function buildSpreadsheetCollectionItems(params) {
   return params.from({ context: params.context }).map((source) => {
     const item = params.each(source);
     return {
       ...item,
-      value: params.resolveValue(item),
-      source
+      source,
+      value: params.resolveValue(item)
     };
   });
 }
 export function createSpreadsheetDynamicBuilder(context) {
   function resolveDynamicCollectionValue(definition) {
-    if (isSpreadsheetDynamicValueResolver(definition))
+    if (isSpreadsheetDynamicValueResolver(definition)) {
       return definition(createSpreadsheetDynamicValueBuilder());
+    }
     return definition;
   }
   return {
-    optionGroups(config) {
-      return {
-        kind: "option-groups",
-        key: config.key,
-        source: config.source,
-        itemKey: config.itemKey,
-        itemLabel: config.itemLabel,
-        targetKey: config.targetKey,
-        header: config.header,
-        options: config.options,
-        values: config.values,
-        output: config.output
-      };
-    },
     arrayFromCollection(rootKey, config) {
       const items = buildSpreadsheetCollectionItems({
         context,
-        from: config.from,
         each: config.each,
+        from: config.from,
         resolveValue: (item) => resolveDynamicCollectionValue(item.value)
       });
       return {
-        kind: "collection",
-        rootKey,
         as: "array",
-        items
+        items,
+        kind: "collection",
+        rootKey
+      };
+    },
+    optionGroups(config) {
+      return {
+        header: config.header,
+        itemKey: config.itemKey,
+        itemLabel: config.itemLabel,
+        key: config.key,
+        kind: "option-groups",
+        options: config.options,
+        output: config.output,
+        source: config.source,
+        targetKey: config.targetKey,
+        values: config.values
       };
     },
     recordFromCollection(rootKey, config) {
       const items = buildSpreadsheetCollectionItems({
         context,
-        from: config.from,
         each: config.each,
+        from: config.from,
         resolveValue: (item) => resolveDynamicCollectionValue(item.value)
       });
       return {
-        kind: "collection",
-        rootKey,
         as: "record",
-        items
+        items,
+        kind: "collection",
+        rootKey
       };
     }
   };
@@ -199,12 +202,12 @@ export function createSpreadsheetReferenceBuilder() {
   const builder = {
     select(field, config) {
       return {
-        kind: "select",
         field,
-        source: config.source,
-        options: config.options,
         getOptions: config.getOptions,
-        rules: resolveSpreadsheetRules(config.rules)
+        kind: "select",
+        options: config.options,
+        rules: resolveSpreadsheetRules(config.rules),
+        source: config.source
       };
     }
   };
@@ -220,24 +223,33 @@ export function defineSpreadsheetBuildRow(buildRow) {
   return buildRow;
 }
 function isSpreadsheetReferenceResolver(references) {
-  return typeof references === "function";
+  return isFunction(references);
 }
 export function resolveSpreadsheetReferences(references) {
-  if (!references) return void 0;
-  if (isSpreadsheetReferenceResolver(references))
+  if (!references) {
+    return;
+  }
+  if (isSpreadsheetReferenceResolver(references)) {
     return references(createSpreadsheetReferenceBuilder());
+  }
   return references;
 }
 function isCollectionResolver(collection) {
-  return typeof collection === "function";
+  return isFunction(collection);
 }
 export function resolveCollection(collection, ...builders) {
-  if (!collection) return void 0;
-  if (isCollectionResolver(collection)) return collection(...builders);
+  if (!collection) {
+    return void 0;
+  }
+  if (isCollectionResolver(collection)) {
+    return collection(...builders);
+  }
   return collection;
 }
 export function resolveSpreadsheetColumns(columns) {
-  if (!columns || typeof columns !== "object") return columns;
+  if (!columns || !isObject(columns)) {
+    return columns;
+  }
   const staticColumns = "static" in columns ? resolveCollection(
     columns.static,
     createSpreadsheetColumnBuilder(),

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

@@ -1,4 +1,4 @@
-import type { SpreadsheetContextItem, SpreadsheetContextDataFromItems } from '../types/index.js';
+import type { SpreadsheetContextItem, SpreadsheetContextDataFromItems, SpreadsheetValue } from '../types/index.js';
 export interface SpreadsheetContextQueryResult {
     key?: string;
     data?: unknown;
@@ -7,14 +7,14 @@ export interface SpreadsheetContextQueryResult {
     isFetching?: boolean;
     isSuccess?: boolean;
     isRefetching?: boolean;
-    refetch: () => Promise<unknown>;
+    refetch: () => Promise<SpreadsheetValue>;
 }
 export declare function createSpreadsheetContextQueries<TItems extends readonly SpreadsheetContextItem<string, unknown>[]>(items: TItems): import("../types/index.js").SpreadsheetQueryDefinition<unknown>[];
 export declare function createSpreadsheetContextData<TItems extends readonly SpreadsheetContextItem<string, unknown>[]>(items: TItems, results: readonly Pick<SpreadsheetContextQueryResult, 'data'>[]): Partial<SpreadsheetContextDataFromItems<TItems>>;
 export declare function createSpreadsheetContextStatus(results: readonly Pick<SpreadsheetContextQueryResult, 'isPending' | 'isFetching' | 'isSuccess' | 'isRefetching'>[]): {
     initialized: boolean;
-    isPending: boolean;
     isFetching: boolean;
+    isPending: boolean;
     isReady: boolean;
     isRefreshing: boolean;
 };

package/dist/runtime/spreadsheet/utils/context.js

@@ -17,8 +17,8 @@ export function createSpreadsheetContextStatus(results) {
   const isRefreshing = results.some((result) => Boolean(result.isRefetching));
   return {
     initialized: true,
-    isPending,
     isFetching,
+    isPending,
     isReady,
     isRefreshing
   };

package/dist/runtime/spreadsheet/utils/display.d.ts

@@ -1,5 +1,6 @@
+import type { SpreadsheetValue } from '../types/index.js';
 export type SpreadsheetDisplayLabel = string | number | (() => string | number) | undefined;
 export declare function resolveSpreadsheetDisplayLabel(value: SpreadsheetDisplayLabel, fallback: string): string;
 export declare function humanizeSpreadsheetKey(value: string): string;
 export declare function snakeCaseSpreadsheetKey(value: string): string;
-export declare function formatSpreadsheetCell(value: unknown): string;
+export declare function formatSpreadsheetCell(value: SpreadsheetValue): string;

package/dist/runtime/spreadsheet/utils/display.js

@@ -1,16 +1,26 @@
+import { isBoolean, isFunction, isNumber, isString } from "#ui-tools/shared/utils/predicate";
+import { isNullish } from "../../shared/utils/predicate.js";
 export function resolveSpreadsheetDisplayLabel(value, fallback) {
-  if (typeof value === "function") return String(value());
-  return value == null ? fallback : String(value);
+  if (isFunction(value)) {
+    return String(value());
+  }
+  return isNullish(value) ? fallback : String(value);
 }
 export function humanizeSpreadsheetKey(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+  return value.replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2").replaceAll(/[_-]+/gu, " ").replaceAll(/\b\w/gu, (char) => char.toUpperCase());
 }
 export function snakeCaseSpreadsheetKey(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+  return value.replaceAll(/([a-z0-9])([A-Z])/gu, "$1_$2").replaceAll(/[\s-]+/gu, "_").toLowerCase();
 }
 export function formatSpreadsheetCell(value) {
-  if (value == null) return "\u2014";
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (isNullish(value)) {
+    return "\u2014";
+  }
+  if (isString(value)) {
+    return value;
+  }
+  if (isNumber(value) || isBoolean(value)) {
+    return String(value);
+  }
   return JSON.stringify(value);
 }

package/dist/runtime/spreadsheet/utils/object.d.ts

@@ -1,8 +1,9 @@
-export declare function isSpreadsheetRecord(value: unknown): value is Record<string, unknown>;
-export declare function getSpreadsheetValueAtPath(data: Record<string, unknown>, path: string): unknown;
-export declare function setSpreadsheetValueAtPath(target: Record<string, unknown>, path: string, value: unknown): void;
-export declare function deleteSpreadsheetValueAtPath(target: Record<string, unknown>, path: string): void;
-export declare function getSpreadsheetObjectEntries(value: unknown): [string, unknown][];
-export declare function getSpreadsheetObjectKeys(value: unknown): string[];
-export declare function getSpreadsheetLeafPaths(value: unknown, prefix?: string): string[];
-export declare function cloneSpreadsheetRowData(data: Record<string, unknown>): Record<string, unknown>;
+import type { SpreadsheetRecord, SpreadsheetValue } from '../types/index.js';
+export declare function isSpreadsheetRecord<T>(value: T): value is T & SpreadsheetRecord;
+export declare function getSpreadsheetValueAtPath(data: SpreadsheetRecord, path: string): SpreadsheetValue | undefined;
+export declare function setSpreadsheetValueAtPath(target: SpreadsheetRecord, path: string, value: SpreadsheetValue): void;
+export declare function deleteSpreadsheetValueAtPath(target: SpreadsheetRecord, path: string): void;
+export declare function getSpreadsheetObjectEntries<T>(value: T): [string, SpreadsheetValue][];
+export declare function getSpreadsheetObjectKeys<T>(value: T): string[];
+export declare function getSpreadsheetLeafPaths<T>(value: T, prefix?: string): string[];
+export declare function cloneSpreadsheetRowData(data: SpreadsheetRecord): SpreadsheetRecord;

package/dist/runtime/spreadsheet/utils/object.js

@@ -1,9 +1,12 @@
+import { isObject } from "#ui-tools/shared/utils/predicate";
 export function isSpreadsheetRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return isObject(value);
 }
 export function getSpreadsheetValueAtPath(data, path) {
   return path.split(".").reduce((current, part) => {
-    if (!isSpreadsheetRecord(current)) return void 0;
+    if (!isSpreadsheetRecord(current)) {
+      return;
+    }
     return current[part];
   }, data);
 }
@@ -30,31 +33,43 @@ export function deleteSpreadsheetValueAtPath(target, path) {
   const parts = path.split(".");
   let current = target;
   for (const [index, part] of parts.entries()) {
-    if (!current) return;
+    if (!current) {
+      return;
+    }
     const isLast = index === parts.length - 1;
     if (isLast) {
       delete current[part];
       return;
     }
     const nextValue = current[part];
-    if (!isSpreadsheetRecord(nextValue)) return;
+    if (!isSpreadsheetRecord(nextValue)) {
+      return;
+    }
     current = nextValue;
   }
 }
 export function getSpreadsheetObjectEntries(value) {
-  if (!isSpreadsheetRecord(value)) return [];
+  if (!isSpreadsheetRecord(value)) {
+    return [];
+  }
   return Object.entries(value);
 }
 export function getSpreadsheetObjectKeys(value) {
   return getSpreadsheetObjectEntries(value).map(([key]) => key);
 }
 export function getSpreadsheetLeafPaths(value, prefix = "") {
-  if (!isSpreadsheetRecord(value)) return prefix ? [prefix] : [];
+  if (!isSpreadsheetRecord(value)) {
+    return prefix ? [prefix] : [];
+  }
   const entries = getSpreadsheetObjectEntries(value);
-  if (!entries.length) return prefix ? [prefix] : [];
+  if (!entries.length) {
+    return prefix ? [prefix] : [];
+  }
   return entries.flatMap(([key, entryValue]) => {
     const nextPath = prefix ? `${prefix}.${key}` : key;
-    if (isSpreadsheetRecord(entryValue)) return getSpreadsheetLeafPaths(entryValue, nextPath);
+    if (isSpreadsheetRecord(entryValue)) {
+      return getSpreadsheetLeafPaths(entryValue, nextPath);
+    }
     return [nextPath];
   });
 }

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

@@ -1,8 +1,10 @@
-export declare function isSpreadsheetPrimitiveOption(value: unknown): value is string | number | boolean;
-export declare function isSpreadsheetOptionEntry(value: unknown): value is {
+import type { SpreadsheetValue } from '../types/index.js';
+export interface SpreadsheetOptionEntry {
     label: string;
-    value: unknown;
-};
-export declare function resolveSpreadsheetOptionEntries<TParams>(source: unknown, params: TParams): any;
-export declare function getSpreadsheetOptionLabel(option: unknown): string;
-export declare function getSpreadsheetOptionValue(option: unknown): unknown;
+    value: SpreadsheetValue;
+}
+export declare function isSpreadsheetPrimitiveOption<T>(value: T): value is T & (string | number | boolean);
+export declare function isSpreadsheetOptionEntry<T>(value: T): value is T & SpreadsheetOptionEntry;
+export declare function resolveSpreadsheetOptionEntries<TParams>(source: SpreadsheetValue, params: TParams): readonly SpreadsheetValue[];
+export declare function getSpreadsheetOptionLabel<T>(option: T): string;
+export declare function getSpreadsheetOptionValue<T>(option: T): SpreadsheetValue | undefined;