nuxt-ui-tools 0.1.3 → 1.0.0

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

@@ -1,3 +1,4 @@
+import { isString } from "#ui-tools/shared/utils/predicate";
 import {
   applySpreadsheetNormalization,
   isSpreadsheetColumnGroup,
@@ -9,55 +10,75 @@ import {
 } from "./shared.js";
 const defaultHeaderModifiers = ["trim", "case-insensitive", "accent-insensitive"];
 function getDefaultMatchDefinition(column) {
-  if (column.match) return column.match;
-  const from = column.from;
-  if (!from)
+  if (column.match) {
+    return column.match;
+  }
+  const { from } = column;
+  if (!from) {
     return {
       headers: [column.key],
       prefer: "first"
     };
+  }
   return {
     headers: Array.isArray(from) ? from : [from],
     prefer: "first"
   };
 }
 function scoreHeaderMatcher(header, matcher) {
-  if (typeof matcher === "string") {
+  if (isString(matcher)) {
     const left = applySpreadsheetNormalization(header.text, defaultHeaderModifiers);
     const right = applySpreadsheetNormalization(matcher, defaultHeaderModifiers);
     return left === right ? 1 : null;
   }
-  if (matcher instanceof RegExp) return matcher.test(header.text) ? 0.95 : null;
+  if (matcher instanceof RegExp) {
+    return matcher.test(header.text) ? 0.95 : null;
+  }
   return matcher({
     header: {
       index: header.index,
-      text: header.text,
-      normalized: normalizeSpreadsheetText(header.text)
+      normalized: normalizeSpreadsheetText(header.text),
+      text: header.text
     }
   });
 }
 function findHeaderMatch(headers, definition, usedHeaderIndexes) {
   const candidates = headers.flatMap((header) => {
-    if (usedHeaderIndexes.has(header.index)) return [];
+    if (usedHeaderIndexes.has(header.index)) {
+      return [];
+    }
     const scores = definition.headers.map((matcher) => scoreHeaderMatcher(header, matcher)).filter((score) => score !== null);
-    if (!scores.length) return [];
+    if (!scores.length) {
+      return [];
+    }
     const bestScore = Math.max(...scores);
-    if (definition.minScore !== void 0 && bestScore < definition.minScore) return [];
+    if (definition.minScore !== void 0 && bestScore < definition.minScore) {
+      return [];
+    }
     return [{ header, score: bestScore }];
   });
-  if (!candidates.length) return null;
-  if (definition.prefer !== "best-score") return candidates[0];
-  return candidates.slice().sort((left, right) => {
-    if (left.score !== right.score) return right.score - left.score;
+  if (!candidates.length) {
+    return null;
+  }
+  if (definition.prefer !== "best-score") {
+    return candidates[0];
+  }
+  return [...candidates].sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
     return left.header.index - right.header.index;
   })[0];
 }
 function getDynamicHeaderPatterns(column, source) {
   const label = column.itemLabel?.(source) ?? column.itemKey?.(source) ?? column.key;
   const strategy = column.header?.strategy ?? "exact";
-  if (strategy === "template" && column.header?.template)
+  if (strategy === "template" && column.header?.template) {
     return [column.header.template({ source })];
-  if (strategy === "patterns" && column.header?.patterns) return column.header.patterns({ source });
+  }
+  if (strategy === "patterns" && column.header?.patterns) {
+    return column.header.patterns({ source });
+  }
   return [label];
 }
 function createOptionGroupsMatchDefinition(column, source) {
@@ -68,8 +89,12 @@ function createOptionGroupsMatchDefinition(column, source) {
 }
 export function flattenSpreadsheetStaticColumns(entries) {
   return entries.flatMap((entry) => {
-    if (isSpreadsheetColumnGroup(entry)) return flattenSpreadsheetStaticColumns(entry.columns);
-    if (isSpreadsheetStaticColumn(entry)) return [entry];
+    if (isSpreadsheetColumnGroup(entry)) {
+      return flattenSpreadsheetStaticColumns(entry.columns);
+    }
+    if (isSpreadsheetStaticColumn(entry)) {
+      return [entry];
+    }
     return [];
   });
 }
@@ -79,28 +104,36 @@ export function matchSpreadsheetColumns(columns, headers, manualAssignments = {}
   const manualMatches = Object.entries(manualAssignments).map(([headerIndex, key]) => {
     const column = columns.find((entry) => entry.key === key);
     const header = headers.find((entry) => entry.index === Number(headerIndex));
-    if (!column || !header) return null;
-    if (usedHeaderIndexes.has(header.index) || matchedKeys.has(column.key)) return null;
+    if (!column || !header) {
+      return null;
+    }
+    if (usedHeaderIndexes.has(header.index) || matchedKeys.has(column.key)) {
+      return null;
+    }
     usedHeaderIndexes.add(header.index);
     matchedKeys.add(column.key);
     return {
-      key: column.key,
+      column,
       columnIndex: header.index,
       header,
-      column
+      key: column.key
     };
   }).filter((match) => match !== null);
   const automaticMatches = columns.flatMap((column) => {
-    if (matchedKeys.has(column.key)) return [];
+    if (matchedKeys.has(column.key)) {
+      return [];
+    }
     const match = findHeaderMatch(headers, getDefaultMatchDefinition(column), usedHeaderIndexes);
-    if (!match) return [];
+    if (!match) {
+      return [];
+    }
     usedHeaderIndexes.add(match.header.index);
     return [
       {
-        key: column.key,
+        column,
         columnIndex: match.header.index,
         header: match.header,
-        column
+        key: column.key
       }
     ];
   });
@@ -108,20 +141,24 @@ export function matchSpreadsheetColumns(columns, headers, manualAssignments = {}
 }
 function matchCollectionColumn(column, headers, reservedHeaderIndexes) {
   return column.items.flatMap((entry) => {
-    if (!isSpreadsheetDynamicCollectionItem(entry)) return [];
+    if (!isSpreadsheetDynamicCollectionItem(entry)) {
+      return [];
+    }
     const item = entry;
     const match = findHeaderMatch(headers, item.match, reservedHeaderIndexes);
-    if (!match) return [];
+    if (!match) {
+      return [];
+    }
     reservedHeaderIndexes.add(match.header.index);
     return [
       {
-        key: column.rootKey,
-        targetKey: item.id,
+        column,
         columnIndex: match.header.index,
         header: match.header,
-        column,
+        item,
+        key: column.rootKey,
         source: item.source,
-        item
+        targetKey: item.id
       }
     ];
   });
@@ -134,16 +171,18 @@ function matchOptionGroupsColumn(column, headers, reservedHeaderIndexes) {
       createOptionGroupsMatchDefinition(column, source),
       reservedHeaderIndexes
     );
-    if (!match) return [];
+    if (!match) {
+      return [];
+    }
     reservedHeaderIndexes.add(match.header.index);
     return [
       {
-        key: column.output.into,
-        targetKey: column.targetKey?.(source) ?? column.itemKey?.(source) ?? String(match.header.index),
+        column,
         columnIndex: match.header.index,
         header: match.header,
-        column,
-        source
+        key: column.output.into,
+        source,
+        targetKey: column.targetKey?.(source) ?? column.itemKey?.(source) ?? String(match.header.index)
       }
     ];
   });
@@ -156,14 +195,15 @@ export function matchSpreadsheetDynamicColumns(columns, headers, usedHeaderIndex
       matches.push(...matchOptionGroupsColumn(entry, headers, reservedHeaderIndexes));
       continue;
     }
-    if (isSpreadsheetDynamicCollectionColumn(entry))
+    if (isSpreadsheetDynamicCollectionColumn(entry)) {
       matches.push(...matchCollectionColumn(entry, headers, reservedHeaderIndexes));
+    }
   }
   return matches;
 }
 export function getSpreadsheetUnmatchedColumns(columns, matches) {
   const matchedKeys = new Set(matches.map((match) => match.key));
   return columns.flatMap(
-    (column) => matchedKeys.has(column.key) ? [] : [{ key: column.key, column }]
+    (column) => matchedKeys.has(column.key) ? [] : [{ column, key: column.key }]
   );
 }

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

@@ -1,8 +1,7 @@
-import type { SpreadsheetColumnDefinition } from '../../types/index.js';
-import type { SpreadsheetColumnMatch, SpreadsheetDynamicColumnMatch, SpreadsheetParsedRow } from '../../types/index.js';
+import type { SpreadsheetColumnDefinition, SpreadsheetColumnMatch, SpreadsheetDynamicColumnMatch, SpreadsheetParsedRow, SpreadsheetRecord } from '../../types/index.js';
 export declare function parseSpreadsheetRows<TContext>(params: {
     rows: readonly (readonly unknown[])[];
     matches: readonly SpreadsheetColumnMatch<SpreadsheetColumnDefinition<string, unknown, boolean, TContext>>[];
     dynamicMatches?: readonly SpreadsheetDynamicColumnMatch[];
     context: TContext;
-}): Promise<SpreadsheetParsedRow<Record<string, unknown>>[]>;
+}): Promise<SpreadsheetParsedRow<SpreadsheetRecord>[]>;

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

