nuxt-ui-tools 0.1.3 → 1.0.0

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

@@ -1,22 +1,38 @@
+import { isBoolean, isFunction, isNumber, isString } from "#ui-tools/shared/utils/predicate";
 import { isSpreadsheetRecord } from "./object.js";
+function isSpreadsheetOptionResolver(value) {
+  return isFunction(value);
+}
 export function isSpreadsheetPrimitiveOption(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  return isString(value) || isNumber(value) || isBoolean(value);
 }
 export function isSpreadsheetOptionEntry(value) {
-  return isSpreadsheetRecord(value) && typeof value.label === "string" && "value" in value;
+  return isSpreadsheetRecord(value) && "label" in value && isString(value.label) && "value" in value;
 }
 export function resolveSpreadsheetOptionEntries(source, params) {
-  if (Array.isArray(source)) return source;
-  if (typeof source === "function") return source(params);
+  if (Array.isArray(source)) {
+    return source;
+  }
+  if (isSpreadsheetOptionResolver(source)) {
+    return source(params);
+  }
   return [];
 }
 export function getSpreadsheetOptionLabel(option) {
-  if (isSpreadsheetPrimitiveOption(option)) return String(option);
-  if (isSpreadsheetOptionEntry(option)) return option.label;
+  if (isSpreadsheetPrimitiveOption(option)) {
+    return String(option);
+  }
+  if (isSpreadsheetOptionEntry(option)) {
+    return option.label;
+  }
   return "";
 }
 export function getSpreadsheetOptionValue(option) {
-  if (isSpreadsheetPrimitiveOption(option)) return option;
-  if (isSpreadsheetOptionEntry(option)) return option.value;
+  if (isSpreadsheetPrimitiveOption(option)) {
+    return option;
+  }
+  if (isSpreadsheetOptionEntry(option)) {
+    return option.value;
+  }
   return void 0;
 }

package/dist/runtime/spreadsheet/utils/references/candidates.js

@@ -2,21 +2,27 @@ import { getSpreadsheetOptionLabel, getSpreadsheetOptionValue } from "../options
 import { normalizeSpreadsheetRuntimeResolutions } from "./guards.js";
 import { scoreSpreadsheetReferenceCandidate } from "./shared.js";
 export function createSpreadsheetReferenceCandidates(params) {
-  if (!normalizeSpreadsheetRuntimeResolutions([params.reference])[0]) return [];
+  if (!normalizeSpreadsheetRuntimeResolutions([params.reference])[0]) {
+    return [];
+  }
   return params.options.flatMap((option) => {
     const label = getSpreadsheetOptionLabel(option);
     const value = getSpreadsheetOptionValue(option);
-    if (!label || value === void 0) return [];
+    if (!label || value === void 0) {
+      return [];
+    }
     return [
       {
-        value,
         label,
         option,
-        score: scoreSpreadsheetReferenceCandidate(params.sourceValue, label)
+        score: scoreSpreadsheetReferenceCandidate(params.sourceValue, label),
+        value
       }
     ];
   }).sort((left, right) => {
-    if (left.score !== right.score) return right.score - left.score;
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
     return left.label.localeCompare(right.label);
   });
 }

package/dist/runtime/spreadsheet/utils/references/guards.d.ts

@@ -1,4 +1,4 @@
-import type { SpreadsheetReferenceDefinition, SpreadsheetResolutionDefinition } from '../../types/index.js';
-export declare function isSpreadsheetResolutionDefinition(value: unknown): value is SpreadsheetResolutionDefinition;
-export declare function isSpreadsheetPublicReferenceDefinition(value: unknown): value is SpreadsheetReferenceDefinition;
+import type { SpreadsheetReferenceDefinition, SpreadsheetResolutionDefinition, SpreadsheetValue } from '../../types/index.js';
+export declare function isSpreadsheetResolutionDefinition(value: SpreadsheetValue): value is SpreadsheetResolutionDefinition;
+export declare function isSpreadsheetPublicReferenceDefinition(value: SpreadsheetValue): value is SpreadsheetReferenceDefinition;
 export declare function normalizeSpreadsheetRuntimeResolutions(entries: readonly unknown[]): SpreadsheetResolutionDefinition[];

