nuxt-ui-tools 0.1.0

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

@@ -0,0 +1,169 @@
+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.from;
+  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") {
+    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,
+      text: header.text,
+      normalized: normalizeSpreadsheetText(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.slice().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 {
+      key: column.key,
+      columnIndex: header.index,
+      header,
+      column
+    };
+  }).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 [
+      {
+        key: column.key,
+        columnIndex: match.header.index,
+        header: match.header,
+        column
+      }
+    ];
+  });
+  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 [
+      {
+        key: column.rootKey,
+        targetKey: item.id,
+        columnIndex: match.header.index,
+        header: match.header,
+        column,
+        source: item.source,
+        item
+      }
+    ];
+  });
+}
+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 [
+      {
+        key: column.output.into,
+        targetKey: column.targetKey?.(source) ?? column.itemKey?.(source) ?? String(match.header.index),
+        columnIndex: match.header.index,
+        header: match.header,
+        column,
+        source
+      }
+    ];
+  });
+}
+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) ? [] : [{ key: column.key, column }]
+  );
+}

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

@@ -0,0 +1,8 @@
+import type { SpreadsheetColumnDefinition } from '../../types/index.js';
+import type { SpreadsheetColumnMatch, SpreadsheetDynamicColumnMatch, SpreadsheetParsedRow } 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>>[]>;

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

@@ -0,0 +1,179 @@
+import { setSpreadsheetValueAtPath } from "../object.js";
+import {
+  getSpreadsheetOptionLabel,
+  getSpreadsheetOptionValue,
+  resolveSpreadsheetOptionEntries
+} from "../options.js";
+import {
+  applySpreadsheetModifiers,
+  applySpreadsheetNormalization,
+  getSpreadsheetIssueText,
+  isSpreadsheetDynamicCollectionColumn,
+  parseSpreadsheetCellValue
+} from "./shared.js";
+function resolveOptionValue(params) {
+  const issueText = getSpreadsheetIssueText();
+  const text = String(params.raw ?? "").trim();
+  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) {
+    const normalizedToken = applySpreadsheetNormalization(token, params.definition.itemModifiers);
+    const match = params.definition.from.find((option) => {
+      const candidate = params.definition.matchBy === "value" ? String(getSpreadsheetOptionValue(option) ?? "") : getSpreadsheetOptionLabel(option);
+      return applySpreadsheetNormalization(candidate, params.definition.itemModifiers) === normalizedToken;
+    });
+    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
+      });
+      continue;
+    }
+    const value = getSpreadsheetOptionValue(match);
+    if (value === void 0) continue;
+    resolvedValues.push(value);
+  }
+  if (params.definition.mode === "multiple") return resolvedValues;
+  return resolvedValues[0];
+}
+function resolveCollectionCellValue(params) {
+  const item = params.match.item;
+  if (!item) return void 0;
+  const valueDefinition = item.value;
+  const text = String(params.raw ?? "").trim();
+  if (!text) return void 0;
+  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());
+  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
+  });
+}
+function applyCollectionValue(params) {
+  const item = params.match.item;
+  if (!item) return;
+  if (params.resolvedValue === void 0) return;
+  const builtValue = item.build ? item.build(
+    Array.isArray(params.resolvedValue) ? {
+      id: item.id,
+      source: params.match.source,
+      values: params.resolvedValue
+    } : {
+      id: item.id,
+      source: params.match.source,
+      value: params.resolvedValue
+    }
+  ) : params.resolvedValue;
+  if (params.column.as === "array") {
+    const existing = params.data[params.column.rootKey];
+    const nextItems = Array.isArray(existing) ? existing : [];
+    const nextValue = item.build ? builtValue : Array.isArray(params.resolvedValue) ? { id: item.id, values: params.resolvedValue } : { id: item.id, value: params.resolvedValue };
+    params.data[params.column.rootKey] = [...nextItems, nextValue];
+    return;
+  }
+  setSpreadsheetValueAtPath(params.data, `${params.column.rootKey}.${item.id}`, builtValue);
+}
+function resolveSpreadsheetDynamicCellValues(column, source, raw, issues, rowIndex, columnIndex, header) {
+  const issueText = getSpreadsheetIssueText();
+  const text = String(raw ?? "").trim();
+  if (!text) return [];
+  const valuesConfig = column.values;
+  const optionsConfig = column.options;
+  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 = [];
+  for (const token of tokens) {
+    const normalizedToken = applySpreadsheetNormalization(token, valuesConfig.itemModifiers);
+    const match = options.find((option) => {
+      const candidate = valuesConfig.resolve === "label" ? getSpreadsheetOptionLabel(option) : String(getSpreadsheetOptionValue(option) ?? "");
+      return applySpreadsheetNormalization(candidate, valuesConfig.itemModifiers) === normalizedToken;
+    });
+    if (!match) {
+      issues.push({
+        level: "error",
+        code: "option.not_found",
+        message: issueText.unrecognizedValue(token),
+        rowIndex,
+        columnKey: column.key,
+        columnIndex,
+        header
+      });
+      continue;
+    }
+    resolvedValues.push(getSpreadsheetOptionValue(match));
+  }
+  return resolvedValues;
+}
+export async function parseSpreadsheetRows(params) {
+  const parsedRows = [];
+  for (const [rowIndex, source] of params.rows.entries()) {
+    const issues = [];
+    const data = {};
+    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
+      };
+      const value = await parseSpreadsheetCellValue(match.column, cell, params.context, issues);
+      if (value !== void 0) setSpreadsheetValueAtPath(data, match.key, value);
+    }
+    for (const entry of params.dynamicMatches ?? []) {
+      const raw = source[entry.columnIndex];
+      if (entry.column.kind === "option-groups") {
+        const values = resolveSpreadsheetDynamicCellValues(
+          entry.column,
+          entry.source,
+          raw,
+          issues,
+          rowIndex,
+          entry.columnIndex,
+          entry.header.text
+        );
+        if (values.length)
+          setSpreadsheetValueAtPath(data, `${entry.key}.${entry.targetKey}`, values);
+        continue;
+      }
+      if (!isSpreadsheetDynamicCollectionColumn(entry.column)) continue;
+      const resolvedValue = resolveCollectionCellValue({
+        column: entry.column,
+        match: entry,
+        raw,
+        issues,
+        rowIndex
+      });
+      applyCollectionValue({
+        data,
+        column: entry.column,
+        match: entry,
+        resolvedValue
+      });
+    }
+    parsedRows.push({
+      index: rowIndex,
+      source,
+      data,
+      issues,
+      isValid: issues.every((issue) => issue.level !== "error")
+    });
+  }
+  return parsedRows;
+}

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