@@ -14,7 +14,9 @@ import {
 function resolveOptionValue(params) {
   const issueText = getSpreadsheetIssueText();
   const text = String(params.raw ?? "").trim();
-  if (!text) return params.definition.mode === "multiple" ? [] : void 0;
+  if (!text) {
+    return params.definition.mode === "multiple" ? [] : void 0;
+  }
   const tokens = params.definition.mode === "multiple" ? text.split(params.definition.separator ?? ",").map((entry) => entry.trim()).filter(Boolean) : [text];
   const resolvedValues = [];
   for (const token of tokens) {
@@ -25,48 +27,67 @@ function resolveOptionValue(params) {
     });
     if (!match) {
       params.issues.push({
-        level: "error",
         code: "option.not_found",
-        message: issueText.unrecognizedValue(token),
-        rowIndex: params.rowIndex,
-        columnKey: params.columnKey,
         columnIndex: params.columnIndex,
-        header: params.header
+        columnKey: params.columnKey,
+        header: params.header,
+        level: "error",
+        message: issueText.unrecognizedValue(token),
+        rowIndex: params.rowIndex
       });
       continue;
     }
     const value = getSpreadsheetOptionValue(match);
-    if (value === void 0) continue;
+    if (value === void 0) {
+      continue;
+    }
     resolvedValues.push(value);
   }
-  if (params.definition.mode === "multiple") return resolvedValues;
+  if (params.definition.mode === "multiple") {
+    return resolvedValues;
+  }
   return resolvedValues[0];
 }
 function resolveCollectionCellValue(params) {
-  const item = params.match.item;
-  if (!item) return void 0;
+  const { item } = params.match;
+  if (!item) {
+    return;
+  }
   const valueDefinition = item.value;
   const text = String(params.raw ?? "").trim();
-  if (!text) return void 0;
-  if (valueDefinition.kind === "text")
+  if (!text) {
+    return;
+  }
+  if (valueDefinition.kind === "text") {
     return applySpreadsheetModifiers(text, valueDefinition.modifiers);
-  if (valueDefinition.kind === "number") return Number(text);
-  if (valueDefinition.kind === "date") return text;
-  if (valueDefinition.kind === "boolean") return ["true", "1", "yes"].includes(text.toLowerCase());
+  }
+  if (valueDefinition.kind === "number") {
+    return Number(text);
+  }
+  if (valueDefinition.kind === "date") {
+    return text;
+  }
+  if (valueDefinition.kind === "boolean") {
+    return ["true", "1", "yes"].includes(text.toLowerCase());
+  }
   return resolveOptionValue({
-    definition: valueDefinition,
-    raw: params.raw,
-    issues: params.issues,
-    rowIndex: params.rowIndex,
     columnIndex: params.match.columnIndex,
     columnKey: item.id,
-    header: params.match.header.text
+    definition: valueDefinition,
+    header: params.match.header.text,
+    issues: params.issues,
+    raw: params.raw,
+    rowIndex: params.rowIndex
   });
 }
 function applyCollectionValue(params) {
-  const item = params.match.item;
-  if (!item) return;
-  if (params.resolvedValue === void 0) return;
+  const { item } = params.match;
+  if (!item) {
+    return;
+  }
+  if (params.resolvedValue === void 0) {
+    return;
+  }
   const builtValue = item.build ? item.build(
     Array.isArray(params.resolvedValue) ? {
       id: item.id,
@@ -90,10 +111,14 @@ function applyCollectionValue(params) {
 function resolveSpreadsheetDynamicCellValues(column, source, raw, issues, rowIndex, columnIndex, header) {
   const issueText = getSpreadsheetIssueText();
   const text = String(raw ?? "").trim();
-  if (!text) return [];
+  if (!text) {
+    return [];
+  }
   const valuesConfig = column.values;
   const optionsConfig = column.options;
-  if (!valuesConfig || !optionsConfig) return [];
+  if (!valuesConfig || !optionsConfig) {
+    return [];
+  }
   const tokens = valuesConfig.mode === "csv" ? text.split(valuesConfig.separator ?? ",").map((entry) => entry.trim()).filter(Boolean) : [text];
   const options = resolveSpreadsheetOptionEntries(optionsConfig, source);
   const resolvedValues = [];
@@ -105,13 +130,13 @@ function resolveSpreadsheetDynamicCellValues(column, source, raw, issues, rowInd
     });
     if (!match) {
       issues.push({
-        level: "error",
         code: "option.not_found",
-        message: issueText.unrecognizedValue(token),
-        rowIndex,
-        columnKey: column.key,
         columnIndex,
-        header
+        columnKey: column.key,
+        header,
+        level: "error",
+        message: issueText.unrecognizedValue(token),
+        rowIndex
       });
       continue;
     }
@@ -127,14 +152,16 @@ export async function parseSpreadsheetRows(params) {
     for (const match of params.matches) {
       const raw = source[match.columnIndex];
       const cell = {
-        text: String(raw ?? "").trim(),
-        raw,
-        header: match.header.text,
         columnIndex: match.columnIndex,
-        rowIndex
+        header: match.header.text,
+        raw,
+        rowIndex,
+        text: String(raw ?? "").trim()
       };
       const value = await parseSpreadsheetCellValue(match.column, cell, params.context, issues);
-      if (value !== void 0) setSpreadsheetValueAtPath(data, match.key, value);
+      if (value !== void 0) {
+        setSpreadsheetValueAtPath(data, match.key, value);
+      }
     }
     for (const entry of params.dynamicMatches ?? []) {
       const raw = source[entry.columnIndex];
@@ -148,31 +175,34 @@ export async function parseSpreadsheetRows(params) {
           entry.columnIndex,
           entry.header.text
         );
-        if (values.length)
+        if (values.length) {
           setSpreadsheetValueAtPath(data, `${entry.key}.${entry.targetKey}`, values);
+        }
+        continue;
+      }
+      if (!isSpreadsheetDynamicCollectionColumn(entry.column)) {
         continue;
       }
-      if (!isSpreadsheetDynamicCollectionColumn(entry.column)) continue;
       const resolvedValue = resolveCollectionCellValue({
         column: entry.column,
+        issues,
         match: entry,
         raw,
-        issues,
         rowIndex
       });
       applyCollectionValue({
-        data,
         column: entry.column,
+        data,
         match: entry,
         resolvedValue
       });
     }
     parsedRows.push({
-      index: rowIndex,
-      source,
       data,
+      index: rowIndex,
+      isValid: issues.every((issue) => issue.level !== "error"),
       issues,
-      isValid: issues.every((issue) => issue.level !== "error")
+      source
     });
   }
   return parsedRows;

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

@@ -1,18 +1,17 @@
-import type { SpreadsheetColumnDefinition, SpreadsheetDynamicCollectionItemDefinition, SpreadsheetDynamicCollectionDefinition, SpreadsheetDynamicOptionGroupsDefinition } from '../../types/index.js';
-import type { SpreadsheetCellValue, SpreadsheetModifier, SpreadsheetRowIssue, SpreadsheetStaticColumn, SpreadsheetStaticColumnGroup } from '../../types/index.js';
-export declare function normalizeSpreadsheetText(value: unknown): string;
-export declare function applySpreadsheetNormalization(value: unknown, normalize: readonly SpreadsheetModifier[] | undefined): string;
-export declare function applySpreadsheetModifiers(value: unknown, modifiers: readonly string[] | undefined): string;
-export declare function isSpreadsheetStaticColumn(value: unknown): value is SpreadsheetStaticColumn;
-export declare function isSpreadsheetColumnGroup(value: unknown): value is SpreadsheetStaticColumnGroup;
-export declare function isSpreadsheetDynamicOptionGroupsColumn(value: unknown): value is SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown>;
-export declare function isSpreadsheetDynamicCollectionColumn(value: unknown): value is SpreadsheetDynamicCollectionDefinition<string, 'array' | 'record'>;
-export declare function isSpreadsheetDynamicCollectionItem(value: unknown): value is SpreadsheetDynamicCollectionItemDefinition;
+import type { SpreadsheetColumnDefinition, SpreadsheetDynamicCollectionItemDefinition, SpreadsheetDynamicCollectionDefinition, SpreadsheetDynamicOptionGroupsDefinition, SpreadsheetCellValue, SpreadsheetModifier, SpreadsheetRowIssue, SpreadsheetStaticColumn, SpreadsheetStaticColumnGroup, SpreadsheetValue } from '../../types/index.js';
+export declare function normalizeSpreadsheetText(value: SpreadsheetValue): string;
+export declare function applySpreadsheetNormalization(value: SpreadsheetValue, normalize: readonly SpreadsheetModifier[] | undefined): string;
+export declare function applySpreadsheetModifiers(value: SpreadsheetValue, modifiers: readonly string[] | undefined): string;
+export declare function isSpreadsheetStaticColumn(value: SpreadsheetValue): value is SpreadsheetStaticColumn;
+export declare function isSpreadsheetColumnGroup(value: SpreadsheetValue): value is SpreadsheetStaticColumnGroup;
+export declare function isSpreadsheetDynamicOptionGroupsColumn(value: SpreadsheetValue): value is SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown>;
+export declare function isSpreadsheetDynamicCollectionColumn(value: SpreadsheetValue): value is SpreadsheetDynamicCollectionDefinition<string, 'array' | 'record'>;
+export declare function isSpreadsheetDynamicCollectionItem(value: SpreadsheetValue): value is SpreadsheetDynamicCollectionItemDefinition;
 export declare function getSpreadsheetIssueText(): {
-    unrecognizedValue: (value: string) => string;
-    invalidNumberInput: (value: string) => string;
     invalidBooleanInput: (value: string) => string;
+    invalidNumberInput: (value: string) => string;
     missingValue: (field: string) => string;
     parseFailed: (field: string) => string;
+    unrecognizedValue: (value: string) => string;
 };
 export declare function parseSpreadsheetCellValue<TContext>(column: SpreadsheetColumnDefinition<string, unknown, boolean, TContext>, cell: SpreadsheetCellValue, context: TContext, issues: SpreadsheetRowIssue[]): Promise<unknown>;