package/dist/runtime/spreadsheet/utils/references/guards.js

@@ -7,17 +7,21 @@ export function isSpreadsheetPublicReferenceDefinition(value) {
 }
 export function normalizeSpreadsheetRuntimeResolutions(entries) {
   return entries.flatMap((entry) => {
-    if (isSpreadsheetResolutionDefinition(entry)) return [entry];
-    if (!isSpreadsheetPublicReferenceDefinition(entry)) return [];
+    if (isSpreadsheetResolutionDefinition(entry)) {
+      return [entry];
+    }
+    if (!isSpreadsheetPublicReferenceDefinition(entry)) {
+      return [];
+    }
     return [
       {
+        getOptions: entry.getOptions,
         kind: "select",
+        options: entry.options,
+        rules: entry.rules,
         scope: "reference",
-        targetField: entry.field,
         sourceField: entry.source,
-        options: entry.options,
-        getOptions: entry.getOptions,
-        rules: entry.rules
+        targetField: entry.field
       }
     ];
   });

package/dist/runtime/spreadsheet/utils/references/resolutions.d.ts

@@ -1,17 +1,17 @@
-import type { SpreadsheetParsedRow, SpreadsheetReferenceQueryRequest, SpreadsheetReferenceResolution, SpreadsheetResolvedReferenceRow } from '../../types/index.js';
+import type { SpreadsheetParsedRow, SpreadsheetReferenceQueryRequest, SpreadsheetReferenceResolution, SpreadsheetRecord, SpreadsheetResolvedReferenceRow } from '../../types/index.js';
 export declare function createSpreadsheetReferenceResolutions(params: {
     references: readonly unknown[];
-    rows: readonly SpreadsheetParsedRow<Record<string, unknown>>[];
-    context: Record<string, unknown>;
+    rows: readonly SpreadsheetParsedRow<SpreadsheetRecord>[];
+    context: SpreadsheetRecord;
 }): SpreadsheetReferenceResolution<unknown, unknown>[];
 export declare function applySpreadsheetReferenceResolutions(params: {
-    rows: readonly SpreadsheetParsedRow<Record<string, unknown>>[];
+    rows: readonly SpreadsheetParsedRow<SpreadsheetRecord>[];
     references: readonly unknown[];
     resolutions: readonly SpreadsheetReferenceResolution[];
     relations?: readonly unknown[];
-}): SpreadsheetResolvedReferenceRow<Record<string, unknown>>[];
+}): SpreadsheetResolvedReferenceRow<SpreadsheetRecord>[];
 export declare function createSpreadsheetReferenceQueryRequests(params: {
     references: readonly unknown[];
-    rows: readonly SpreadsheetParsedRow<Record<string, unknown>>[];
-    context: Record<string, unknown>;
+    rows: readonly SpreadsheetParsedRow<SpreadsheetRecord>[];
+    context: SpreadsheetRecord;
 }): SpreadsheetReferenceQueryRequest[];

package/dist/runtime/spreadsheet/utils/references/resolutions.js

@@ -1,8 +1,10 @@
+import { isFunction, isString } from "#ui-tools/shared/utils/predicate";
 import {
   cloneSpreadsheetRowData,
   deleteSpreadsheetValueAtPath,
   getSpreadsheetValueAtPath,
-  setSpreadsheetValueAtPath
+  setSpreadsheetValueAtPath,
+  isSpreadsheetRecord
 } from "../object.js";
 import { resolveSpreadsheetOptionEntries } from "../options.js";
 import { executeSpreadsheetRules, resolveSpreadsheetRelationRules } from "../validation/core.js";
