nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/shared/utils/predicate.js

@@ -1,3 +1,6 @@
+function objectTag(value) {
+  return Object.prototype.toString.call(value);
+}
 export function isDefined(value) {
   return value !== null && value !== void 0;
 }
@@ -11,19 +14,19 @@ export function isNullish(value) {
   return value === null || value === void 0;
 }
 export function isString(value) {
-  return typeof value === "string";
+  return objectTag(value) === "[object String]";
 }
 export function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
+  return isString(value) && value.length > 0;
 }
 export function isNumber(value) {
-  return typeof value === "number" && !Number.isNaN(value);
+  return objectTag(value) === "[object Number]" && !Number.isNaN(value);
 }
 export function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
+  return isNumber(value) && Number.isFinite(value);
 }
 export function isInteger(value) {
-  return typeof value === "number" && Number.isInteger(value);
+  return isNumber(value) && Number.isInteger(value);
 }
 export function isPositiveNumber(value) {
   return isNumber(value) && value > 0;
@@ -32,37 +35,44 @@ export function isNonNegativeNumber(value) {
   return isNumber(value) && value >= 0;
 }
 export function isBoolean(value) {
-  return typeof value === "boolean";
+  return objectTag(value) === "[object Boolean]";
 }
 export function isFunction(value) {
-  return typeof value === "function";
+  const tag = objectTag(value);
+  return tag === "[object Function]" || tag === "[object AsyncFunction]" || tag === "[object GeneratorFunction]" || tag === "[object AsyncGeneratorFunction]";
 }
 export function isObject(value) {
-  return value !== null && !Array.isArray(value) && typeof value === "object";
+  return objectTag(value) === "[object Object]" && !Array.isArray(value);
 }
 export function isSymbol(value) {
-  return typeof value === "symbol";
+  return objectTag(value) === "[object Symbol]";
 }
 export function isBigInt(value) {
-  return typeof value === "bigint";
+  return objectTag(value) === "[object BigInt]";
 }
 export function isDate(value) {
   return value instanceof Date && !Number.isNaN(value.getTime());
 }
 export function isValidDate(value) {
-  return value instanceof Date && !Number.isNaN(value.getTime());
+  return isDate(value);
 }
 export function isRegExp(value) {
   return value instanceof RegExp;
 }
 export function isPromise(value) {
-  return value instanceof Promise || value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+  if (value instanceof Promise) {
+    return true;
+  }
+  if (!isObject(value) || !("then" in value)) {
+    return false;
+  }
+  return isFunction(value.then);
 }
 export function isError(value) {
   return value instanceof Error;
 }
 export function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
+  if (!isObject(value)) {
     return false;
   }
   const proto = Object.getPrototypeOf(value);
@@ -75,34 +85,37 @@ export function isNonEmptyArray(value) {
   return Array.isArray(value) && value.length > 0;
 }
 export function isArrayOf(value, predicate) {
-  return Array.isArray(value) && value.every(predicate);
+  return Array.isArray(value) && value.every((item) => predicate(item));
 }
 export function isNonEmptyObject(value) {
   return isPlainObject(value) && Object.keys(value).length > 0;
 }
 export function isPrimitive(value) {
-  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol" || typeof value === "bigint";
+  return value === null || value === void 0 || isString(value) || isNumber(value) || isBoolean(value) || isSymbol(value) || isBigInt(value);
 }
 export function hasProperty(value, key) {
-  return value !== null && typeof value === "object" && key in value;
+  return (isObject(value) || Array.isArray(value)) && key in value;
 }
 export function hasProperties(value, keys) {
-  return value !== null && typeof value === "object" && keys.every((key) => key in value);
+  return keys.every((key) => hasProperty(value, key));
 }
 export function hasTypedProperty(value, key, predicate) {
-  return hasProperty(value, key) && predicate(value[key]);
+  if (!isObject(value) || !(key in value)) {
+    return false;
+  }
+  return predicate(value[key]);
 }
 export function isOneOf(values) {
-  return (value) => values.includes(value);
+  return (value) => values.some((candidate) => Object.is(candidate, value));
 }
 export function not(predicate) {
   return (value) => !predicate(value);
 }
 export function all(...predicates) {
-  return (value) => predicates.every((p) => p(value));
+  return (value) => predicates.every((predicate) => predicate(value));
 }
 export function some(...predicates) {
-  return (value) => predicates.some((p) => p(value));
+  return (value) => predicates.some((predicate) => predicate(value));
 }
 export function isTruthy(value) {
   return Boolean(value);
@@ -114,25 +127,30 @@ export function matchesPattern(pattern) {
   return (value) => isString(value) && pattern.test(value);
 }
 export function isEmail(value) {
-  if (!isString(value)) return false;
+  if (!isString(value)) {
+    return false;
+  }
   const atIndex = value.indexOf("@");
-  if (atIndex < 1) return false;
+  if (atIndex < 1) {
+    return false;
+  }
   const domain = value.slice(atIndex + 1);
   const dotIndex = domain.lastIndexOf(".");
   return dotIndex > 0 && dotIndex < domain.length - 1 && !value.includes(" ");
 }
 export function isURL(value) {
-  if (!isString(value)) return false;
+  if (!isString(value)) {
+    return false;
+  }
   try {
     const url = new URL(value);
-    void url;
-    return true;
+    return url.protocol.length > 0;
   } catch {
     return false;
   }
 }
 export const isUUID = matchesPattern(
-  /^[\da-f]{8}-[\da-f]{4}-[1-5][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i
+  /^[\da-f]{8}-[\da-f]{4}-[1-5][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu
 );
 export function isInstanceOf(constructor) {
   return (value) => value instanceof constructor;
@@ -150,7 +168,11 @@ export function isWeakSet(value) {
   return value instanceof WeakSet;
 }
 export function isIterable(value) {
-  return value !== null && value !== void 0 && typeof value[Symbol.iterator] === "function";
+  if (!(isObject(value) || Array.isArray(value))) {
+    return false;
+  }
+  const descriptor = Object.getOwnPropertyDescriptor(value, Symbol.iterator);
+  return descriptor !== void 0 && isFunction(descriptor.value);
 }
 export function isArrayBuffer(value) {
   return value instanceof ArrayBuffer;

package/dist/runtime/shared/utils/registry.js

@@ -4,6 +4,7 @@ export function createKeyedRegistry(items) {
       ...registry,
       [item.key]: item
     }),
+    // SAFETY: every reducer write uses an item key from the input tuple, so the mapped registry is complete.
     {}
   );
 }

package/dist/runtime/shared/utils/render.d.ts

@@ -1,4 +1,4 @@
-import { type VNodeChild } from 'vue';
+import type { VNodeChild } from 'vue';
 import type { LazyTextValue, RenderableType } from '../types/utils.js';
 export type RenderableValue<TArgs extends unknown[] = []> = RenderableType | ((...args: TArgs) => RenderableType);
 export type ResolvableTextValue = LazyTextValue;

package/dist/runtime/shared/utils/render.js

@@ -1,13 +1,21 @@
 import { createTextVNode } from "vue";
+import { isFunction, isNumber, isString } from "./predicate.js";
 export function renderVNode(value, ...args) {
-  const resolved = typeof value === "function" ? value(...args) : value;
-  if (typeof resolved === "string" || typeof resolved === "number") {
+  const resolved = isRenderableFunction(value) ? value(...args) : value;
+  if (isString(resolved) || isNumber(resolved)) {
     return createTextVNode(String(resolved));
   }
   return resolved ?? null;
 }
+function isRenderableFunction(value) {
+  return isFunction(value);
+}
 export function resolveTextValue(value, fallback = "") {
-  if (typeof value === "function") return String(value());
-  if (typeof value === "string" || typeof value === "number") return String(value);
+  if (isFunction(value)) {
+    return String(value());
+  }
+  if (isString(value) || isNumber(value)) {
+    return String(value);
+  }
   return fallback;
 }

package/dist/runtime/shared/utils/responsive.d.ts

@@ -1,6 +1,7 @@
 import type { InferResponsiveValue, ResponsiveBreakpointContext, ResponsiveTransformKey, ResponsiveTransformResult, ResponsiveTransformer, ResponsiveValueInput } from '../types/responsive.js';
-type ResponsiveTransform = ResponsiveTransformKey | ResponsiveTransformer<unknown>;
-export type ViewportLike = {
+export type ResponsiveRuntimeValue = string | number | boolean | object | null;
+type ResponsiveTransform = ResponsiveTransformKey | ResponsiveTransformer<ResponsiveRuntimeValue>;
+export interface ViewportLike {
     breakpoint: {
         value: string;
     };
@@ -9,7 +10,7 @@ export type ViewportLike = {
             size: number;
         }>;
     };
-};
+}
 export declare function parseResponsiveValue(value: string, breakpointKeys: string[]): Record<string, string | null>;
 export declare function resolveResponsiveValueAtBreakpoint<TValue extends ResponsiveValueInput>(value: TValue, context: ResponsiveBreakpointContext): InferResponsiveValue<TValue> | null;
 export declare function resolveResponsiveValueAtBreakpoint<TTransform extends ResponsiveTransform>(value: string, context: ResponsiveBreakpointContext, transform: TTransform): ResponsiveTransformResult<TTransform> | null;

package/dist/runtime/shared/utils/responsive.js

@@ -1,7 +1,10 @@
+import { isFunction, isString } from "./predicate.js";
 export function parseResponsiveValue(value, breakpointKeys) {
-  const tokens = value.trim().split(/\s+/).filter(Boolean).map((token) => {
+  const tokens = value.trim().split(/\s+/u).filter(Boolean).map((token) => {
     const separatorIndex = token.indexOf(":");
-    if (separatorIndex === -1) return { breakpoint: breakpointKeys[0] ?? "", value: token };
+    if (separatorIndex === -1) {
+      return { breakpoint: breakpointKeys[0] ?? "", value: token };
+    }
     return {
       breakpoint: token.slice(0, separatorIndex),
       value: token.slice(separatorIndex + 1)
@@ -16,31 +19,58 @@ export function parseResponsiveValue(value, breakpointKeys) {
     let fallbackIndex = index - 1;
     while (fallbackIndex >= 0 && resolvedValue === null) {
       resolvedValue = tokens.find((token) => token.breakpoint === breakpointKeys[fallbackIndex])?.value ?? null;
-      fallbackIndex--;
+      fallbackIndex -= 1;
     }
     acc[breakpoint] = resolvedValue;
     return acc;
   }, {});
 }
 export function resolveResponsiveValueAtBreakpoint(value, context, transform) {
-  if (typeof value !== "string") return value;
+  if (!isString(value)) {
+    return value;
+  }
   const resolvedValue = parseResponsiveValue(value, context.breakpointKeys)[context.breakpoint] ?? null;
-  if (resolvedValue === null) return null;
+  if (resolvedValue === null) {
+    return null;
+  }
   return transformResponsiveValue(resolvedValue, transform);
 }
 export function getOrderedBreakpointKeys(viewport) {
   return Object.entries(viewport.queries.value).sort(([, leftQuery], [, rightQuery]) => leftQuery.size - rightQuery.size).map(([breakpoint]) => breakpoint);
 }
 function transformResponsiveValue(value, transform) {
-  if (transform === void 0 || transform === "string") return value;
-  if (typeof transform === "function") return transform(value);
-  if (transform === "boolean") return value === "true";
-  if (transform === "integer") return Number.parseInt(value, 10);
-  if (transform === "float") return Number.parseFloat(value);
-  if (transform === "grid-cols") return `grid-template-columns: repeat(${value}, minmax(0, 1fr))`;
-  if (transform === "grid-rows") return `grid-template-rows: repeat(${value}, minmax(0, 1fr))`;
-  if (transform === "col") return `grid-column: span ${value} / span ${value}`;
-  if (transform === "row") return `grid-row: span ${value} / span ${value}`;
-  if (transform === "maxWidth") return `max-width: ${value}`;
+  if (transform === void 0 || transform === "string") {
+    return value;
+  }
+  if (isResponsiveTransformer(transform)) {
+    return transform(value);
+  }
+  if (transform === "boolean") {
+    return value === "true";
+  }
+  if (transform === "integer") {
+    return Number.parseInt(value, 10);
+  }
+  if (transform === "float") {
+    return Number.parseFloat(value);
+  }
+  if (transform === "grid-cols") {
+    return `grid-template-columns: repeat(${value}, minmax(0, 1fr))`;
+  }
+  if (transform === "grid-rows") {
+    return `grid-template-rows: repeat(${value}, minmax(0, 1fr))`;
+  }
+  if (transform === "col") {
+    return `grid-column: span ${value} / span ${value}`;
+  }
+  if (transform === "row") {
+    return `grid-row: span ${value} / span ${value}`;
+  }
+  if (transform === "maxWidth") {
+    return `max-width: ${value}`;
+  }
   return `max-height: ${value}`;
 }
+function isResponsiveTransformer(value) {
+  return isFunction(value);
+}

package/dist/runtime/spreadsheet/components/shared/spreadsheet-object-preview-table.d.vue.ts

@@ -0,0 +1,7 @@
+import type { SpreadsheetRecord } from '../../types/index.js';
+type __VLS_Props = {
+    rows: readonly SpreadsheetRecord[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/spreadsheet/components/shared/{SpreadsheetObjectPreviewTable.vue → spreadsheet-object-preview-table.vue}

@@ -1,25 +1,26 @@
 <script setup>
 import UTable from "@nuxt/ui/components/Table.vue";
 import { computed } from "vue";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+import { isNullish } from "../../../shared/utils/predicate";
+import { isSpreadsheetRecord } from "../../utils/object";
 function flattenRecord(value, prefix = "") {
   return Object.entries(value).reduce((acc, [key, nextValue]) => {
     const nextKey = prefix ? `${prefix}.${key}` : key;
-    if (Array.isArray(nextValue))
+    if (Array.isArray(nextValue)) {
       return {
         ...acc,
         [nextKey]: nextValue.join(", ")
       };
-    if (isRecord(nextValue))
+    }
+    if (isSpreadsheetRecord(nextValue)) {
       return {
         ...acc,
         ...flattenRecord(nextValue, nextKey)
       };
+    }
     return {
       ...acc,
-      [nextKey]: nextValue == null ? "" : String(nextValue)
+      [nextKey]: isNullish(nextValue) ? "" : String(nextValue)
     };
   }, {});
 }
@@ -36,11 +37,13 @@ const columnKeys = computed(() => {
   const keys = /* @__PURE__ */ new Set();
   for (const row of flattenedRows.value) {
     for (const key of Object.keys(row)) {
-      if (key === "__rowLabel") continue;
+      if (key === "__rowLabel") {
+        continue;
+      }
       keys.add(key);
     }
   }
-  return Array.from(keys);
+  return [...keys];
 });
 const columns = computed(() => [
   {

package/dist/runtime/spreadsheet/components/shared/spreadsheet-object-preview-table.vue.d.ts

@@ -0,0 +1,7 @@
+import type { SpreadsheetRecord } from '../../types/index.js';
+type __VLS_Props = {
+    rows: readonly SpreadsheetRecord[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/spreadsheet/components/shared/{SpreadsheetRawPreviewTable.vue → spreadsheet-raw-preview-table.vue}

@@ -7,9 +7,9 @@ const props = defineProps({
 });
 const normalizedHeaders = computed(
   () => props.headers.map((header, index) => ({
+    index,
     key: `column_${index}`,
-    label: String(header ?? `Column ${index + 1}`),
-    index
+    label: String(header ?? `Column ${index + 1}`)
   }))
 );
 const tableRows = computed(

package/dist/runtime/spreadsheet/components/shared/{SpreadsheetSummaryStats.d.vue.ts → spreadsheet-summary-stats.d.vue.ts}

@@ -1,9 +1,9 @@
 type __VLS_Props = {
-    items: Array<{
+    items: {
         label: string;
         value: string | number;
         color?: 'primary' | 'neutral' | 'success' | 'warning' | 'error' | 'secondary' | 'info';
-    }>;
+    }[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/spreadsheet/components/shared/{SpreadsheetSummaryStats.vue.d.ts → spreadsheet-summary-stats.vue.d.ts}

@@ -1,9 +1,9 @@
 type __VLS_Props = {
-    items: Array<{
+    items: {
         label: string;
         value: string | number;
         color?: 'primary' | 'neutral' | 'success' | 'warning' | 'error' | 'secondary' | 'info';
-    }>;
+    }[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/spreadsheet/components/shared/spreadsheet-value-preview.d.vue.ts

@@ -0,0 +1,10 @@
+import type { SpreadsheetValue } from '../../types/index.js';
+type __VLS_Props = {
+    value: SpreadsheetValue;
+    compact?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    compact: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/spreadsheet/components/shared/{SpreadsheetValuePreview.vue → spreadsheet-value-preview.vue}

@@ -2,6 +2,7 @@
 import UBadge from "@nuxt/ui/components/Badge.vue";
 import UPopover from "@nuxt/ui/components/Popover.vue";
 import { useUiToolsLocale } from "#ui-tools/i18n";
+import { isNullish } from "../../../shared/utils/predicate";
 import { formatSpreadsheetCell } from "../../utils/display";
 import { getSpreadsheetObjectEntries, isSpreadsheetRecord } from "../../utils/object";
 const props = defineProps({
@@ -18,9 +19,15 @@ function getCompactObjectEntries(value) {
   return props.compact ? entries.slice(0, compactLimit) : entries;
 }
 function getValueKind(value) {
-  if (value == null) return "empty";
-  if (Array.isArray(value)) return "array";
-  if (isSpreadsheetRecord(value)) return "object";
+  if (isNullish(value)) {
+    return "empty";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (isSpreadsheetRecord(value)) {
+    return "object";
+  }
   return "primitive";
 }
 function getObjectSummary(value) {

package/dist/runtime/spreadsheet/components/shared/spreadsheet-value-preview.vue.d.ts

@@ -0,0 +1,10 @@
+import type { SpreadsheetValue } from '../../types/index.js';
+type __VLS_Props = {
+    value: SpreadsheetValue;
+    compact?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    compact: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/spreadsheet/components/{SpreadsheetImport.vue → spreadsheet-import.vue}

@@ -1,17 +1,18 @@
 <script setup>
 import { computed, ref, nextTick, watch } from "vue";
 import { provideUiToolsLocale, useUiToolsLocale, useUiToolsLocaleRef } from "#ui-tools/i18n";
+import { isNumber, isObject } from "#ui-tools/shared";
 import { resolveTextValue } from "#ui-tools/shared/utils/render";
 import { useSpreadsheetView } from "../composables/use-spreadsheet-view";
-import SpreadsheetImportFileBar from "./layout/SpreadsheetImportFileBar.vue";
-import SpreadsheetImportFooter from "./layout/SpreadsheetImportFooter.vue";
-import SpreadsheetImportHeader from "./layout/SpreadsheetImportHeader.vue";
-import SpreadsheetImportSidebar from "./layout/SpreadsheetImportSidebar.vue";
-import SpreadsheetImportMatchingStep from "./steps/SpreadsheetImportMatchingStep.vue";
-import SpreadsheetImportReferencesStep from "./steps/SpreadsheetImportReferencesStep.vue";
-import SpreadsheetImportReviewStep from "./steps/SpreadsheetImportReviewStep.vue";
-import SpreadsheetImportStructureStep from "./steps/SpreadsheetImportStructureStep.vue";
-import SpreadsheetImportUploadStep from "./steps/SpreadsheetImportUploadStep.vue";
+import SpreadsheetImportFileBar from "./layout/spreadsheet-import-file-bar.vue";
+import SpreadsheetImportFooter from "./layout/spreadsheet-import-footer.vue";
+import SpreadsheetImportHeader from "./layout/spreadsheet-import-header.vue";
+import SpreadsheetImportSidebar from "./layout/spreadsheet-import-sidebar.vue";
+import SpreadsheetImportMatchingStep from "./steps/spreadsheet-import-matching-step.vue";
+import SpreadsheetImportReferencesStep from "./steps/spreadsheet-import-references-step.vue";
+import SpreadsheetImportReviewStep from "./steps/spreadsheet-import-review-step.vue";
+import SpreadsheetImportStructureStep from "./steps/spreadsheet-import-structure-step.vue";
+import SpreadsheetImportUploadStep from "./steps/spreadsheet-import-upload-step.vue";
 const props = defineProps({
   spreadsheet: { type: Object, required: true },
   title: { type: String, required: false },
@@ -39,16 +40,18 @@ const currentStep = computed(
   () => steps.value.find((step) => step.value === activeStep.value) ?? steps.value[0]
 );
 const stageTitle = computed(() => {
-  if (activeStep.value === "upload")
+  if (activeStep.value === "upload") {
     return resolveTextValue(
       props.spreadsheet.schema.value.steps?.upload?.title,
       t("spreadsheet.steps.upload.stageTitle")
     );
-  if (activeStep.value === "structure")
+  }
+  if (activeStep.value === "structure") {
     return resolveTextValue(
       props.spreadsheet.schema.value.steps?.structure?.title,
       t("spreadsheet.steps.structure.stageTitle")
     );
+  }
   return currentStep.value?.title ?? humanizeKey(props.spreadsheet.schema.value.importKey);
 });
 const stageDescription = computed(() => currentStep.value?.description ?? "");
@@ -59,17 +62,27 @@ const isPreparingNextStep = ref(false);
 const hasWorkbook = computed(() => Boolean(props.spreadsheet.workbook.value));
 const hasHeaders = computed(() => props.spreadsheet.headers.value.length > 0);
 function getSchemaMaxRecords(schema) {
-  if ("file" in schema && schema.file && typeof schema.file === "object" && "maxRecords" in schema.file)
-    return typeof schema.file.maxRecords === "number" ? schema.file.maxRecords : void 0;
-  if ("source" in schema && schema.source && typeof schema.source === "object" && "maxRecords" in schema.source)
-    return typeof schema.source.maxRecords === "number" ? schema.source.maxRecords : void 0;
+  if ("file" in schema && schema.file && isObject(schema.file) && "maxRecords" in schema.file) {
+    return isNumber(schema.file.maxRecords) ? schema.file.maxRecords : void 0;
+  }
+  if ("source" in schema && schema.source && isObject(schema.source) && "maxRecords" in schema.source) {
+    return isNumber(schema.source.maxRecords) ? schema.source.maxRecords : void 0;
+  }
   return void 0;
 }
 const canGoNext = computed(() => {
-  if (activeStep.value === "upload") return hasWorkbook.value;
-  if (activeStep.value === "structure") return hasWorkbook.value && hasHeaders.value;
-  if (activeStep.value === "matching") return hasWorkbook.value && hasHeaders.value;
-  if (activeStep.value === "references") return hasWorkbook.value && hasHeaders.value;
+  if (activeStep.value === "upload") {
+    return hasWorkbook.value;
+  }
+  if (activeStep.value === "structure") {
+    return hasWorkbook.value && hasHeaders.value;
+  }
+  if (activeStep.value === "matching") {
+    return hasWorkbook.value && hasHeaders.value;
+  }
+  if (activeStep.value === "references") {
+    return hasWorkbook.value && hasHeaders.value;
+  }
   return false;
 });
 const fileName = computed(() => props.spreadsheet.workbook.value?.fileName);
@@ -88,16 +101,21 @@ const sidebarItems = computed(
   }))
 );
 function humanizeKey(value) {
-  return value.split(".").at(-1)?.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase()) ?? value;
+  return value.split(".").at(-1)?.replaceAll(/([a-z0-9])([A-Z])/gu, "$1 $2").replaceAll(/[_-]+/gu, " ").replaceAll(/\b\w/gu, (char) => char.toUpperCase()) ?? value;
 }
 const actionHint = computed(() => {
-  if (activeStep.value === "structure") return t("spreadsheet.common.clickToChangeHeaderRow");
-  if (activeStep.value === "references") return t("spreadsheet.common.referencesStepHint");
+  if (activeStep.value === "structure") {
+    return t("spreadsheet.common.clickToChangeHeaderRow");
+  }
+  if (activeStep.value === "references") {
+    return t("spreadsheet.common.referencesStepHint");
+  }
   return void 0;
 });
 const primaryActionLabel = computed(() => {
-  if (activeStep.value === "review")
+  if (activeStep.value === "review") {
     return t("spreadsheet.common.importRows", { count: importableRowCount.value });
+  }
   return t("spreadsheet.common.continue");
 });
 const primaryActionColor = computed(
@@ -117,7 +135,9 @@ async function handlePrimaryAction() {
     void props.spreadsheet.refresh();
     return;
   }
-  if (!canGoNext.value) return;
+  if (!canGoNext.value) {
+    return;
+  }
   const nextStep = getNextStepValue();
   if (nextStep === "review") {
     isPreparingNextStep.value = true;
@@ -134,8 +154,12 @@ function handleClose() {
   emit("close");
 }
 watch(hasWorkbook, (nextHasWorkbook) => {
-  if (!nextHasWorkbook) return;
-  if (activeStep.value !== "upload") return;
+  if (!nextHasWorkbook) {
+    return;
+  }
+  if (activeStep.value !== "upload") {
+    return;
+  }
   goToNextStep();
 });
 </script>

package/dist/runtime/spreadsheet/components/steps/matching/{SpreadsheetMatchingSummary.d.vue.ts → spreadsheet-matching-summary.d.vue.ts}

@@ -1,10 +1,10 @@
 type __VLS_Props = {
-    items: Array<{
+    items: {
         key: string;
         label: string;
         value: number;
         tone: 'success' | 'warning' | 'error' | 'neutral';
-    }>;
+    }[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;