nuxt-ui-tools 1.11.2 → 1.13.0

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

@@ -1,136 +0,0 @@
-import {
-  resolveSpreadsheetColumns,
-  resolveSpreadsheetReferences,
-  createSpreadsheetDynamicBuilder
-} from "../utils/builders/index.js";
-import { isSpreadsheetRecord } from "../utils/object.js";
-function isSpreadsheetColumnGroupDefinition(value) {
-  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "group" && "columns" in value;
-}
-function isSpreadsheetResolvableColumnDefinition(value) {
-  return isSpreadsheetRecord(value) && "kind" in value && value.kind !== "group" && "key" in value && "resolve" in value && Boolean(value.resolve);
-}
-function isSpreadsheetReferenceDefinition(value) {
-  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "select" && "field" in value && "source" in value;
-}
-function collectSpreadsheetResolutionColumns(entries) {
-  const resolvedColumns = [];
-  for (const entry of entries) {
-    if (isSpreadsheetColumnGroupDefinition(entry)) {
-      resolvedColumns.push(...collectSpreadsheetResolutionColumns(entry.columns));
-      continue;
-    }
-    if (isSpreadsheetResolvableColumnDefinition(entry)) {
-      resolvedColumns.push(entry);
-    }
-  }
-  return resolvedColumns;
-}
-function normalizeSpreadsheetResolutionDefinitions(params) {
-  const columnResolutions = collectSpreadsheetResolutionColumns(
-    params.columns
-  ).flatMap((column) => {
-    if (!column.resolve) {
-      return [];
-    }
-    return [
-      {
-        getOptions: column.resolve.getOptions,
-        kind: "select",
-        options: column.resolve.options,
-        rules: column.rules,
-        scope: "column",
-        sourceField: column.key,
-        targetField: column.key
-      }
-    ];
-  });
-  const referenceResolutions = [];
-  for (const entry of params.references) {
-    if (!isSpreadsheetReferenceDefinition(entry)) {
-      continue;
-    }
-    referenceResolutions.push({
-      getOptions: entry.getOptions,
-      kind: "select",
-      options: entry.options,
-      rules: entry.rules,
-      scope: "reference",
-      sourceField: entry.source,
-      targetField: entry.field
-    });
-  }
-  return [...columnResolutions, ...referenceResolutions];
-}
-export function resolveSpreadsheetDynamicColumns(columns, context) {
-  if (!columns?.dynamic) {
-    return [];
-  }
-  return columns.dynamic({
-    context,
-    dynamic: createSpreadsheetDynamicBuilder(context)
-  });
-}
-export function resolveSpreadsheetBuildRow(buildRow) {
-  return buildRow;
-}
-export function normalizeSpreadsheetSchema(schema) {
-  const resolvedColumns = resolveSpreadsheetColumns(schema.columns);
-  const resolvedReferences = resolveSpreadsheetReferences(schema.references);
-  const staticColumns = resolvedColumns?.static ?? [];
-  const references = Array.isArray(resolvedReferences) ? resolvedReferences : [];
-  const steps = normalizeSpreadsheetSteps(schema);
-  return {
-    ...schema,
-    buildRow: resolveSpreadsheetBuildRow(schema.buildRow),
-    columns: {
-      dynamic: resolvedColumns?.dynamic ?? (() => []),
-      static: staticColumns
-    },
-    context: schema.context ?? [],
-    header: steps.structure?.header,
-    matching: steps.matching,
-    references,
-    relations: schema.relations ?? [],
-    resolutions: normalizeSpreadsheetResolutionDefinitions({
-      columns: staticColumns,
-      references
-    }),
-    review: steps.review,
-    sheet: steps.structure?.sheet,
-    steps
-  };
-}
-function normalizeSpreadsheetSteps(schema) {
-  const steps = toRecord(schema.steps);
-  const structure = toRecord(steps.structure);
-  return {
-    matching: {
-      ...toRecord(schema.matching),
-      ...toRecord(steps.matching)
-    },
-    references: toRecord(steps.references),
-    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 isSpreadsheetRecord(value);
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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/inference.d.ts

@@ -1,83 +0,0 @@
-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] ? NonNullable<unknown> : 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> : 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>> : NonNullable<unknown>>>;
-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]>>>> : NonNullable<unknown>;
-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> : NonNullable<unknown>;
-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

@@ -1,50 +0,0 @@
-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/pipeline.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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;
-    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 = SpreadsheetRecord> {
-    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']>>;
-}

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