@@ -10,33 +12,33 @@ import { createSpreadsheetReferenceCandidates } from "./candidates.js";
 import { isSpreadsheetResolutionDefinition, normalizeSpreadsheetRuntimeResolutions } from "./guards.js";
 import { collectSpreadsheetReferenceSources, collectSpreadsheetReferenceTokens } from "./sources.js";
 function isSpreadsheetRelationDefinition(value) {
-  return value !== null && typeof value === "object" && "column" in value && typeof value.column === "string" && "rules" in value && typeof value.rules === "function";
+  return isSpreadsheetRecord(value) && "column" in value && isString(value.column) && "rules" in value && isFunction(value.rules);
 }
 export function createSpreadsheetReferenceResolutions(params) {
   return collectSpreadsheetReferenceSources(params.references, params.rows).flatMap(
     ({ reference, entries }) => entries.map((entry) => {
       const candidates = createSpreadsheetReferenceCandidates({
-        sourceValue: entry.value,
-        reference,
         options: resolveSpreadsheetOptionEntries(reference.options, {
           context: params.context
-        })
+        }),
+        reference,
+        sourceValue: entry.value
       });
       const bestCandidate = candidates[0];
       const isMatched = Boolean(bestCandidate && bestCandidate.score >= 0.9);
       return {
-        scope: reference.scope,
-        resolutionField: reference.targetField,
-        targetField: reference.targetField,
+        candidates,
+        outputField: reference.targetField,
         referenceField: reference.targetField,
+        resolutionField: reference.targetField,
+        rowIndexes: entry.rowIndexes,
+        scope: reference.scope,
+        selectedLabel: isMatched ? bestCandidate?.label : void 0,
+        selectedValue: isMatched ? bestCandidate?.value : void 0,
         sourceField: reference.sourceField,
-        outputField: reference.targetField,
         sourceValue: entry.value,
-        rowIndexes: entry.rowIndexes,
         status: isMatched ? "matched" : "unresolved",
-        selectedValue: isMatched ? bestCandidate?.value : void 0,
-        selectedLabel: isMatched ? bestCandidate?.label : void 0,
-        candidates
+        targetField: reference.targetField
       };
     })
   );
@@ -53,16 +55,22 @@ export function applySpreadsheetReferenceResolutions(params) {
     const issues = [...row.issues];
     const multiValueOutputs = /* @__PURE__ */ new Map();
     for (const definition of resolutionDefinitions) {
-      if (definition.scope !== "column") continue;
+      if (definition.scope !== "column") {
+        continue;
+      }
       deleteSpreadsheetValueAtPath(data, definition.targetField);
     }
     for (const [sourceField, resolutions] of resolutionsBySourceField.entries()) {
       const rawValue = getSpreadsheetValueAtPath(row.data, sourceField);
       const sourceTokens = collectSpreadsheetReferenceTokens(rawValue);
-      if (!sourceTokens.length) continue;
+      if (!sourceTokens.length) {
+        continue;
+      }
       for (const sourceValue of sourceTokens) {
         const resolution = resolutions.find((entry) => entry.sourceValue === sourceValue);
-        if (!resolution) continue;
+        if (!resolution) {
+          continue;
+        }
         if (resolution.selectedValue !== void 0) {
           if (Array.isArray(rawValue)) {
             const values = multiValueOutputs.get(resolution.outputField) ?? [];
@@ -74,79 +82,90 @@ export function applySpreadsheetReferenceResolutions(params) {
         }
       }
     }
-    for (const [outputField, values] of multiValueOutputs.entries())
+    for (const [outputField, values] of multiValueOutputs.entries()) {
       setSpreadsheetValueAtPath(data, outputField, values);
+    }
     for (const reference of resolutionDefinitions) {
       const value = getSpreadsheetValueAtPath(data, reference.targetField);
       const referenceIssues = executeSpreadsheetRules({
-        value,
-        rules: reference.rules
+        rules: reference.rules,
+        value
       });
       issues.push(
         ...referenceIssues.map(
           (issue) => ({
             ...issue,
-            rowIndex: row.index,
-            columnKey: reference.targetField
+            columnKey: reference.targetField,
+            rowIndex: row.index
           })
         )
       );
     }
     for (const relation of params.relations ?? []) {
-      if (!isSpreadsheetRelationDefinition(relation)) continue;
-      if (relation.condition && !relation.condition(data)) continue;
+      if (!isSpreadsheetRelationDefinition(relation)) {
+        continue;
+      }
+      if (relation.condition && !relation.condition(data)) {
+        continue;
+      }
       const relationIssues = executeSpreadsheetRules({
-        value: getSpreadsheetValueAtPath(data, relation.column),
         rules: resolveSpreadsheetRelationRules({
           row: data,
           rules: relation.rules
-        })
+        }),
+        value: getSpreadsheetValueAtPath(data, relation.column)
       });
       issues.push(
         ...relationIssues.map(
           (issue) => ({
             ...issue,
-            rowIndex: row.index,
-            columnKey: relation.column
+            columnKey: relation.column,
+            rowIndex: row.index
           })
         )
       );
     }
     return {
-      index: row.index,
-      source: row.source,
       data,
+      index: row.index,
+      isValid: issues.every((issue) => issue.level !== "error"),
       issues,
-      isValid: issues.every((issue) => issue.level !== "error")
+      source: row.source
     };
   });
 }
 export function createSpreadsheetReferenceQueryRequests(params) {
   return createSpreadsheetReferenceResolutions({
+    context: params.context,
     references: params.references,
-    rows: params.rows,
-    context: params.context
+    rows: params.rows
   }).flatMap((resolution) => {
     const referenceEntry = normalizeSpreadsheetRuntimeResolutions(params.references).find(
       (entry) => entry.targetField === (resolution.targetField ?? resolution.referenceField)
     );
-    if (!isSpreadsheetResolutionDefinition(referenceEntry)) return [];
+    if (!isSpreadsheetResolutionDefinition(referenceEntry)) {
+      return [];
+    }
     const reference = referenceEntry;
-    if (!reference.getOptions || resolution.status === "matched") return [];
+    if (!reference.getOptions || resolution.status === "matched") {
+      return [];
+    }
     const sourceRow = params.rows.find((row) => row.index === resolution.rowIndexes[0]);
-    if (!sourceRow) return [];
+    if (!sourceRow) {
+      return [];
+    }
     return [
       {
-        scope: reference.scope,
-        resolutionField: reference.targetField,
-        targetField: reference.targetField,
-        referenceField: reference.targetField,
-        sourceValue: resolution.sourceValue,
         query: reference.getOptions({
           context: params.context,
           row: sourceRow.data,
           search: resolution.sourceValue
-        })
+        }),
+        referenceField: reference.targetField,
+        resolutionField: reference.targetField,
+        scope: reference.scope,
+        sourceValue: resolution.sourceValue,
+        targetField: reference.targetField
       }
     ];
   });

