nuxt-ui-tools 0.1.0

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

@@ -0,0 +1,25 @@
+export function createSpreadsheetContextQueries(items) {
+  return items.map((item) => item.query());
+}
+export function createSpreadsheetContextData(items, results) {
+  return items.reduce(
+    (acc, item, index) => ({
+      ...acc,
+      [item.key]: results[index]?.data
+    }),
+    {}
+  );
+}
+export function createSpreadsheetContextStatus(results) {
+  const isPending = results.some((result) => Boolean(result.isPending));
+  const isFetching = results.some((result) => Boolean(result.isFetching));
+  const isReady = !results.length || results.every((result) => Boolean(result.isSuccess));
+  const isRefreshing = results.some((result) => Boolean(result.isRefetching));
+  return {
+    initialized: true,
+    isPending,
+    isFetching,
+    isReady,
+    isRefreshing
+  };
+}

package/dist/runtime/spreadsheet/utils/display.d.ts

@@ -0,0 +1,5 @@
+export type SpreadsheetDisplayLabel = string | number | (() => string | number) | undefined;
+export declare function resolveSpreadsheetDisplayLabel(value: SpreadsheetDisplayLabel, fallback: string): string;
+export declare function humanizeSpreadsheetKey(value: string): string;
+export declare function snakeCaseSpreadsheetKey(value: string): string;
+export declare function formatSpreadsheetCell(value: unknown): string;

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

@@ -0,0 +1,16 @@
+export function resolveSpreadsheetDisplayLabel(value, fallback) {
+  if (typeof value === "function") return String(value());
+  return value == null ? fallback : String(value);
+}
+export function humanizeSpreadsheetKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+export function snakeCaseSpreadsheetKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+export function formatSpreadsheetCell(value) {
+  if (value == null) return "\u2014";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}

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

@@ -0,0 +1,6 @@
+export * from './builders/index.js';
+export * from './context.js';
+export * from './references/index.js';
+export * from './rows/index.js';
+export * from './source/index.js';
+export * from './validation/index.js';

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

@@ -0,0 +1,6 @@
+export * from "./builders/index.js";
+export * from "./context.js";
+export * from "./references/index.js";
+export * from "./rows/index.js";
+export * from "./source/index.js";
+export * from "./validation/index.js";

package/dist/runtime/spreadsheet/utils/object.d.ts