@@ -1,32 +0,0 @@
-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';
-interface SpreadsheetReferenceSelectBaseConfig<TOption extends SpreadsheetOptionItem> {
-    source: string;
-    options?: SpreadsheetOptionsSource<{
-        context: SpreadsheetRecord;
-    }, 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: SpreadsheetRecord;
-    }, TOption>;
-    getOptions?: SpreadsheetResolutionQueryResolver<SpreadsheetRecord, SpreadsheetRecord, TOption>;
-    rules?: SpreadsheetFieldRulesInput<TValue>;
-    __rulesInput?: TRulesInput;
-}
-export type SpreadsheetReferenceSelectConfig<TRow, TSource extends SpreadsheetReferenceSourcePath<TRow>, TOption extends SpreadsheetOptionItem, TValue = SpreadsheetResolvedSelectionValue<SpreadsheetReferenceValueAtPath<TRow, TSource>, InferSpreadsheetOptionValue<TOption>>, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined> = Omit<SpreadsheetReferenceSelectBaseConfig<TOption>, 'source'> & {
-    source: TSource;
-    rules?: TRulesInput;
-};
-export type SpreadsheetReferenceValue<TSourceValue, TValue> = SpreadsheetResolvedSelectionValue<TSourceValue, TValue>;
-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;
-export {};

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

@@ -1,43 +0,0 @@
-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, 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> = {
-    bivarianceHack: (params: {
-        context: TContext;
-        row: TRow;
-        search: string;
-    }) => SpreadsheetQueryDefinition<readonly TOption[]>;
-}['bivarianceHack'];
-export interface SpreadsheetColumnResolveDefinition<TContext = unknown, TSourceValue = unknown, TOption extends SpreadsheetOptionItem = SpreadsheetOptionItem, TValue = SpreadsheetResolvedSelectionValue<TSourceValue, InferSpreadsheetOptionValue<TOption>>> {
-    options: SpreadsheetOptionsSource<{
-        context: TContext;
-    }, 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 = SpreadsheetRecord, TRow = SpreadsheetRecord, TRulesInput extends SpreadsheetFieldRulesInput<TValue> | undefined = SpreadsheetFieldRulesInput<TValue> | undefined> {
-    kind: 'select';
-    scope: TScope;
-    targetField: TTargetField;
-    sourceField: TSourceField;
-    options?: SpreadsheetOptionsSource<{
-        context: TContext;
-    }, TOption>;
-    getOptions?: SpreadsheetResolutionQueryResolver<TContext, TRow, TOption>;
-    rules?: SpreadsheetFieldRulesInput<TValue>;
-    __rulesInput?: TRulesInput;
-    __sourceValueType?: TSourceValue;
-    __valueType?: TValue;
-}
-export type SpreadsheetReferenceSourcePath<TRow> = SpreadsheetReferencePath<TRow>;
-export type SpreadsheetSchemaContextData<TSchema> = TSchema extends {
-    context?: infer TContextItems extends readonly SpreadsheetContextItem<string, unknown>[];
-} ? SpreadsheetContextDataFromItems<TContextItems> : SpreadsheetRecord;
-export {};

package/dist/runtime/spreadsheet/utils/builders/core.d.ts

@@ -1,17 +0,0 @@
-import type { SpreadsheetColumnBuilder, SpreadsheetColumnsDefinition, SpreadsheetDynamicBuilder, SpreadsheetGroupBuilder, SpreadsheetReferenceBuilder, SpreadsheetReferenceDefinition, SpreadsheetResolvedColumns, SpreadsheetBuildRowDefinition } from '../../types/index.js';
-export declare function createSpreadsheetColumnBuilder<TContext = unknown>(): SpreadsheetColumnBuilder<TContext>;
-export declare function createSpreadsheetGroupBuilder(): SpreadsheetGroupBuilder;
-export declare function createSpreadsheetDynamicBuilder<TContext>(context: TContext): SpreadsheetDynamicBuilder<TContext>;
-export declare function defineSpreadsheetColumns<TContext, const TColumns extends {
-    static?: unknown;
-    dynamic?: unknown;
-}>(columns: TColumns & SpreadsheetColumnsDefinition<TContext>): TColumns;
-export declare function createSpreadsheetReferenceBuilder<_TContext, TRow>(): SpreadsheetReferenceBuilder<TRow>;
-export declare function defineSpreadsheetReference<const TDefinition extends SpreadsheetReferenceDefinition>(definition: TDefinition): TDefinition;
-export declare function defineSpreadsheetReferences<const TReferences extends readonly unknown[]>(references: TReferences): TReferences;
-export declare function defineSpreadsheetBuildRow<TContext, TRow, const TBuildRow extends SpreadsheetBuildRowDefinition<TContext, TRow>>(buildRow: TBuildRow): TBuildRow;
-export declare function resolveSpreadsheetReferences<TReferences>(references: TReferences): TReferences;
-export declare function resolveSpreadsheetReferences<TRow, TReferences>(references: ((reference: SpreadsheetReferenceBuilder<TRow>) => TReferences) | undefined): TReferences | undefined;
-export declare function resolveCollection<TBuilderTuple extends readonly unknown[], TResult>(collection: (...builders: TBuilderTuple) => TResult, ...builders: TBuilderTuple): TResult;
-export declare function resolveCollection<TBuilderTuple extends readonly unknown[], TResult>(collection: TResult, ...builders: TBuilderTuple): TResult;
-export declare function resolveSpreadsheetColumns<TColumns>(columns: TColumns): TColumns extends SpreadsheetColumnsDefinition<any> ? SpreadsheetResolvedColumns<TColumns> : TColumns;