package/dist/runtime/spreadsheet/utils/references/shared.d.ts

@@ -1,2 +1,3 @@
-export declare function normalizeSpreadsheetReferenceText(value: unknown): string;
+import type { SpreadsheetValue } from '../../types/index.js';
+export declare function normalizeSpreadsheetReferenceText(value: SpreadsheetValue): string;
 export declare function scoreSpreadsheetReferenceCandidate(sourceValue: string, label: string): number;

package/dist/runtime/spreadsheet/utils/references/shared.js

@@ -1,16 +1,26 @@
 export function normalizeSpreadsheetReferenceText(value) {
-  return String(value ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().replace(/\s+/g, " ").toLowerCase();
+  return String(value ?? "").normalize("NFD").replaceAll(/[\u0300-\u036F]/gu, "").trim().replaceAll(/\s+/gu, " ").toLowerCase();
 }
 export function scoreSpreadsheetReferenceCandidate(sourceValue, label) {
   const normalizedSource = normalizeSpreadsheetReferenceText(sourceValue);
   const normalizedLabel = normalizeSpreadsheetReferenceText(label);
-  if (!normalizedSource || !normalizedLabel) return 0;
-  if (normalizedSource === normalizedLabel) return 1;
-  if (normalizedLabel.includes(normalizedSource)) return 0.9;
-  if (normalizedSource.includes(normalizedLabel)) return 0.82;
+  if (!normalizedSource || !normalizedLabel) {
+    return 0;
+  }
+  if (normalizedSource === normalizedLabel) {
+    return 1;
+  }
+  if (normalizedLabel.includes(normalizedSource)) {
+    return 0.9;
+  }
+  if (normalizedSource.includes(normalizedLabel)) {
+    return 0.82;
+  }
   const sourceTokens = normalizedSource.split(" ");
   const labelTokens = normalizedLabel.split(" ");
   const overlap = sourceTokens.filter((token) => labelTokens.includes(token)).length;
-  if (!overlap) return 0;
+  if (!overlap) {
+    return 0;
+  }
   return overlap / Math.max(sourceTokens.length, labelTokens.length);
 }

package/dist/runtime/spreadsheet/utils/references/sources.d.ts

@@ -1,9 +1,9 @@
-import type { SpreadsheetParsedRow } from '../../types/index.js';
-export declare function collectSpreadsheetReferenceTokens(value: unknown): string[];
-export declare function collectSpreadsheetReferenceSources(references: readonly unknown[], rows: readonly SpreadsheetParsedRow<Record<string, unknown>>[]): {
-    reference: import("../../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../../types/index.js").SpreadsheetOptionItem, Record<string, unknown>, Record<string, unknown>, import("../../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>;
+import type { SpreadsheetParsedRow, SpreadsheetRecord, SpreadsheetValue } from '../../types/index.js';
+export declare function collectSpreadsheetReferenceTokens(value: SpreadsheetValue): string[];
+export declare function collectSpreadsheetReferenceSources(references: readonly unknown[], rows: readonly SpreadsheetParsedRow<SpreadsheetRecord>[]): {
     entries: {
-        value: string;
         rowIndexes: number[];
+        value: string;
     }[];
+    reference: import("../../types/index.js").SpreadsheetResolutionDefinition<"column" | "reference", string, string, unknown, unknown, import("../../types/index.js").SpreadsheetOptionItem, SpreadsheetRecord, SpreadsheetRecord, import("../../types/index.js").SpreadsheetFieldRulesInput<unknown> | undefined>;
 }[];

package/dist/runtime/spreadsheet/utils/references/sources.js

@@ -5,8 +5,12 @@ export function collectSpreadsheetReferenceTokens(value) {
   const tokens = [];
   for (const item of items) {
     const token = String(item ?? "").trim();
-    if (!token) continue;
-    if (tokens.includes(token)) continue;
+    if (!token) {
+      continue;
+    }
+    if (tokens.includes(token)) {
+      continue;
+    }
     tokens.push(token);
   }
   return tokens;
@@ -23,11 +27,11 @@ export function collectSpreadsheetReferenceSources(references, rows) {
     }
     return [
       {
-        reference: entry,
-        entries: Array.from(entries.entries()).map(([value, rowIndexes]) => ({
-          value,
-          rowIndexes
-        }))
+        entries: [...entries.entries()].map(([value, rowIndexes]) => ({
+          rowIndexes,
+          value
+        })),
+        reference: entry
       }
     ];
   });

package/dist/runtime/spreadsheet/utils/rows/headers.js

@@ -2,8 +2,8 @@ import { normalizeSpreadsheetText } from "./shared.js";
 export function createSpreadsheetHeaderCells(headers) {
   return headers.map((header, index) => ({
     index,
+    normalized: normalizeSpreadsheetText(header),
     raw: header,
-    text: String(header ?? "").trim(),
-    normalized: normalizeSpreadsheetText(header)
+    text: String(header ?? "").trim()
   }));
 }

package/dist/runtime/spreadsheet/utils/rows/matching.d.ts

@@ -1,5 +1,4 @@
-import type { SpreadsheetHeaderCell, SpreadsheetStaticColumn } from '../../types/index.js';
-import type { SpreadsheetColumnMatch, SpreadsheetDynamicColumnMatch, SpreadsheetUnmatchedColumn } from '../../types/index.js';
+import type { SpreadsheetHeaderCell, SpreadsheetStaticColumn, SpreadsheetColumnMatch, SpreadsheetDynamicColumnMatch, SpreadsheetUnmatchedColumn } from '../../types/index.js';
 export declare function flattenSpreadsheetStaticColumns(entries: readonly unknown[]): SpreadsheetStaticColumn[];
 export declare function matchSpreadsheetColumns(columns: readonly SpreadsheetStaticColumn[], headers: readonly SpreadsheetHeaderCell[], manualAssignments?: Readonly<Record<string, string>>): SpreadsheetColumnMatch[];
 export declare function matchSpreadsheetDynamicColumns(columns: readonly unknown[], headers: readonly SpreadsheetHeaderCell[], usedHeaderIndexes?: readonly number[]): SpreadsheetDynamicColumnMatch[];