@@ -0,0 +1,8 @@
+export declare function isSpreadsheetRecord(value: unknown): value is Record<string, unknown>;
+export declare function getSpreadsheetValueAtPath(data: Record<string, unknown>, path: string): unknown;
+export declare function setSpreadsheetValueAtPath(target: Record<string, unknown>, path: string, value: unknown): void;
+export declare function deleteSpreadsheetValueAtPath(target: Record<string, unknown>, path: string): void;
+export declare function getSpreadsheetObjectEntries(value: unknown): [string, unknown][];
+export declare function getSpreadsheetObjectKeys(value: unknown): string[];
+export declare function getSpreadsheetLeafPaths(value: unknown, prefix?: string): string[];
+export declare function cloneSpreadsheetRowData(data: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,63 @@
+export function isSpreadsheetRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function getSpreadsheetValueAtPath(data, path) {
+  return path.split(".").reduce((current, part) => {
+    if (!isSpreadsheetRecord(current)) return void 0;
+    return current[part];
+  }, data);
+}
+export function setSpreadsheetValueAtPath(target, path, value) {
+  const parts = path.split(".");
+  let current = target;
+  for (const [index, part] of parts.entries()) {
+    const isLast = index === parts.length - 1;
+    if (isLast) {
+      current[part] = value;
+      continue;
+    }
+    const nextValue = current[part];
+    if (isSpreadsheetRecord(nextValue)) {
+      current = nextValue;
+      continue;
+    }
+    const nextRecord = {};
+    current[part] = nextRecord;
+    current = nextRecord;
+  }
+}
+export function deleteSpreadsheetValueAtPath(target, path) {
+  const parts = path.split(".");
+  let current = target;
+  for (const [index, part] of parts.entries()) {
+    if (!current) return;
+    const isLast = index === parts.length - 1;
+    if (isLast) {
+      delete current[part];
+      return;
+    }
+    const nextValue = current[part];
+    if (!isSpreadsheetRecord(nextValue)) return;
+    current = nextValue;
+  }
+}
+export function getSpreadsheetObjectEntries(value) {
+  if (!isSpreadsheetRecord(value)) return [];
+  return Object.entries(value);
+}
+export function getSpreadsheetObjectKeys(value) {
+  return getSpreadsheetObjectEntries(value).map(([key]) => key);
+}
+export function getSpreadsheetLeafPaths(value, prefix = "") {
+  if (!isSpreadsheetRecord(value)) return prefix ? [prefix] : [];
+  const entries = getSpreadsheetObjectEntries(value);
+  if (!entries.length) return prefix ? [prefix] : [];
+  return entries.flatMap(([key, entryValue]) => {
+    const nextPath = prefix ? `${prefix}.${key}` : key;
+    if (isSpreadsheetRecord(entryValue)) return getSpreadsheetLeafPaths(entryValue, nextPath);
+    return [nextPath];
+  });
+}
+export function cloneSpreadsheetRowData(data) {
+  return structuredClone(data);
+}

package/dist/runtime/spreadsheet/utils/options.d.ts

@@ -0,0 +1,8 @@
+export declare function isSpreadsheetPrimitiveOption(value: unknown): value is string | number | boolean;
+export declare function isSpreadsheetOptionEntry(value: unknown): value is {
+    label: string;
+    value: unknown;
+};
+export declare function resolveSpreadsheetOptionEntries<TParams>(source: unknown, params: TParams): any;
+export declare function getSpreadsheetOptionLabel(option: unknown): string;
+export declare function getSpreadsheetOptionValue(option: unknown): unknown;

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

@@ -0,0 +1,22 @@
+import { isSpreadsheetRecord } from "./object.js";
+export function isSpreadsheetPrimitiveOption(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+export function isSpreadsheetOptionEntry(value) {
+  return isSpreadsheetRecord(value) && typeof value.label === "string" && "value" in value;
+}
+export function resolveSpreadsheetOptionEntries(source, params) {
+  if (Array.isArray(source)) return source;
+  if (typeof source === "function") return source(params);
+  return [];
+}
+export function getSpreadsheetOptionLabel(option) {
+  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;
+  return void 0;
+}

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

@@ -0,0 +1,6 @@
+import type { SpreadsheetReferenceCandidate, SpreadsheetReferenceDefinition, SpreadsheetResolutionDefinition } from '../../types/index.js';
+export declare function createSpreadsheetReferenceCandidates(params: {
+    sourceValue: string;
+    reference: SpreadsheetResolutionDefinition | SpreadsheetReferenceDefinition;
+    options: readonly unknown[];
+}): SpreadsheetReferenceCandidate<unknown, unknown>[];

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

@@ -0,0 +1,22 @@
+import { getSpreadsheetOptionLabel, getSpreadsheetOptionValue } from "../options.js";
+import { normalizeSpreadsheetRuntimeResolutions } from "./guards.js";
+import { scoreSpreadsheetReferenceCandidate } from "./shared.js";
+export function createSpreadsheetReferenceCandidates(params) {
+  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 [];
+    return [
+      {
+        value,
+        label,
+        option,
+        score: scoreSpreadsheetReferenceCandidate(params.sourceValue, label)
+      }
+    ];
+  }).sort((left, right) => {
+    if (left.score !== right.score) return right.score - left.score;
+    return left.label.localeCompare(right.label);
+  });
+}

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

@@ -0,0 +1,3 @@
+export * from './candidates.js';
+export * from './resolutions.js';
+export * from './sources.js';

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

