nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/spreadsheet/components/steps/{SpreadsheetImportReferencesStep.vue → spreadsheet-import-references-step.vue}

@@ -5,8 +5,8 @@ import {
   resolveSpreadsheetDisplayLabel,
   snakeCaseSpreadsheetKey
 } from "../../utils/display";
-import SpreadsheetReferencesAccordion from "./references/SpreadsheetReferencesAccordion.vue";
-import SpreadsheetReferencesSummary from "./references/SpreadsheetReferencesSummary.vue";
+import SpreadsheetReferencesAccordion from "./references/spreadsheet-references-accordion.vue";
+import SpreadsheetReferencesSummary from "./references/spreadsheet-references-summary.vue";
 const props = defineProps({
   spreadsheet: { type: Object, required: true }
 });
@@ -16,18 +16,21 @@ function getSourceLabel(sourceField) {
   const staticColumn = internals.rows.staticColumns.value.find(
     (column) => column.key === sourceField
   );
-  if (staticColumn)
+  if (staticColumn) {
     return resolveSpreadsheetDisplayLabel(
       staticColumn.label,
       humanizeSpreadsheetKey(staticColumn.key)
     );
+  }
   return humanizeSpreadsheetKey(sourceField);
 }
 function getOutputLabel(outputField) {
   return snakeCaseSpreadsheetKey(outputField);
 }
 function getBestScore(candidates) {
-  if (!candidates.length) return null;
+  if (!candidates.length) {
+    return null;
+  }
   return Math.round(Math.max(...candidates.map((candidate) => candidate.score)) * 100);
 }
 function getRowCountLabel(count) {
@@ -35,30 +38,30 @@ function getRowCountLabel(count) {
 }
 function getSelectItems(resolution) {
   const recommendedOptions = resolution.candidates.filter((candidate) => candidate.score > 0).map((candidate) => ({
+    description: `${Math.round(candidate.score * 100)}% match`,
     kind: "option",
-    value: candidate.value,
     label: candidate.label,
-    description: `${Math.round(candidate.score * 100)}% match`
+    value: candidate.value
   }));
   const remainingOptions = resolution.candidates.filter((candidate) => candidate.score <= 0).map((candidate) => ({
     kind: "option",
-    value: candidate.value,
-    label: candidate.label
+    label: candidate.label,
+    value: candidate.value
   }));
   return [
     ...recommendedOptions,
     ...recommendedOptions.length && remainingOptions.length ? [
       {
+        disabled: true,
         kind: "divider",
-        label: "Other options",
-        disabled: true
+        label: "Other options"
       }
     ] : [],
     ...recommendedOptions.length ? remainingOptions : resolution.candidates.map((candidate) => ({
+      description: candidate.score > 0 ? `${Math.round(candidate.score * 100)}% match` : void 0,
       kind: "option",
-      value: candidate.value,
       label: candidate.label,
-      description: candidate.score > 0 ? `${Math.round(candidate.score * 100)}% match` : void 0
+      value: candidate.value
     }))
   ];
 }
@@ -68,50 +71,50 @@ const groupedColumns = computed(() => {
     const group = groups.get(resolution.referenceField) ?? [];
     groups.set(resolution.referenceField, [...group, resolution]);
   }
-  return Array.from(groups.entries()).map(([referenceField, items]) => {
+  return [...groups.entries()].map(([referenceField, items]) => {
     const sourceField = items[0]?.sourceField ?? referenceField;
     const outputField = items[0]?.outputField ?? referenceField;
     const resolvedCount = items.filter((item) => item.status === "matched").length;
     const unresolvedCount = items.length - resolvedCount;
     return {
-      resolutionKey: referenceField,
-      sourceField,
+      items,
       outputField,
-      sourceLabel: getSourceLabel(sourceField),
       outputLabel: getOutputLabel(outputField),
-      resolvedCount,
-      unresolvedCount,
       progressWidth: `${Math.max(0, Math.min(100, items.length ? resolvedCount / items.length * 100 : 0))}%`,
-      items
+      resolutionKey: referenceField,
+      resolvedCount,
+      sourceField,
+      sourceLabel: getSourceLabel(sourceField),
+      unresolvedCount
     };
   });
 });
 const summaryItems = computed(() => [
   {
+    barClass: "bg-muted",
     key: "groups",
     label: "Columns to reconcile",
-    value: groupedColumns.value.length,
-    barClass: "bg-muted"
+    value: groupedColumns.value.length
   },
   {
+    barClass: "bg-success",
     key: "resolved",
     label: "Values resolved",
     value: props.spreadsheet.referenceResolutions.value.filter(
       (resolution) => resolution.status === "matched"
-    ).length,
-    barClass: "bg-success"
+    ).length
   },
   {
+    barClass: "bg-warning",
     key: "unresolved",
     label: "Values to resolve",
-    value: props.spreadsheet.unresolvedReferenceResolutions.value.length,
-    barClass: "bg-warning"
+    value: props.spreadsheet.unresolvedReferenceResolutions.value.length
   },
   {
+    barClass: "bg-muted",
     key: "rows",
     label: "Total rows",
-    value: props.spreadsheet.rowSummary.value.totalRows,
-    barClass: "bg-muted"
+    value: props.spreadsheet.rowSummary.value.totalRows
   }
 ]);
 const unresolvedGroupKeys = computed(
@@ -119,11 +122,14 @@ const unresolvedGroupKeys = computed(
 );
 function getNextExpandableKey(currentKey) {
   const currentIndex = groupedColumns.value.findIndex((group) => group.resolutionKey === currentKey);
-  if (currentIndex < 0)
+  if (currentIndex === -1) {
     return unresolvedGroupKeys.value[0] ?? groupedColumns.value[0]?.resolutionKey;
+  }
   for (let index = currentIndex + 1; index < groupedColumns.value.length; index += 1) {
     const nextGroup = groupedColumns.value[index];
-    if (nextGroup?.unresolvedCount) return nextGroup.resolutionKey;
+    if (nextGroup?.unresolvedCount) {
+      return nextGroup.resolutionKey;
+    }
   }
   return unresolvedGroupKeys.value[0] ?? currentKey;
 }
@@ -148,8 +154,12 @@ watch(
     const previousGroup = previousGroups?.find(
       (group) => group.resolutionKey === expandedResolutionKey.value
     );
-    if (!previousGroup) return;
-    if (!previousGroup.unresolvedCount || currentGroup.unresolvedCount) return;
+    if (!previousGroup) {
+      return;
+    }
+    if (!previousGroup.unresolvedCount || currentGroup.unresolvedCount) {
+      return;
+    }
     expandedResolutionKey.value = getNextExpandableKey(currentGroup.resolutionKey);
   },
   {
@@ -157,26 +167,38 @@ watch(
   }
 );
 function getMetaTone(resolution) {
-  if (resolution.status === "matched") return null;
+  if (resolution.status === "matched") {
+    return null;
+  }
   const bestScore = getBestScore(resolution.candidates);
-  if (bestScore === null) return { label: "No options available", class: "text-error" };
-  if (bestScore === 0) return null;
-  return { label: `Best match: ${bestScore}%`, class: "text-warning" };
+  if (bestScore === null) {
+    return { class: "text-error", label: "No options available" };
+  }
+  if (bestScore === 0) {
+    return null;
+  }
+  return { class: "text-warning", label: `Best match: ${bestScore}%` };
 }
 function getResolutionBadge(resolution) {
-  if (resolution.status === "matched") return { label: "Resolved", color: "success" };
+  if (resolution.status === "matched") {
+    return { color: "success", label: "Resolved" };
+  }
   const bestScore = getBestScore(resolution.candidates);
-  if (bestScore === null) return { label: "No options", color: "error" };
-  return { label: "Needs review", color: "warning" };
+  if (bestScore === null) {
+    return { color: "error", label: "No options" };
+  }
+  return { color: "warning", label: "Needs review" };
 }
 function handleSelect(resolution, value) {
   const candidate = resolution.candidates.find((entry) => entry.value === value);
-  if (!candidate) return;
+  if (!candidate) {
+    return;
+  }
   props.spreadsheet.selectReference({
     referenceField: resolution.referenceField,
-    sourceValue: resolution.sourceValue,
+    selectedLabel: candidate.label,
     selectedValue: candidate.value,
-    selectedLabel: candidate.label
+    sourceValue: resolution.sourceValue
   });
 }
 </script>

package/dist/runtime/spreadsheet/components/steps/{SpreadsheetImportReviewStep.vue → spreadsheet-import-review-step.vue}

@@ -3,30 +3,35 @@ import UButton from "@nuxt/ui/components/Button.vue";
 import UTable from "@nuxt/ui/components/Table.vue";
 import { computed } from "vue";
 import { useUiToolsLocale } from "#ui-tools/i18n";
-import TableEmptyState from "../../../table/components/table/TableEmptyState.vue";
+import { isNumber, isObject } from "#ui-tools/shared";
+import TableEmptyState from "../../../table/components/table/table-empty-state.vue";
 import { useSpreadsheetReview } from "../../composables/use-spreadsheet-review";
-import SpreadsheetReviewInspection from "./review/SpreadsheetReviewInspection.vue";
-import SpreadsheetReviewOverflowAlert from "./review/SpreadsheetReviewOverflowAlert.vue";
-import SpreadsheetReviewStats from "./review/SpreadsheetReviewStats.vue";
+import SpreadsheetReviewInspection from "./review/spreadsheet-review-inspection.vue";
+import SpreadsheetReviewOverflowAlert from "./review/spreadsheet-review-overflow-alert.vue";
+import SpreadsheetReviewStats from "./review/spreadsheet-review-stats.vue";
 const props = defineProps({
   spreadsheet: { type: Object, required: true }
 });
 const { t } = useUiToolsLocale();
 function getSchemaMaxRecords(schema) {
-  if ("file" in schema && schema.file && typeof schema.file === "object" && "maxRecords" in schema.file && typeof schema.file.maxRecords === "number")
+  if ("file" in schema && schema.file && isObject(schema.file) && "maxRecords" in schema.file && isNumber(schema.file.maxRecords)) {
     return schema.file.maxRecords;
-  if ("source" in schema && schema.source && typeof schema.source === "object" && "maxRecords" in schema.source && typeof schema.source.maxRecords === "number")
+  }
+  if ("source" in schema && schema.source && isObject(schema.source) && "maxRecords" in schema.source && isNumber(schema.source.maxRecords)) {
     return schema.source.maxRecords;
+  }
   return void 0;
 }
 const maxRecords = computed(() => getSchemaMaxRecords(props.spreadsheet.schema.value) ?? Infinity);
 const review = useSpreadsheetReview({
-  resolvedRows: computed(() => props.spreadsheet.resolvedRows.value),
-  maxRecords
+  maxRecords,
+  resolvedRows: computed(() => props.spreadsheet.resolvedRows.value)
 });
 const tableHasRows = computed(() => review.visibleRows.value.length > 0);
 const summaryLimitText = computed(() => {
-  if (!Number.isFinite(maxRecords.value)) return void 0;
+  if (!Number.isFinite(maxRecords.value)) {
+    return void 0;
+  }
   return t("spreadsheet.steps.review.importLimit", {
     importable: Math.min(props.spreadsheet.resolvedRows.value.length, maxRecords.value),
     total: props.spreadsheet.resolvedRows.value.length

package/dist/runtime/spreadsheet/components/steps/{SpreadsheetImportStructureStep.vue → spreadsheet-import-structure-step.vue}

@@ -2,8 +2,8 @@
 import UAlert from "@nuxt/ui/components/Alert.vue";
 import { computed } from "vue";
 import { useUiToolsLocale } from "#ui-tools/i18n";
-import SpreadsheetStructurePreviewTable from "./structure/SpreadsheetStructurePreviewTable.vue";
-import SpreadsheetStructureSheetList from "./structure/SpreadsheetStructureSheetList.vue";
+import SpreadsheetStructurePreviewTable from "./structure/spreadsheet-structure-preview-table.vue";
+import SpreadsheetStructureSheetList from "./structure/spreadsheet-structure-sheet-list.vue";
 const props = defineProps({
   spreadsheet: { type: Object, required: true }
 });
@@ -11,9 +11,9 @@ const { t } = useUiToolsLocale();
 const activeSheet = computed(() => props.spreadsheet.activeSheet.value);
 const sheetItems = computed(
   () => (props.spreadsheet.workbook.value?.sheets ?? []).map((sheet) => ({
+    columnCount: Math.max(...sheet.rows.map((row) => row.length), 0),
     label: sheet.name,
-    rowCount: Math.max(sheet.rows.length - 1, 0),
-    columnCount: Math.max(...sheet.rows.map((row) => row.length), 0)
+    rowCount: Math.max(sheet.rows.length - 1, 0)
   }))
 );
 const previewRows = computed(

package/dist/runtime/spreadsheet/components/steps/{SpreadsheetImportUploadStep.vue → spreadsheet-import-upload-step.vue}

@@ -4,6 +4,7 @@ import UFileUpload from "@nuxt/ui/components/FileUpload.vue";
 import UIcon from "@nuxt/ui/components/Icon.vue";
 import { computed, ref, watch } from "vue";
 import { useUiToolsLocale } from "#ui-tools/i18n";
+import { isObject } from "#ui-tools/shared";
 const props = defineProps({
   spreadsheet: { type: Object, required: true },
   onDownloadTemplate: { type: Function, required: false }
@@ -11,20 +12,24 @@ const props = defineProps({
 const { t } = useUiToolsLocale();
 const file = ref(null);
 function getSchemaAccept(schema) {
-  if ("file" in schema && schema.file && typeof schema.file === "object" && "accept" in schema.file && Array.isArray(schema.file.accept))
+  if ("file" in schema && schema.file && isObject(schema.file) && "accept" in schema.file && Array.isArray(schema.file.accept)) {
     return schema.file.accept;
-  if ("source" in schema && schema.source && typeof schema.source === "object" && "accept" in schema.source && Array.isArray(schema.source.accept))
+  }
+  if ("source" in schema && schema.source && isObject(schema.source) && "accept" in schema.source && Array.isArray(schema.source.accept)) {
     return schema.source.accept;
+  }
   return void 0;
 }
 const accept = computed(
   () => getSchemaAccept(props.spreadsheet.schema.value)?.join(",") ?? ".xlsx,.xls,.csv"
 );
 watch(file, (nextFile) => {
-  if (!nextFile) return;
+  if (!nextFile) {
+    return;
+  }
   props.spreadsheet.loadSource({
-    source: nextFile,
-    fileName: nextFile.name
+    fileName: nextFile.name,
+    source: nextFile
   });
 });
 </script>

package/dist/runtime/spreadsheet/components/steps/structure/{SpreadsheetStructurePreviewTable.d.vue.ts → spreadsheet-structure-preview-table.d.vue.ts}

@@ -1,8 +1,8 @@
 type __VLS_Props = {
-    rows: Array<{
+    rows: {
         absoluteIndex: number;
         cells: readonly unknown[];
-    }>;
+    }[];
     columnCount: number;
     selectedHeaderRowIndex: number;
 };

package/dist/runtime/spreadsheet/components/steps/structure/{SpreadsheetStructurePreviewTable.vue → spreadsheet-structure-preview-table.vue}

@@ -13,10 +13,10 @@ const viewportRef = ref(null);
 const rowVirtualizer = useVirtualizer(
   computed(() => ({
     count: props.rows.length,
-    getScrollElement: () => viewportRef.value,
     estimateSize: () => 38,
-    overscan: 12,
-    getItemKey: (index) => props.rows[index]?.absoluteIndex ?? index
+    getItemKey: (index) => props.rows[index]?.absoluteIndex ?? index,
+    getScrollElement: () => viewportRef.value,
+    overscan: 12
   }))
 );
 const virtualRows = computed(() => rowVirtualizer.value.getVirtualItems());

package/dist/runtime/spreadsheet/components/steps/structure/{SpreadsheetStructurePreviewTable.vue.d.ts → spreadsheet-structure-preview-table.vue.d.ts}

@@ -1,8 +1,8 @@
 type __VLS_Props = {
-    rows: Array<{
+    rows: {
         absoluteIndex: number;
         cells: readonly unknown[];
-    }>;
+    }[];
     columnCount: number;
     selectedHeaderRowIndex: number;
 };

package/dist/runtime/spreadsheet/components/steps/structure/{SpreadsheetStructureSheetList.d.vue.ts → spreadsheet-structure-sheet-list.d.vue.ts}

@@ -1,9 +1,9 @@
 type __VLS_Props = {
-    items: Array<{
+    items: {
         label: string;
         rowCount: number;
         columnCount: number;
-    }>;
+    }[];
     selectedSheetName?: string;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

package/dist/runtime/spreadsheet/components/steps/structure/{SpreadsheetStructureSheetList.vue.d.ts → spreadsheet-structure-sheet-list.vue.d.ts}

@@ -1,9 +1,9 @@
 type __VLS_Props = {
-    items: Array<{
+    items: {
         label: string;
         rowCount: number;
         columnCount: number;
-    }>;
+    }[];
     selectedSheetName?: string;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

package/dist/runtime/spreadsheet/composables/use-spreadsheet-column-matching.d.ts

@@ -1,18 +1,18 @@
-import { type ComputedRef } from 'vue';
-import type { SpreadsheetNormalizedSchema } from '../types/index.js';
+import type { ComputedRef } from 'vue';
+import type { SpreadsheetNormalizedSchema, SpreadsheetRecord } from '../types/index.js';
 export interface UseSpreadsheetColumnMatchingParams {
     schema: ComputedRef<SpreadsheetNormalizedSchema>;
-    contextData: ComputedRef<Record<string, unknown>>;
+    contextData: ComputedRef<SpreadsheetRecord>;
     headers: ComputedRef<readonly unknown[]>;
 }
 export declare function useSpreadsheetColumnMatching(params: UseSpreadsheetColumnMatchingParams): {
-    headerCells: ComputedRef<import("../types/index.js").SpreadsheetHeaderCell[]>;
-    staticColumns: ComputedRef<import("../types/index.js").SpreadsheetStaticColumn[]>;
+    assignColumn: (headerIndex: number, columnKey: string) => void;
+    clearColumnAssignment: (headerIndex: number) => void;
+    columnMatches: ComputedRef<import("../types/index.js").SpreadsheetColumnMatch<import("../types/index.js").SpreadsheetColumnDefinition<string, unknown, boolean, unknown, undefined, unknown, undefined>>[]>;
+    dynamicColumnMatches: ComputedRef<import("../types/index.js").SpreadsheetDynamicColumnMatch<import("../types/index.js").SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown> | import("../types/index.js").SpreadsheetDynamicCollectionDefinition<string, "array" | "record", readonly unknown[], unknown>, import("../types/index.js").SpreadsheetDynamicCollectionItemDefinition<string, import("../types/index.js").SpreadsheetDynamicValueDefinition | ((value: import("../types/index.js").SpreadsheetDynamicValueBuilder) => import("../types/index.js").SpreadsheetValue), unknown, unknown>>[]>;
     dynamicColumns: ComputedRef<readonly unknown[]>;
+    headerCells: ComputedRef<import("../types/index.js").SpreadsheetHeaderCell[]>;
     manualColumnAssignments: import("vue").ShallowRef<Record<string, string>, Record<string, string>>;
-    columnMatches: ComputedRef<import("../types/index.js").SpreadsheetColumnMatch<import("../types/index.js").SpreadsheetColumnDefinition<string, unknown, boolean, unknown, undefined, unknown, undefined>>[]>;
-    dynamicColumnMatches: ComputedRef<import("../types/index.js").SpreadsheetDynamicColumnMatch<import("../types/index.js").SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown> | import("../types/index.js").SpreadsheetDynamicCollectionDefinition<string, "array" | "record", readonly unknown[], unknown>, import("../types/index.js").SpreadsheetDynamicCollectionItemDefinition<string, import("../types/index.js").SpreadsheetDynamicValueDefinition | ((value: import("../types/index.js").SpreadsheetDynamicValueBuilder) => unknown), unknown, unknown>>[]>;
+    staticColumns: ComputedRef<import("../types/index.js").SpreadsheetStaticColumn[]>;
     unmatchedColumns: ComputedRef<import("../types/index.js").SpreadsheetUnmatchedColumn<import("../types/index.js").SpreadsheetColumnDefinition<string, unknown, boolean, unknown, undefined, unknown, undefined>>[]>;
-    assignColumn: (headerIndex: number, columnKey: string) => void;
-    clearColumnAssignment: (headerIndex: number) => void;
 };

package/dist/runtime/spreadsheet/composables/use-spreadsheet-column-matching.js

@@ -49,14 +49,14 @@ export function useSpreadsheetColumnMatching(params) {
     manualColumnAssignments.value = nextAssignments;
   }
   return {
-    headerCells,
-    staticColumns,
-    dynamicColumns,
-    manualColumnAssignments,
+    assignColumn,
+    clearColumnAssignment,
     columnMatches,
     dynamicColumnMatches,
-    unmatchedColumns,
-    assignColumn,
-    clearColumnAssignment
+    dynamicColumns,
+    headerCells,
+    manualColumnAssignments,
+    staticColumns,
+    unmatchedColumns
   };
 }

package/dist/runtime/spreadsheet/composables/use-spreadsheet-context.d.ts

@@ -1,4 +1,4 @@
-import { type ComputedRef } from 'vue';
+import type { ComputedRef } from 'vue';
 import type { SpreadsheetNormalizedSchema } from '../types/index.js';
 export interface UseSpreadsheetContextParams {
     schema: ComputedRef<SpreadsheetNormalizedSchema>;
@@ -12,7 +12,7 @@ export declare function useSpreadsheetContext(params: UseSpreadsheetContextParam
         isFetching?: boolean;
         isSuccess?: boolean;
         isRefetching?: boolean;
-        refetch: () => Promise<unknown>;
+        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
     }[], {
         key: string;
         data?: unknown;
@@ -21,8 +21,11 @@ export declare function useSpreadsheetContext(params: UseSpreadsheetContextParam
         isFetching?: boolean;
         isSuccess?: boolean;
         isRefetching?: boolean;
-        refetch: () => Promise<unknown>;
+        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
     }[]>>;
+    contextData: ComputedRef<Partial<{
+        [x: string]: unknown;
+    }>>;
     contextItems: ComputedRef<readonly import("../types/index.js").SpreadsheetContextItem<string, unknown>[]>;
     contextResults: ComputedRef<{
         key: string;
@@ -32,18 +35,15 @@ export declare function useSpreadsheetContext(params: UseSpreadsheetContextParam
         isFetching?: boolean;
         isSuccess?: boolean;
         isRefetching?: boolean;
-        refetch: () => Promise<unknown>;
+        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
     }[]>;
-    contextData: ComputedRef<Partial<{
-        [x: string]: unknown;
-    }>>;
+    error: ComputedRef<unknown>;
+    refreshContext: () => Promise<unknown[]>;
     status: ComputedRef<{
         initialized: boolean;
-        isPending: boolean;
         isFetching: boolean;
+        isPending: boolean;
         isReady: boolean;
         isRefreshing: boolean;
     }>;
-    error: ComputedRef<unknown>;
-    refreshContext: () => Promise<unknown[]>;
 };

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

@@ -8,11 +8,11 @@ import {
 export function useSpreadsheetContext(params) {
   const contextItems = computed(() => params.schema.value.context);
   const context = useQueries({
-    queries: () => createSpreadsheetContextQueries(contextItems.value),
     combine: (results) => results.map((result, index) => ({
       key: contextItems.value[index]?.key,
       ...result
-    }))
+    })),
+    queries: () => createSpreadsheetContextQueries(contextItems.value)
   });
   const contextResults = computed(() => context.value);
   const contextData = computed(
@@ -25,11 +25,11 @@ export function useSpreadsheetContext(params) {
   }
   return {
     context,
+    contextData,
     contextItems,
     contextResults,
-    contextData,
-    status,
     error,
-    refreshContext
+    refreshContext,
+    status
   };
 }

package/dist/runtime/spreadsheet/composables/use-spreadsheet-import.d.ts

@@ -1,6 +1,6 @@
-import { type MaybeRefOrGetter } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
 import type { SpreadsheetImportApi } from '../types/index.js';
-import { type SpreadsheetInternals } from './use-spreadsheet-internals.js';
+import type { SpreadsheetInternals } from './use-spreadsheet-internals.js';
 export declare function useSpreadsheetImport<TSchema extends {
     importKey: string;
 }>(schema: MaybeRefOrGetter<TSchema>): SpreadsheetImportApi<TSchema> & {

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

@@ -10,7 +10,9 @@ function mapSpreadsheetRowData(rows) {
   return rows.map((row) => row.data);
 }
 async function createSpreadsheetSubmitPayloads(params) {
-  if (!params.schema.buildRow) return params.rows.map((row) => row.data);
+  if (!params.schema.buildRow) {
+    return params.rows.map((row) => row.data);
+  }
   return Promise.all(
     params.rows.map(
       (row) => params.schema.buildRow({
@@ -23,11 +25,11 @@ async function createSpreadsheetSubmitPayloads(params) {
 export function useSpreadsheetImport(schema) {
   const resolvedSchema = computed(() => toValue(schema));
   const sourceRef = shallowRef(null);
-  const fileNameRef = shallowRef(void 0);
+  const fileNameRef = shallowRef();
   const internals = createSpreadsheetInternals({
+    fileName: fileNameRef,
     rawSchema: resolvedSchema,
-    source: sourceRef,
-    fileName: fileNameRef
+    source: sourceRef
   });
   const parsedRows = computed(
     () => mapSpreadsheetParsedRows(internals.rows.parsedRows.value)
@@ -39,15 +41,15 @@ export function useSpreadsheetImport(schema) {
     () => mapSpreadsheetRowData(internals.resolutions.resolvedRows.value)
   );
   const submitPayloads = computedAsyncPayloads({
-    schema: resolvedSchema,
     context: internals.context.contextData,
-    rows: computed(() => internals.resolutions.resolvedRows.value)
+    rows: computed(() => internals.resolutions.resolvedRows.value),
+    schema: resolvedSchema
   });
   const status = computed(() => ({
     initialized: internals.source.status.value.initialized || internals.context.status.value.initialized || internals.rows.status.value.initialized,
-    isParsingSource: internals.source.status.value.isParsing,
     isLoadingContext: internals.context.status.value.isPending || internals.context.status.value.isFetching,
     isParsingRows: internals.rows.status.value.isParsing,
+    isParsingSource: internals.source.status.value.isParsing,
     isReady: internals.source.status.value.isReady && internals.context.status.value.isReady && internals.rows.status.value.isReady
   }));
   function loadSource(params) {
@@ -64,45 +66,45 @@ export function useSpreadsheetImport(schema) {
     await internals.rows.refreshRows();
   }
   return {
-    schema: resolvedSchema,
-    workbook: internals.source.workbook,
-    selection: internals.source.selection,
+    __internals: internals,
     activeSheet: internals.source.sheet,
-    headers: internals.source.headers,
+    assignColumn: ({ headerIndex, columnKey }) => internals.rows.assignColumn(headerIndex, columnKey),
+    clearColumnAssignment: (headerIndex) => internals.rows.clearColumnAssignment(headerIndex),
+    clearReference: internals.resolutions.clearReference,
+    clearSource,
+    contextError: internals.context.error,
     headerCells: internals.rows.headerCells,
-    rows: internals.source.rows,
+    headers: internals.source.headers,
+    loadSource,
     parsedRows,
+    referenceResolutions: computed(() => internals.resolutions.resolutions.value),
+    refresh,
     resolvedRows,
     rowData,
-    submitPayloads,
+    rowError: internals.rows.error,
     rowSummary: internals.rows.summary,
-    referenceResolutions: computed(() => internals.resolutions.resolutions.value),
+    rows: internals.source.rows,
+    schema: resolvedSchema,
+    selectReference: internals.resolutions.selectReference,
+    selection: internals.source.selection,
+    setHeaderRowIndex: internals.source.setHeaderRowIndex,
+    setSheetName: internals.source.setSheetName,
+    sourceError: internals.source.error,
+    status,
+    submitPayloads,
     unresolvedReferenceResolutions: computed(
       () => internals.resolutions.unresolvedResolutions.value
     ),
-    status,
-    sourceError: internals.source.error,
-    contextError: internals.context.error,
-    rowError: internals.rows.error,
-    loadSource,
-    clearSource,
-    setSheetName: internals.source.setSheetName,
-    setHeaderRowIndex: internals.source.setHeaderRowIndex,
-    assignColumn: ({ headerIndex, columnKey }) => internals.rows.assignColumn(headerIndex, columnKey),
-    clearColumnAssignment: (headerIndex) => internals.rows.clearColumnAssignment(headerIndex),
-    selectReference: internals.resolutions.selectReference,
-    clearReference: internals.resolutions.clearReference,
-    refresh,
-    __internals: internals
+    workbook: internals.source.workbook
   };
 }
 function computedAsyncPayloads(params) {
   const payloads = shallowRef([]);
   async function refreshPayloads() {
     payloads.value = await createSpreadsheetSubmitPayloads({
-      schema: params.schema.value,
       context: params.context.value,
-      rows: params.rows.value
+      rows: params.rows.value,
+      schema: params.schema.value
     });
   }
   watch(