nuxt-ui-tools 1.11.2 → 1.13.0

package/dist/runtime/spreadsheet/composables/use-spreadsheet-review.js

@@ -1,422 +1,162 @@
-import UBadge from "@nuxt/ui/components/Badge.vue";
-import UCheckbox from "@nuxt/ui/components/Checkbox.vue";
-import { computed, ref, h } from "vue";
-import { useUiToolsLocale } from "#ui-tools/i18n";
-import { isNullish } from "../../shared/utils/predicate.js";
-import SpreadsheetValuePreview from "../components/shared/spreadsheet-value-preview.vue";
-import { formatSpreadsheetCell, humanizeSpreadsheetKey } from "../utils/display.js";
-import {
-  getSpreadsheetLeafPaths,
-  getSpreadsheetObjectEntries,
-  getSpreadsheetValueAtPath
-} from "../utils/object.js";
+import { computed, shallowRef, watch } from "vue";
+const LEVEL_RANK = { error: 3, info: 1, warning: 2 };
 export function useSpreadsheetReview(params) {
-  const { t } = useUiToolsLocale();
-  const activeTab = ref("all");
-  const issueFilter = ref("all");
-  const inspectedRowIndex = ref(null);
-  const manuallyDiscardedRowIndexes = ref([]);
-  const rowSelection = ref({});
-  function isOverflowRow(index) {
-    return index >= params.maxRecords.value;
-  }
-  function isManuallyDiscarded(index) {
-    return manuallyDiscardedRowIndexes.value.includes(index);
-  }
-  function isDiscarded(index) {
-    return isOverflowRow(index) || isManuallyDiscarded(index);
-  }
-  function hasBlockingIssue(issues) {
-    return issues.some((issue) => issue.level === "error");
-  }
-  function hasWarningIssue(issues) {
-    return issues.some((issue) => issue.level === "warning");
-  }
-  function clearSelection() {
-    rowSelection.value = {};
-  }
-  function setActiveTab(value) {
-    activeTab.value = value;
-    clearSelection();
-    if (value === "valid" || value === "discarded") {
-      issueFilter.value = "all";
-    }
-  }
-  function setIssueFilter(value) {
-    issueFilter.value = value;
-    clearSelection();
-  }
-  function selectAllVisible(checked) {
-    if (checked !== true) {
-      clearSelection();
-      return;
-    }
-    rowSelection.value = Object.fromEntries(
-      visibleRows.value.filter((row) => !isOverflowRow(row.index) || activeTab.value === "discarded").map((row) => [String(row.index), true])
-    );
-  }
-  function discardSelectedRows() {
-    const discardableIndexes = selectedRowIndexes.value.filter((index) => !isDiscarded(index));
-    manuallyDiscardedRowIndexes.value = [
-      .../* @__PURE__ */ new Set([...manuallyDiscardedRowIndexes.value, ...discardableIndexes])
-    ];
-    clearSelection();
-  }
-  function restoreSelectedRows() {
-    manuallyDiscardedRowIndexes.value = manuallyDiscardedRowIndexes.value.filter(
-      (index) => !selectedRowIndexes.value.includes(index)
-    );
-    clearSelection();
-  }
-  function discardRow(index) {
-    if (isDiscarded(index)) {
-      return;
-    }
-    manuallyDiscardedRowIndexes.value = [...manuallyDiscardedRowIndexes.value, index];
-  }
-  function restoreRow(index) {
-    manuallyDiscardedRowIndexes.value = manuallyDiscardedRowIndexes.value.filter(
-      (value) => value !== index
-    );
-  }
-  function inspectRow(index) {
-    inspectedRowIndex.value = index;
-  }
-  function closeInspection() {
-    inspectedRowIndex.value = null;
-  }
-  const reviewRows = computed(
-    () => params.resolvedRows.value.map((row) => ({
-      ...row,
-      rowObject: Object.fromEntries(getSpreadsheetObjectEntries(row.data))
-    }))
-  );
-  const validRows = computed(
-    () => reviewRows.value.filter((row) => row.isValid && !isDiscarded(row.index))
-  );
-  const invalidRows = computed(
-    () => reviewRows.value.filter((row) => !row.isValid && !isDiscarded(row.index))
-  );
-  const discardedRows = computed(() => reviewRows.value.filter((row) => isDiscarded(row.index)));
-  const issueRows = computed(
-    () => reviewRows.value.filter((row) => row.issues.length > 0 && !isDiscarded(row.index))
-  );
-  const inspectedRow = computed(
-    () => isNullish(inspectedRowIndex.value) ? null : reviewRows.value.find((row) => row.index === inspectedRowIndex.value) ?? null
-  );
-  const inspectedIssueRowPosition = computed(
-    () => isNullish(inspectedRow.value) ? -1 : issueRows.value.findIndex((row) => row.index === inspectedRow.value?.index)
-  );
-  const blockingIssueCount = computed(
-    () => invalidRows.value.reduce(
-      (count, row) => count + row.issues.filter((issue) => issue.level === "error").length,
-      0
-    )
-  );
-  const warningIssueCount = computed(
-    () => invalidRows.value.reduce(
-      (count, row) => count + row.issues.filter((issue) => issue.level === "warning").length,
-      0
-    )
-  );
-  const stats = computed(() => [
-    {
-      accentClass: "bg-success",
-      cardClass: "border-default/70",
-      hint: t("spreadsheet.steps.review.validRows", { count: validRows.value.length }),
-      key: "ready",
-      label: t("spreadsheet.steps.review.ready"),
-      value: validRows.value.length,
-      valueClass: "text-success"
-    },
-    {
-      accentClass: "bg-error",
-      cardClass: "border-default/70",
-      hint: invalidRows.value.length ? `${t("spreadsheet.steps.review.blocking", { count: blockingIssueCount.value })} \xB7 ${t("spreadsheet.steps.review.warnings", { count: warningIssueCount.value })}` : t("spreadsheet.steps.review.noBlockingIssues"),
-      key: "invalid",
-      label: t("spreadsheet.steps.review.invalid", { count: invalidRows.value.length }),
-      value: invalidRows.value.length,
-      valueClass: "text-error"
-    },
-    {
-      accentClass: "bg-warning",
-      cardClass: discardedRows.value.length ? "border-warning/40" : "border-default/70",
-      hint: discardedRows.value.length ? t("spreadsheet.steps.review.willNotBeImported") : t("spreadsheet.steps.review.nothingDiscarded"),
-      key: "discarded",
-      label: t("spreadsheet.steps.review.discarded", { count: discardedRows.value.length }),
-      value: discardedRows.value.length,
-      valueClass: "text-warning"
-    }
-  ]);
-  const hasOverflow = computed(() => reviewRows.value.length > params.maxRecords.value);
-  const overflowCount = computed(
-    () => hasOverflow.value ? reviewRows.value.length - params.maxRecords.value : 0
-  );
-  const tabItems = computed(() => [
-    {
-      key: "all",
-      label: t("spreadsheet.steps.review.allRows", { count: reviewRows.value.length })
-    },
-    {
-      key: "valid",
-      label: t("spreadsheet.steps.review.valid", { count: validRows.value.length })
-    },
-    {
-      key: "invalid",
-      label: t("spreadsheet.steps.review.invalid", { count: invalidRows.value.length })
-    },
-    {
-      key: "discarded",
-      label: t("spreadsheet.steps.review.discarded", { count: discardedRows.value.length })
-    }
-  ]);
-  const issueFilterItems = computed(() => [
-    { key: "all", label: t("spreadsheet.steps.review.allIssues") },
-    {
-      key: "blocking",
-      label: t("spreadsheet.steps.review.blocking", {
-        count: invalidRows.value.filter((row) => hasBlockingIssue(row.issues)).length
-      })
-    },
-    {
-      key: "warning",
-      label: t("spreadsheet.steps.review.warnings", {
-        count: invalidRows.value.filter(
-          (row) => !hasBlockingIssue(row.issues) && hasWarningIssue(row.issues)
-        ).length
-      })
-    }
-  ]);
-  const visibleRows = computed(() => {
-    const baseRows = activeTab.value === "valid" ? validRows.value : activeTab.value === "invalid" ? invalidRows.value : activeTab.value === "discarded" ? discardedRows.value : reviewRows.value;
-    if (activeTab.value === "valid" || activeTab.value === "discarded") {
-      return baseRows;
-    }
-    if (issueFilter.value === "blocking") {
-      return baseRows.filter((row) => hasBlockingIssue(row.issues));
+  const tab = shallowRef("all");
+  const level = shallowRef("all");
+  const mode = shallowRef("all");
+  const issue = shallowRef("");
+  const search = shallowRef("");
+  const selection = shallowRef(/* @__PURE__ */ new Set());
+  const inspectedIndex = shallowRef(null);
+  watch([params.layout.sheet, () => params.layout.selection.value.headerRow], () => reset());
+  const all = computed(() => params.rows.rows.value);
+  const issueTypes = computed(() => {
+    const types = /* @__PURE__ */ new Map();
+    for (const row of all.value) {
+      if (row.discardReason) continue;
+      const seen = /* @__PURE__ */ new Set();
+      for (const entry of row.issues) {
+        if (!entry.field || entry.level === "info") continue;
+        const id = `${entry.field}|${entry.code}`;
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const type = types.get(id);
+        if (type) type.rowCount += 1;
+        else
+          types.set(id, {
+            code: entry.code,
+            field: entry.field,
+            id,
+            level: entry.level,
+            message: entry.message,
+            rowCount: 1
+          });
+      }
     }
-    if (issueFilter.value === "warning") {
-      return baseRows.filter((row) => !hasBlockingIssue(row.issues) && hasWarningIssue(row.issues));
+    return [...types.values()].sort((left, right) => right.rowCount - left.rowCount);
+  });
+  const fieldIssues = computed(() => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of all.value) {
+      if (row.discardReason) continue;
+      for (const [field, entry] of Object.entries(row.fieldIssues)) {
+        if (entry.level === "info") continue;
+        const count = counts.get(field);
+        if (!count) counts.set(field, { level: entry.level, rowCount: 1 });
+        else {
+          count.rowCount += 1;
+          if (LEVEL_RANK[entry.level] > LEVEL_RANK[count.level]) count.level = entry.level;
+        }
+      }
     }
-    return baseRows;
+    return counts;
   });
-  const selectedRowIndexes = computed(
-    () => Object.entries(rowSelection.value).filter(([, selected]) => selected).map(([key]) => Number(key)).filter((index) => !Number.isNaN(index))
-  );
-  const selectedRows = computed(
-    () => visibleRows.value.filter((row) => selectedRowIndexes.value.includes(row.index))
-  );
-  const allVisibleSelected = computed(
-    () => visibleRows.value.length > 0 && visibleRows.value.filter((row) => !isOverflowRow(row.index) || activeTab.value === "discarded").every((row) => rowSelection.value[String(row.index)])
-  );
-  const canDiscardSelection = computed(
-    () => selectedRows.value.some((row) => !isDiscarded(row.index))
+  const visible = computed(() => {
+    let list = tab.value === "importable" ? params.rows.importable.value : tab.value === "invalid" ? params.rows.invalid.value : tab.value === "discarded" ? params.rows.discarded.value : all.value;
+    if (tab.value !== "discarded") {
+      if (level.value === "blocking")
+        list = list.filter((row) => !row.discardReason && row.errors.length);
+      if (level.value === "warnings")
+        list = list.filter((row) => !row.discardReason && row.warnings.length);
+      if (mode.value !== "all") list = list.filter((row) => row.mode === mode.value);
+    }
+    if (issue.value) {
+      const [field, code] = issue.value.split("|");
+      list = list.filter(
+        (row) => row.issues.some((entry) => entry.field === field && (code === "*" || entry.code === code))
+      );
+    }
+    const query = search.value.trim().toLowerCase();
+    if (query) {
+      const parsed = params.rows.parsed.value;
+      list = list.filter(
+        (row) => [...parsed[row.index]?.cells.values() ?? []].some(
+          (cell) => cell.text.toLowerCase().includes(query) || cell.display.toLowerCase().includes(query)
+        )
+      );
+    }
+    return list;
+  });
+  const withIssues = computed(
+    () => all.value.filter((row) => !row.discardReason && (row.errors.length || row.warnings.length))
   );
-  const canRestoreSelection = computed(
-    () => selectedRows.value.some((row) => isManuallyDiscarded(row.index))
+  const inspected = computed(
+    () => inspectedIndex.value === null ? null : all.value[inspectedIndex.value] ?? null
   );
-  const tableColumns = computed(() => {
-    const sample = visibleRows.value[0]?.data ?? reviewRows.value[0]?.data ?? {};
-    return getSpreadsheetLeafPaths(sample);
-  });
-  function getRowStatus(index, issues) {
-    if (isDiscarded(index)) {
-      return {
-        color: "neutral",
-        icon: "i-lucide-ban",
-        label: t("spreadsheet.steps.review.discardedStatus")
-      };
-    }
-    if (hasBlockingIssue(issues)) {
-      return {
-        color: "error",
-        icon: "i-lucide-circle-x",
-        label: t("spreadsheet.steps.review.blockingStatus")
-      };
-    }
-    if (hasWarningIssue(issues)) {
-      return {
-        color: "warning",
-        icon: "i-lucide-triangle-alert",
-        label: t("spreadsheet.steps.review.warningStatus")
-      };
-    }
-    return {
-      color: "success",
-      icon: "i-lucide-circle-check",
-      label: t("spreadsheet.steps.review.validStatus")
-    };
-  }
-  function getIssueBadge(issue) {
-    if (issue.level === "error") {
-      return { color: "error", label: t("spreadsheet.steps.review.issueBadgeBlocking") };
-    }
-    return { color: "warning", label: t("spreadsheet.steps.review.issueBadgeWarning") };
-  }
-  function getIssueValueTone(issue) {
-    if (issue.level === "error") {
-      return "bg-error/6";
-    }
-    return "bg-warning/10";
+  const position = computed(() => ({
+    current: inspectedIndex.value === null ? 0 : withIssues.value.findIndex((row) => row.index === inspectedIndex.value) + 1,
+    total: withIssues.value.length
+  }));
+  function setTab(value) {
+    tab.value = value;
+    selection.value = /* @__PURE__ */ new Set();
+    if (value === "importable" || value === "discarded") level.value = "all";
+  }
+  function setLevel(value) {
+    level.value = value;
+    if (value !== "all" && (tab.value === "importable" || tab.value === "discarded"))
+      tab.value = "all";
+  }
+  function setMode(value) {
+    mode.value = value;
+  }
+  function setIssue(value) {
+    issue.value = value;
+    if (value && (tab.value === "importable" || tab.value === "discarded")) tab.value = "all";
+  }
+  function setSearch(value) {
+    search.value = value;
+  }
+  function select(indexes, selected) {
+    const next = new Set(selection.value);
+    for (const index of indexes) {
+      if (selected) next.add(index);
+      else next.delete(index);
+    }
+    selection.value = next;
   }
-  function getIssueValue(rowData, issue) {
-    if (!issue.columnKey) {
-      return t("spreadsheet.steps.review.noValue");
-    }
-    return formatSpreadsheetCell(getSpreadsheetValueAtPath(rowData, issue.columnKey));
-  }
-  function getIssueRawValue(rowData, issue) {
-    if (!issue.columnKey) {
-      return;
-    }
-    return getSpreadsheetValueAtPath(rowData, issue.columnKey);
-  }
-  function getRelatedIssueCount(issue) {
-    return issueRows.value.filter(
-      (row) => row.issues.some(
-        (candidate) => candidate.code === issue.code && candidate.columnKey === issue.columnKey && candidate.message === issue.message
-      )
-    ).length;
+  function clearSelection() {
+    selection.value = /* @__PURE__ */ new Set();
   }
-  function getRowToneClass(row) {
-    if (isDiscarded(row.index)) {
-      return "opacity-45";
-    }
-    if (hasBlockingIssue(row.issues)) {
-      return "bg-error/5";
-    }
-    if (hasWarningIssue(row.issues)) {
-      return "bg-warning/5";
-    }
-    return "";
+  function inspect(index) {
+    inspectedIndex.value = index;
   }
-  const reviewTableColumns = computed(() => [
-    {
-      cell: ({ row }) => h("div", { class: "flex justify-center" }, [
-        h(UCheckbox, {
-          disabled: isOverflowRow(row.original.index) && activeTab.value !== "discarded",
-          modelValue: rowSelection.value[String(row.original.index)] ?? false,
-          "onUpdate:modelValue": (value) => {
-            rowSelection.value = {
-              ...rowSelection.value,
-              [String(row.original.index)]: value === true
-            };
-          }
-        })
-      ]),
-      header: () => h("div", { class: "flex justify-center" }, [
-        h(UCheckbox, {
-          modelValue: allVisibleSelected.value,
-          "onUpdate:modelValue": selectAllVisible
-        })
-      ]),
-      id: "select",
-      meta: {
-        class: {
-          td: "w-12",
-          th: "w-12"
-        }
-      }
-    },
-    {
-      accessorFn: (row) => row.index + 1,
-      cell: ({
-        row
-      }) => {
-        const status = getRowStatus(row.original.index, row.original.issues);
-        const issueCount = row.original.issues.length;
-        const statusLabel = issueCount > 0 ? `${status.label} \xB7 ${issueCount}` : status.label;
-        return h("div", { class: "flex items-center gap-2 whitespace-nowrap leading-none" }, [
-          h("span", { class: "font-mono text-xs text-muted" }, `#${row.original.index + 1}`),
-          h(
-            UBadge,
-            {
-              class: "font-medium",
-              color: status.color,
-              icon: status.icon,
-              size: "sm",
-              variant: "soft"
-            },
-            () => statusLabel
-          )
-        ]);
-      },
-      header: t("spreadsheet.steps.review.row"),
-      id: "row",
-      meta: {
-        class: {
-          td: "w-44 align-top",
-          th: "w-44"
-        }
-      }
-    },
-    ...tableColumns.value.map((column) => ({
-      accessorFn: (row) => formatSpreadsheetCell(getSpreadsheetValueAtPath(row.data, column)),
-      cell: ({ row }) => h(SpreadsheetValuePreview, {
-        compact: true,
-        value: getSpreadsheetValueAtPath(row.original.data, column)
-      }),
-      header: humanizeSpreadsheetKey(column),
-      id: column,
-      meta: {
-        class: {
-          td: "min-w-44 max-w-80 align-top text-toned",
-          th: "min-w-44"
-        }
-      }
-    }))
-  ]);
-  function inspectPrevIssueRow() {
-    if (inspectedIssueRowPosition.value <= 0) {
-      return;
-    }
-    inspectedRowIndex.value = issueRows.value[inspectedIssueRowPosition.value - 1]?.index ?? null;
+  function step(direction) {
+    const current = withIssues.value.findIndex((row) => row.index === inspectedIndex.value);
+    const next = withIssues.value[current < 0 ? 0 : current + direction];
+    if (next) inspectedIndex.value = next.index;
   }
-  function inspectNextIssueRow() {
-    if (inspectedIssueRowPosition.value < 0) {
-      return;
-    }
-    inspectedRowIndex.value = issueRows.value[inspectedIssueRowPosition.value + 1]?.index ?? null;
+  function reset() {
+    tab.value = "all";
+    level.value = "all";
+    mode.value = "all";
+    issue.value = "";
+    search.value = "";
+    selection.value = /* @__PURE__ */ new Set();
+    inspectedIndex.value = null;
   }
   return {
-    activeTab,
-    canDiscardSelection,
-    canRestoreSelection,
-    closeInspection,
-    discardRow,
-    discardSelectedRows,
-    formatSpreadsheetCell,
-    getIssueBadge,
-    getIssueRawValue,
-    getIssueValue,
-    getIssueValueTone,
-    getRelatedIssueCount,
-    getRowStatus,
-    getRowToneClass,
-    getSpreadsheetObjectEntries,
-    hasOverflow,
-    humanizeSpreadsheetKey,
-    inspectNextIssueRow,
-    inspectPrevIssueRow,
-    inspectRow,
-    inspectedIssueRowPosition,
-    inspectedRow,
-    isDiscarded,
-    isManuallyDiscarded,
-    issueFilter,
-    issueFilterItems,
-    issueRows,
-    overflowCount,
-    restoreRow,
-    restoreSelectedRows,
-    reviewTableColumns,
-    rowSelection,
-    selectedRowIndexes,
-    setActiveTab,
-    setIssueFilter,
-    stats,
-    tabItems,
-    tableColumns,
-    visibleRows
+    clearSelection,
+    fieldIssues,
+    inspect,
+    inspected,
+    issue,
+    issueTypes,
+    level,
+    mode,
+    next: () => step(1),
+    position,
+    previous: () => step(-1),
+    reset,
+    search,
+    select,
+    selection,
+    setIssue,
+    setLevel,
+    setMode,
+    setSearch,
+    setTab,
+    tab,
+    visible
   };
 }

package/dist/runtime/spreadsheet/composables/use-spreadsheet-rows.d.ts

@@ -1,32 +1,54 @@
 import type { ComputedRef } from 'vue';
-import type { SpreadsheetNormalizedSchema, SpreadsheetRecord } from '../types/index.js';
+import type { UiToolsTranslator } from '#ui-tools/i18n';
+import type { SpreadsheetCellView, SpreadsheetRecord, SpreadsheetRow, SpreadsheetRowIssue, SpreadsheetRuntimeSchema } from '../types/index.js';
+import type { SpreadsheetParsedRow } from '../utils/index.js';
+import type { useSpreadsheetAnswers } from './use-spreadsheet-answers.js';
+import type { useSpreadsheetColumns } from './use-spreadsheet-columns.js';
+import type { useSpreadsheetContext } from './use-spreadsheet-context.js';
+import type { useSpreadsheetEdits } from './use-spreadsheet-edits.js';
+import type { useSpreadsheetFields } from './use-spreadsheet-fields.js';
+import type { useSpreadsheetLayout } from './use-spreadsheet-layout.js';
+import type { useSpreadsheetOptions } from './use-spreadsheet-options.js';
 export interface UseSpreadsheetRowsParams {
-    schema: ComputedRef<SpreadsheetNormalizedSchema>;
-    contextData: ComputedRef<SpreadsheetRecord>;
-    headers: ComputedRef<readonly unknown[]>;
-    rows: ComputedRef<readonly (readonly unknown[])[]>;
+    schema: ComputedRef<SpreadsheetRuntimeSchema>;
+    context: ReturnType<typeof useSpreadsheetContext>;
+    fields: ReturnType<typeof useSpreadsheetFields>;
+    layout: ReturnType<typeof useSpreadsheetLayout>;
+    columns: ReturnType<typeof useSpreadsheetColumns>;
+    options: ReturnType<typeof useSpreadsheetOptions>;
+    answers: ReturnType<typeof useSpreadsheetAnswers>;
+    edits: ReturnType<typeof useSpreadsheetEdits>;
+    t: UiToolsTranslator;
 }
+/**
+ * Every data row of the file: parsed, validated, identified against the file and stored records,
+ * and discarded or not. Parsing is cached per row; an edit re-parses its row only.
+ */
 export declare function useSpreadsheetRows(params: UseSpreadsheetRowsParams): {
-    error: import("vue").ShallowRef<unknown, unknown>;
-    parsedRows: import("vue").ShallowRef<import("../types/index.js").SpreadsheetParsedRow<SpreadsheetRecord>[], import("../types/index.js").SpreadsheetParsedRow<SpreadsheetRecord>[]>;
-    refreshRows: () => Promise<void>;
-    status: import("vue").ShallowRef<{
-        initialized: boolean;
-        isParsing: boolean;
-        isReady: boolean;
-    }, {
-        initialized: boolean;
-        isParsing: boolean;
-        isReady: boolean;
+    byMode: ComputedRef<{
+        create: number;
+        skip: number;
+        update: number;
     }>;
-    summary: import("vue").ShallowRef<import("../types/index.js").SpreadsheetRowSummary, import("../types/index.js").SpreadsheetRowSummary>;
-    assignColumn: (headerIndex: number, columnKey: string) => void;
-    clearColumnAssignment: (headerIndex: number) => void;
-    columnMatches: ComputedRef<import("../types/index.js").SpreadsheetColumnMatch<import("../types/index.js").SpreadsheetColumnDefinition<string, unknown, boolean, unknown, undefined, unknown, undefined>>[]>;
-    dynamicColumnMatches: ComputedRef<import("../types/index.js").SpreadsheetDynamicColumnMatch<import("../types/index.js").SpreadsheetDynamicOptionGroupsDefinition<string, string, unknown> | import("../types/index.js").SpreadsheetDynamicCollectionDefinition<string, "array" | "record", readonly unknown[], unknown>, import("../types/index.js").SpreadsheetDynamicCollectionItemDefinition<string, import("../types/index.js").SpreadsheetDynamicValueDefinition | ((value: import("../types/index.js").SpreadsheetDynamicValueBuilder) => import("../types/index.js").SpreadsheetValue), unknown, unknown>>[]>;
-    dynamicColumns: ComputedRef<readonly unknown[]>;
-    headerCells: ComputedRef<import("../types/index.js").SpreadsheetHeaderCell[]>;
-    manualColumnAssignments: import("vue").ShallowRef<Record<string, string>, Record<string, string>>;
-    staticColumns: ComputedRef<import("../types/index.js").SpreadsheetStaticColumn[]>;
-    unmatchedColumns: ComputedRef<import("../types/index.js").SpreadsheetUnmatchedColumn<import("../types/index.js").SpreadsheetColumnDefinition<string, unknown, boolean, unknown, undefined, unknown, undefined>>[]>;
+    cell: (index: number, field: string) => SpreadsheetCellView;
+    discard: (indexes: readonly number[]) => void;
+    discarded: ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
+    distinct: (field: string) => string[];
+    edit: (index: number, field: string, text: string) => void;
+    exportInvalid: (issuesHeader: string) => Blob;
+    importable: ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
+    invalid: ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
+    issues: (field?: string) => {
+        issue: SpreadsheetRowIssue;
+        row: number;
+    }[];
+    keyFields: ComputedRef<string[]>;
+    loading: ComputedRef<boolean>;
+    parsed: ComputedRef<SpreadsheetParsedRow[]>;
+    rejections: import("vue").ShallowRef<ReadonlyMap<number, readonly SpreadsheetRowIssue[]>, ReadonlyMap<number, readonly SpreadsheetRowIssue[]>>;
+    reset: () => void;
+    restore: (indexes: readonly number[]) => void;
+    rows: ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
+    setRejections: (next: ReadonlyMap<number, readonly SpreadsheetRowIssue[]>) => void;
+    valid: ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
 };