@@ -0,0 +1,3 @@
+export * from "./candidates.js";
+export * from "./resolutions.js";
+export * from "./sources.js";

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

@@ -0,0 +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;
+export declare function normalizeSpreadsheetRuntimeResolutions(entries: readonly unknown[]): SpreadsheetResolutionDefinition[];

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

@@ -0,0 +1,24 @@
+import { isSpreadsheetRecord } from "../object.js";
+export function isSpreadsheetResolutionDefinition(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "select" && "targetField" in value && "sourceField" in value;
+}
+export function isSpreadsheetPublicReferenceDefinition(value) {
+  return isSpreadsheetRecord(value) && "kind" in value && value.kind === "select" && "field" in value && "source" in value;
+}
+export function normalizeSpreadsheetRuntimeResolutions(entries) {
+  return entries.flatMap((entry) => {
+    if (isSpreadsheetResolutionDefinition(entry)) return [entry];
+    if (!isSpreadsheetPublicReferenceDefinition(entry)) return [];
+    return [
+      {
+        kind: "select",
+        scope: "reference",
+        targetField: entry.field,
+        sourceField: entry.source,
+        options: entry.options,
+        getOptions: entry.getOptions,
+        rules: entry.rules
+      }
+    ];
+  });
+}

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

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

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

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

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

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

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

@@ -0,0 +1,153 @@
+import {
+  cloneSpreadsheetRowData,
+  deleteSpreadsheetValueAtPath,
+  getSpreadsheetValueAtPath,
+  setSpreadsheetValueAtPath
+} 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 value !== null && typeof value === "object" && "column" in value && typeof value.column === "string" && "rules" in value && typeof value.rules === "function";
+}
+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
+        })
+      });
+      const bestCandidate = candidates[0];
+      const isMatched = Boolean(bestCandidate && bestCandidate.score >= 0.9);
+      return {
+        scope: reference.scope,
+        resolutionField: reference.targetField,
+        targetField: reference.targetField,
+        referenceField: reference.targetField,
+        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
+      };
+    })
+  );
+}
+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({
+        value,
+        rules: reference.rules
+      });
+      issues.push(
+        ...referenceIssues.map(
+          (issue) => ({
+            ...issue,
+            rowIndex: row.index,
+            columnKey: reference.targetField
+          })
+        )
+      );
+    }
+    for (const relation of params.relations ?? []) {
+      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
+        })
+      });
+      issues.push(
+        ...relationIssues.map(
+          (issue) => ({
+            ...issue,
+            rowIndex: row.index,
+            columnKey: relation.column
+          })
+        )
+      );
+    }
+    return {
+      index: row.index,
+      source: row.source,
+      data,
+      issues,
+      isValid: issues.every((issue) => issue.level !== "error")
+    };
+  });
+}
+export function createSpreadsheetReferenceQueryRequests(params) {
+  return createSpreadsheetReferenceResolutions({
+    references: params.references,
+    rows: params.rows,
+    context: params.context
+  }).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 [
+      {
+        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
+        })
+      }
+    ];
+  });
+}

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

@@ -0,0 +1,2 @@
+export declare function normalizeSpreadsheetReferenceText(value: unknown): string;
+export declare function scoreSpreadsheetReferenceCandidate(sourceValue: string, label: string): number;

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

@@ -0,0 +1,16 @@
+export function normalizeSpreadsheetReferenceText(value) {
+  return String(value ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().replace(/\s+/g, " ").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

@@ -0,0 +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>;
+    entries: {
+        value: string;
+        rowIndexes: number[];
+    }[];
+}[];

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

@@ -0,0 +1,34 @@
+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 [
+      {
+        reference: entry,
+        entries: Array.from(entries.entries()).map(([value, rowIndexes]) => ({
+          value,
+          rowIndexes
+        }))
+      }
+    ];
+  });
+}

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

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

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

@@ -0,0 +1,4 @@
+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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import type { SpreadsheetHeaderCell, SpreadsheetStaticColumn } from '../../types/index.js';
+import type { 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[];