nuxt-ui-tools 1.11.2 → 1.13.0

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

@@ -1,172 +0,0 @@
-import { isFunction, isString } from "#ui-tools/shared/utils/predicate";
-import {
-  cloneSpreadsheetRowData,
-  deleteSpreadsheetValueAtPath,
-  getSpreadsheetValueAtPath,
-  setSpreadsheetValueAtPath,
-  isSpreadsheetRecord
-} from "../object.js";
-import { resolveSpreadsheetOptionEntries } from "../options.js";
-import { executeSpreadsheetRules, resolveSpreadsheetRelationRules } from "../validation/core.js";
-import { createSpreadsheetReferenceCandidates } from "./candidates.js";
-import { isSpreadsheetResolutionDefinition, normalizeSpreadsheetRuntimeResolutions } from "./guards.js";
-import { collectSpreadsheetReferenceSources, collectSpreadsheetReferenceTokens } from "./sources.js";
-function isSpreadsheetRelationDefinition(value) {
-  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({
-        options: resolveSpreadsheetOptionEntries(reference.options, {
-          context: params.context
-        }),
-        reference,
-        sourceValue: entry.value
-      });
-      const bestCandidate = candidates[0];
-      const isMatched = Boolean(bestCandidate && bestCandidate.score >= 0.9);
-      return {
-        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,
-        sourceValue: entry.value,
-        status: isMatched ? "matched" : "unresolved",
-        targetField: reference.targetField
-      };
-    })
-  );
-}
-export function applySpreadsheetReferenceResolutions(params) {
-  const resolutionDefinitions = normalizeSpreadsheetRuntimeResolutions(params.references);
-  const resolutionsBySourceField = params.resolutions.reduce((groups, resolution) => {
-    const entries = groups.get(resolution.sourceField) ?? [];
-    groups.set(resolution.sourceField, [...entries, resolution]);
-    return groups;
-  }, /* @__PURE__ */ new Map());
-  return params.rows.map((row) => {
-    const data = cloneSpreadsheetRowData(row.data);
-    const issues = [...row.issues];
-    const multiValueOutputs = /* @__PURE__ */ new Map();
-    for (const definition of resolutionDefinitions) {
-      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;
-      }
-      for (const sourceValue of sourceTokens) {
-        const resolution = resolutions.find((entry) => entry.sourceValue === sourceValue);
-        if (!resolution) {
-          continue;
-        }
-        if (resolution.selectedValue !== void 0) {
-          if (Array.isArray(rawValue)) {
-            const values = multiValueOutputs.get(resolution.outputField) ?? [];
-            multiValueOutputs.set(resolution.outputField, [...values, resolution.selectedValue]);
-          } else {
-            setSpreadsheetValueAtPath(data, resolution.outputField, resolution.selectedValue);
-          }
-          continue;
-        }
-      }
-    }
-    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({
-        rules: reference.rules,
-        value
-      });
-      issues.push(
-        ...referenceIssues.map(
-          (issue) => ({
-            ...issue,
-            columnKey: reference.targetField,
-            rowIndex: row.index
-          })
-        )
-      );
-    }
-    for (const relation of params.relations ?? []) {
-      if (!isSpreadsheetRelationDefinition(relation)) {
-        continue;
-      }
-      if (relation.condition && !relation.condition(data)) {
-        continue;
-      }
-      const relationIssues = executeSpreadsheetRules({
-        rules: resolveSpreadsheetRelationRules({
-          row: data,
-          rules: relation.rules
-        }),
-        value: getSpreadsheetValueAtPath(data, relation.column)
-      });
-      issues.push(
-        ...relationIssues.map(
-          (issue) => ({
-            ...issue,
-            columnKey: relation.column,
-            rowIndex: row.index
-          })
-        )
-      );
-    }
-    return {
-      data,
-      index: row.index,
-      isValid: issues.every((issue) => issue.level !== "error"),
-      issues,
-      source: row.source
-    };
-  });
-}
-export function createSpreadsheetReferenceQueryRequests(params) {
-  return createSpreadsheetReferenceResolutions({
-    context: params.context,
-    references: params.references,
-    rows: params.rows
-  }).flatMap((resolution) => {
-    const referenceEntry = normalizeSpreadsheetRuntimeResolutions(params.references).find(
-      (entry) => entry.targetField === (resolution.targetField ?? resolution.referenceField)
-    );
-    if (!isSpreadsheetResolutionDefinition(referenceEntry)) {
-      return [];
-    }
-    const reference = referenceEntry;
-    if (!reference.getOptions || resolution.status === "matched") {
-      return [];
-    }
-    const sourceRow = params.rows.find((row) => row.index === resolution.rowIndexes[0]);
-    if (!sourceRow) {
-      return [];
-    }
-    return [
-      {
-        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,3 +0,0 @@
-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,26 +0,0 @@
-export function normalizeSpreadsheetReferenceText(value) {
-  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;
-  }
-  const sourceTokens = normalizedSource.split(" ");
-  const labelTokens = normalizedLabel.split(" ");
-  const overlap = sourceTokens.filter((token) => labelTokens.includes(token)).length;
-  if (!overlap) {
-    return 0;
-  }
-  return overlap / Math.max(sourceTokens.length, labelTokens.length);
-}

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

@@ -1,9 +0,0 @@
-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: {
-        rowIndexes: number[];
-        value: string;
-    }[];
-    reference: import("../../types/index.js").SpreadsheetResolutionDefinition<"reference" | "column", 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

@@ -1,38 +0,0 @@
-import { getSpreadsheetValueAtPath } from "../object.js";
-import { normalizeSpreadsheetRuntimeResolutions } from "./guards.js";
-export function collectSpreadsheetReferenceTokens(value) {
-  const items = Array.isArray(value) ? value : [value];
-  const tokens = [];
-  for (const item of items) {
-    const token = String(item ?? "").trim();
-    if (!token) {
-      continue;
-    }
-    if (tokens.includes(token)) {
-      continue;
-    }
-    tokens.push(token);
-  }
-  return tokens;
-}
-export function collectSpreadsheetReferenceSources(references, rows) {
-  return normalizeSpreadsheetRuntimeResolutions(references).flatMap((entry) => {
-    const entries = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const rawValue = getSpreadsheetValueAtPath(row.data, entry.sourceField);
-      for (const sourceValue of collectSpreadsheetReferenceTokens(rawValue)) {
-        const rowIndexes = entries.get(sourceValue) ?? [];
-        entries.set(sourceValue, [...rowIndexes, row.index]);
-      }
-    }
-    return [
-      {
-        entries: [...entries.entries()].map(([value, rowIndexes]) => ({
-          rowIndexes,
-          value
-        })),
-        reference: entry
-      }
-    ];
-  });
-}

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

@@ -1,4 +0,0 @@
-export * from './headers.js';
-export * from './matching.js';
-export * from './parsing.js';
-export * from './summary.js';

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

@@ -1,4 +0,0 @@
-export * from "./headers.js";
-export * from "./matching.js";
-export * from "./parsing.js";
-export * from "./summary.js";

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

@@ -1,2 +0,0 @@
-import type { SpreadsheetHeaderCell } from '../../types/index.js';
-export declare function createSpreadsheetHeaderCells(headers: readonly unknown[]): SpreadsheetHeaderCell[];

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

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

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

@@ -1 +0,0 @@
-export * from './core.js';

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

@@ -1 +0,0 @@
-export * from "./core.js";

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

@@ -1,5 +0,0 @@
-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[];
-export declare function getSpreadsheetUnmatchedColumns(columns: readonly SpreadsheetStaticColumn[], matches: readonly SpreadsheetColumnMatch[]): SpreadsheetUnmatchedColumn[];

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

@@ -1,209 +0,0 @@
-import { isString } from "#ui-tools/shared/utils/predicate";
-import {
-  applySpreadsheetNormalization,
-  isSpreadsheetColumnGroup,
-  isSpreadsheetDynamicCollectionItem,
-  isSpreadsheetDynamicCollectionColumn,
-  isSpreadsheetDynamicOptionGroupsColumn,
-  isSpreadsheetStaticColumn,
-  normalizeSpreadsheetText
-} from "./shared.js";
-const defaultHeaderModifiers = ["trim", "case-insensitive", "accent-insensitive"];
-function getDefaultMatchDefinition(column) {
-  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 (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;
-  }
-  return matcher({
-    header: {
-      index: header.index,
-      normalized: normalizeSpreadsheetText(header.text),
-      text: header.text
-    }
-  });
-}
-function findHeaderMatch(headers, definition, usedHeaderIndexes) {
-  const candidates = headers.flatMap((header) => {
-    if (usedHeaderIndexes.has(header.index)) {
-      return [];
-    }
-    const scores = definition.headers.map((matcher) => scoreHeaderMatcher(header, matcher)).filter((score) => score !== null);
-    if (!scores.length) {
-      return [];
-    }
-    const bestScore = Math.max(...scores);
-    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].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) {
-    return [column.header.template({ source })];
-  }
-  if (strategy === "patterns" && column.header?.patterns) {
-    return column.header.patterns({ source });
-  }
-  return [label];
-}
-function createOptionGroupsMatchDefinition(column, source) {
-  return {
-    headers: getDynamicHeaderPatterns(column, source),
-    prefer: "first"
-  };
-}
-export function flattenSpreadsheetStaticColumns(entries) {
-  return entries.flatMap((entry) => {
-    if (isSpreadsheetColumnGroup(entry)) {
-      return flattenSpreadsheetStaticColumns(entry.columns);
-    }
-    if (isSpreadsheetStaticColumn(entry)) {
-      return [entry];
-    }
-    return [];
-  });
-}
-export function matchSpreadsheetColumns(columns, headers, manualAssignments = {}) {
-  const usedHeaderIndexes = /* @__PURE__ */ new Set();
-  const matchedKeys = /* @__PURE__ */ new Set();
-  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;
-    }
-    usedHeaderIndexes.add(header.index);
-    matchedKeys.add(column.key);
-    return {
-      column,
-      columnIndex: header.index,
-      header,
-      key: column.key
-    };
-  }).filter((match) => match !== null);
-  const automaticMatches = columns.flatMap((column) => {
-    if (matchedKeys.has(column.key)) {
-      return [];
-    }
-    const match = findHeaderMatch(headers, getDefaultMatchDefinition(column), usedHeaderIndexes);
-    if (!match) {
-      return [];
-    }
-    usedHeaderIndexes.add(match.header.index);
-    return [
-      {
-        column,
-        columnIndex: match.header.index,
-        header: match.header,
-        key: column.key
-      }
-    ];
-  });
-  return [...manualMatches, ...automaticMatches];
-}
-function matchCollectionColumn(column, headers, reservedHeaderIndexes) {
-  return column.items.flatMap((entry) => {
-    if (!isSpreadsheetDynamicCollectionItem(entry)) {
-      return [];
-    }
-    const item = entry;
-    const match = findHeaderMatch(headers, item.match, reservedHeaderIndexes);
-    if (!match) {
-      return [];
-    }
-    reservedHeaderIndexes.add(match.header.index);
-    return [
-      {
-        column,
-        columnIndex: match.header.index,
-        header: match.header,
-        item,
-        key: column.rootKey,
-        source: item.source,
-        targetKey: item.id
-      }
-    ];
-  });
-}
-function matchOptionGroupsColumn(column, headers, reservedHeaderIndexes) {
-  const sourceItems = column.source ?? [];
-  return sourceItems.flatMap((source) => {
-    const match = findHeaderMatch(
-      headers,
-      createOptionGroupsMatchDefinition(column, source),
-      reservedHeaderIndexes
-    );
-    if (!match) {
-      return [];
-    }
-    reservedHeaderIndexes.add(match.header.index);
-    return [
-      {
-        column,
-        columnIndex: match.header.index,
-        header: match.header,
-        key: column.output.into,
-        source,
-        targetKey: column.targetKey?.(source) ?? column.itemKey?.(source) ?? String(match.header.index)
-      }
-    ];
-  });
-}
-export function matchSpreadsheetDynamicColumns(columns, headers, usedHeaderIndexes = []) {
-  const reservedHeaderIndexes = new Set(usedHeaderIndexes);
-  const matches = [];
-  for (const entry of columns) {
-    if (isSpreadsheetDynamicOptionGroupsColumn(entry)) {
-      matches.push(...matchOptionGroupsColumn(entry, headers, reservedHeaderIndexes));
-      continue;
-    }
-    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) ? [] : [{ column, key: column.key }]
-  );
-}

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

@@ -1,7 +0,0 @@
-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<SpreadsheetRecord>[]>;