@@ -0,0 +1,18 @@
+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;
+export declare function getSpreadsheetIssueText(): {
+    unrecognizedValue: (value: string) => string;
+    invalidNumberInput: (value: string) => string;
+    invalidBooleanInput: (value: string) => string;
+    missingValue: (field: string) => string;
+    parseFailed: (field: string) => string;
+};
+export declare function parseSpreadsheetCellValue<TContext>(column: SpreadsheetColumnDefinition<string, unknown, boolean, TContext>, cell: SpreadsheetCellValue, context: TContext, issues: SpreadsheetRowIssue[]): Promise<unknown>;

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

@@ -0,0 +1,259 @@
+import { useUiToolsLocale } from "#ui-tools/i18n";
+import { isSpreadsheetRecord } from "../object.js";
+import {
+  getSpreadsheetOptionLabel,
+  getSpreadsheetOptionValue,
+  resolveSpreadsheetOptionEntries
+} from "../options.js";
+import { executeSpreadsheetRules } from "../validation/index.js";
+export function normalizeSpreadsheetText(value) {
+  return String(value ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\s*\*\s*$/g, "").replace(/\s*\(required\)\s*$/gi, "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+export function applySpreadsheetNormalization(value, normalize) {
+  const nextValue = String(value ?? "").trim();
+  if (!normalize?.length) return nextValue;
+  return normalize.reduce((result, token) => {
+    if (token === "trim") return result.trim();
+    if (token === "case-insensitive") return result.toLowerCase();
+    if (token === "accent-insensitive")
+      return result.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    return result;
+  }, nextValue).replace(/\s*\*\s*$/g, "").replace(/\s*\(required\)\s*$/gi, "");
+}
+export function applySpreadsheetModifiers(value, modifiers) {
+  const nextValue = String(value ?? "");
+  if (!modifiers?.length) return nextValue;
+  return modifiers.reduce((result, modifier) => {
+    if (modifier === "trim") return result.trim();
+    if (modifier === "lowercase" || modifier === "case-insensitive") return result.toLowerCase();
+    if (modifier === "uppercase") return result.toUpperCase();
+    if (modifier === "normalizeSpaces") return result.replace(/\s+/g, " ");
+    if (modifier === "accent-insensitive")
+      return result.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    return result;
+  }, nextValue);
+}
+export function isSpreadsheetStaticColumn(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind !== "group" && "key" in value;
+}
+export function isSpreadsheetColumnGroup(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "group" && "columns" in value;
+}
+export function isSpreadsheetDynamicOptionGroupsColumn(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "option-groups";
+}
+export function isSpreadsheetDynamicCollectionColumn(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "collection";
+}
+export function isSpreadsheetDynamicCollectionItem(value) {
+  return isSpreadsheetRecord(value) && "id" in value && "match" in value && "value" in value;
+}
+function hasSpreadsheetColumnResolve(column) {
+  return "resolve" in column && Boolean(column.resolve);
+}
+function resolveSpreadsheetColumnOptionEntries(options, context) {
+  return resolveSpreadsheetOptionEntries(options, { context });
+}
+function resolveSpreadsheetMultipleConfig(multiple) {
+  if (!multiple) return void 0;
+  if (multiple === true) return {};
+  return multiple;
+}
+function splitSpreadsheetMultipleTokens(value, separator) {
+  return value.split(separator ?? ",").map((entry) => entry.trim()).filter(Boolean);
+}
+function parseSpreadsheetNumberValue(value) {
+  const nextValue = Number(value);
+  if (Number.isNaN(nextValue) || !Number.isFinite(nextValue)) return void 0;
+  return nextValue;
+}
+function parseSpreadsheetBooleanValue(value) {
+  const normalized = value.toLowerCase();
+  if (["true", "1", "yes"].includes(normalized)) return true;
+  if (["false", "0", "no"].includes(normalized)) return false;
+  return void 0;
+}
+function pushSpreadsheetParseIssue(params) {
+  params.issues.push({
+    level: "error",
+    code: params.code,
+    message: params.message,
+    rowIndex: params.rowIndex,
+    columnKey: params.columnKey,
+    columnIndex: params.columnIndex,
+    header: params.header
+  });
+}
+export function getSpreadsheetIssueText() {
+  const { t } = useUiToolsLocale();
+  return {
+    unrecognizedValue: (value) => t("spreadsheet.validation.unrecognizedValue", { value }),
+    invalidNumberInput: (value) => t("spreadsheet.validation.invalidNumberInput", { value }),
+    invalidBooleanInput: (value) => t("spreadsheet.validation.invalidBooleanInput", { value }),
+    missingValue: (field) => t("spreadsheet.validation.missingValue", { field }),
+    parseFailed: (field) => t("spreadsheet.validation.parseFailed", { field })
+  };
+}
+function parseSpreadsheetEnumColumnValue(column, token, cell, issues) {
+  const issueText = getSpreadsheetIssueText();
+  if (!token) return void 0;
+  const multipleConfig = resolveSpreadsheetMultipleConfig(column.multiple);
+  const normalizedToken = multipleConfig?.itemModifiers ? applySpreadsheetNormalization(token, multipleConfig.itemModifiers) : token;
+  const match = column.options.find((option) => {
+    const candidate = String(option);
+    if (!multipleConfig?.itemModifiers) return candidate === token;
+    return applySpreadsheetNormalization(candidate, multipleConfig.itemModifiers) === normalizedToken;
+  });
+  if (match !== void 0) return match;
+  pushSpreadsheetParseIssue({
+    issues,
+    code: "enum.not_found",
+    message: issueText.unrecognizedValue(token),
+    rowIndex: cell.rowIndex,
+    columnKey: column.key,
+    columnIndex: cell.columnIndex,
+    header: cell.header
+  });
+  return void 0;
+}
+function parseSpreadsheetOptionColumnValue(column, token, cell, context, issues) {
+  const issueText = getSpreadsheetIssueText();
+  if (!token) return void 0;
+  const options = resolveSpreadsheetColumnOptionEntries(column.options, context);
+  const multipleConfig = resolveSpreadsheetMultipleConfig(column.multiple);
+  const normalizedToken = multipleConfig?.itemModifiers ? applySpreadsheetNormalization(token, multipleConfig.itemModifiers) : token;
+  const match = options.find((option) => {
+    const label = getSpreadsheetOptionLabel(option);
+    const value = getSpreadsheetOptionValue(option);
+    const by = multipleConfig?.matchBy;
+    if (by === "label")
+      return (multipleConfig?.itemModifiers ? applySpreadsheetNormalization(label, multipleConfig.itemModifiers) : label) === normalizedToken;
+    if (by === "value")
+      return (multipleConfig?.itemModifiers ? applySpreadsheetNormalization(String(value ?? ""), multipleConfig.itemModifiers) : String(value ?? "")) === normalizedToken;
+    return token === label || token === String(value ?? "");
+  });
+  if (match === void 0) {
+    pushSpreadsheetParseIssue({
+      issues,
+      code: "option.not_found",
+      message: issueText.unrecognizedValue(token),
+      rowIndex: cell.rowIndex,
+      columnKey: column.key,
+      columnIndex: cell.columnIndex,
+      header: cell.header
+    });
+    return void 0;
+  }
+  return getSpreadsheetOptionValue(match);
+}
+function isSpreadsheetEnumColumn(column) {
+  return column.kind === "enum" && "options" in column && Array.isArray(column.options);
+}
+function isSpreadsheetOptionColumn(column) {
+  return column.kind === "option" && "options" in column;
+}
+function parseSpreadsheetSingleBuiltInValue(column, token, cell, context, issues) {
+  const issueText = getSpreadsheetIssueText();
+  if (column.kind === "text" || column.kind === "email" || column.kind === "date") return token;
+  if (column.kind === "number") {
+    const value = parseSpreadsheetNumberValue(token);
+    if (value !== void 0) return value;
+    pushSpreadsheetParseIssue({
+      issues,
+      code: "number.invalid",
+      message: issueText.invalidNumberInput(token),
+      rowIndex: cell.rowIndex,
+      columnKey: column.key,
+      columnIndex: cell.columnIndex,
+      header: cell.header
+    });
+    return void 0;
+  }
+  if (column.kind === "boolean") {
+    const value = parseSpreadsheetBooleanValue(token);
+    if (value !== void 0) return value;
+    pushSpreadsheetParseIssue({
+      issues,
+      code: "boolean.invalid",
+      message: issueText.invalidBooleanInput(token),
+      rowIndex: cell.rowIndex,
+      columnKey: column.key,
+      columnIndex: cell.columnIndex,
+      header: cell.header
+    });
+    return void 0;
+  }
+  if (isSpreadsheetEnumColumn(column))
+    return parseSpreadsheetEnumColumnValue(column, token, cell, issues);
+  if (isSpreadsheetOptionColumn(column))
+    return parseSpreadsheetOptionColumnValue(column, token, cell, context, issues);
+  return token;
+}
+function createSpreadsheetCellWithModifiers(cell, modifiers) {
+  if (!modifiers?.length) return cell;
+  return {
+    ...cell,
+    text: applySpreadsheetModifiers(cell.text, modifiers)
+  };
+}
+function parseSpreadsheetBuiltInCellValue(column, cell, context, issues) {
+  const nextCell = createSpreadsheetCellWithModifiers(cell, column.modifiers);
+  const multipleConfig = resolveSpreadsheetMultipleConfig(column.multiple);
+  if (!multipleConfig)
+    return parseSpreadsheetSingleBuiltInValue(column, nextCell.text, nextCell, context, issues);
+  if (!nextCell.text) return [];
+  return splitSpreadsheetMultipleTokens(nextCell.text, multipleConfig.separator).flatMap(
+    (token) => {
+      const nextToken = applySpreadsheetModifiers(token, multipleConfig.itemModifiers);
+      const value = parseSpreadsheetSingleBuiltInValue(column, nextToken, nextCell, context, issues);
+      return value === void 0 ? [] : [value];
+    }
+  );
+}
+export async function parseSpreadsheetCellValue(column, cell, context, issues) {
+  const issueText = getSpreadsheetIssueText();
+  const nextCell = createSpreadsheetCellWithModifiers(cell, column.modifiers);
+  const isEmpty = nextCell.text.trim() === "";
+  if (column.required && !hasSpreadsheetColumnResolve(column) && isEmpty) {
+    issues.push({
+      level: "error",
+      code: "cell.required",
+      message: issueText.missingValue(cell.header),
+      rowIndex: cell.rowIndex,
+      columnKey: column.key,
+      columnIndex: cell.columnIndex,
+      header: cell.header
+    });
+  }
+  try {
+    const value = column.parse ? await column.parse({ cell: nextCell, context }) : parseSpreadsheetBuiltInCellValue(column, cell, context, issues);
+    const validationIssues = hasSpreadsheetColumnResolve(column) ? [] : executeSpreadsheetRules({
+      value,
+      rules: column.rules
+    });
+    issues.push(
+      ...validationIssues.map(
+        (issue) => ({
+          ...issue,
+          rowIndex: cell.rowIndex,
+          columnKey: column.key,
+          columnIndex: cell.columnIndex,
+          header: cell.header
+        })
+      )
+    );
+    if (isEmpty && !column.parse) return void 0;
+    return value;
+  } catch (error) {
+    issues.push({
+      level: "error",
+      code: "cell.parse_failed",
+      message: error instanceof Error ? error.message : issueText.parseFailed(cell.header),
+      rowIndex: cell.rowIndex,
+      columnKey: column.key,
+      columnIndex: cell.columnIndex,
+      header: cell.header
+    });
+    return void 0;
+  }
+}

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

@@ -0,0 +1,2 @@
+import type { SpreadsheetParsedRow, SpreadsheetRowSummary } from '../../types/index.js';
+export declare function createSpreadsheetRowSummary(rows: readonly SpreadsheetParsedRow[]): SpreadsheetRowSummary;

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

@@ -0,0 +1,10 @@
+export function createSpreadsheetRowSummary(rows) {
+  const invalidRows = rows.filter((row) => !row.isValid).length;
+  const issueCount = rows.reduce((total, row) => total + row.issues.length, 0);
+  return {
+    totalRows: rows.length,
+    validRows: rows.length - invalidRows,
+    invalidRows,
+    issueCount
+  };
+}

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

@@ -0,0 +1,9 @@
+import type { SpreadsheetBinarySource, SpreadsheetWorkbookData, SpreadsheetWorkbookSheet } from '../../types/index.js';
+export declare function parseSpreadsheetWorkbook(params: {
+    source: SpreadsheetBinarySource;
+    fileName?: string;
+}): Promise<SpreadsheetWorkbookData>;
+export declare function getDefaultSpreadsheetSheetName(workbook: SpreadsheetWorkbookData | null): string | undefined;
+export declare function getSpreadsheetSheet(workbook: SpreadsheetWorkbookData | null, sheetName: string | undefined): SpreadsheetWorkbookSheet | null;
+export declare function getSpreadsheetHeaders(sheet: SpreadsheetWorkbookSheet | null, headerRowIndex: number): readonly unknown[];
+export declare function getSpreadsheetDataRows(sheet: SpreadsheetWorkbookSheet | null, headerRowIndex: number): (readonly unknown[])[];