nuxt-ui-tools 1.11.2 → 1.13.0

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

@@ -0,0 +1,95 @@
+import { computed, shallowRef, watch } from "vue";
+import { createSpreadsheetHeaderCells, detectSpreadsheetLayout } from "../utils/index.js";
+export function useSpreadsheetLayout(params) {
+  const selection = shallowRef({
+    headerRow: 0,
+    sheet: null
+  });
+  const detection = computed(() => {
+    const workbook = params.file.workbook.value;
+    if (!workbook || !params.fields.columnFields.value.length) return null;
+    return detectSpreadsheetLayout({
+      ctx: params.context.ctx.value,
+      fields: params.fields.columnFields.value,
+      workbook
+    });
+  });
+  function detectedSelection() {
+    const workbook = params.file.workbook.value;
+    const definition = params.schema.value.file ?? {};
+    const best = detection.value?.best;
+    const sheetName = definition.sheet && definition.sheet !== "auto" ? definition.sheet : best?.sheet ?? workbook?.sheets[0]?.name ?? null;
+    const sheet2 = workbook?.sheets.find((entry) => entry.name === sheetName);
+    const layout = detection.value?.sheets.find((entry) => entry.name === sheetName);
+    const headerRow = typeof definition.headerRow === "number" ? Math.max(sheet2?.rowNumbers.indexOf(definition.headerRow) ?? -1, 0) : layout?.headerRow ?? 0;
+    return { headerRow, sheet: sheetName };
+  }
+  function redetect() {
+    selection.value = detectedSelection();
+  }
+  watch(
+    () => [params.file.workbook.value, detection.value !== null],
+    ([workbook], previous) => {
+      if (!workbook) {
+        selection.value = { headerRow: 0, sheet: null };
+        return;
+      }
+      if (previous?.[0] !== workbook || !previous[1]) redetect();
+    },
+    { immediate: true }
+  );
+  const sheet = computed(
+    () => params.file.workbook.value?.sheets.find((entry) => entry.name === selection.value.sheet) ?? null
+  );
+  const headers = computed(
+    () => createSpreadsheetHeaderCells(sheet.value?.rows[selection.value.headerRow] ?? [])
+  );
+  const dataRows = computed(() => sheet.value?.rows.slice(selection.value.headerRow + 1) ?? []);
+  const dataRaws = computed(() => sheet.value?.raws.slice(selection.value.headerRow + 1) ?? []);
+  const dataRowNumbers = computed(
+    () => sheet.value?.rowNumbers.slice(selection.value.headerRow + 1) ?? []
+  );
+  const candidates = computed(
+    () => detection.value?.sheets.find((entry) => entry.name === selection.value.sheet)?.candidates ?? []
+  );
+  const detected = computed(() => {
+    const expected = detectedSelection();
+    return Boolean(detection.value?.best) && expected.sheet === selection.value.sheet && expected.headerRow === selection.value.headerRow;
+  });
+  const preview = computed(() => {
+    const rows = sheet.value?.rows ?? [];
+    const numbers = sheet.value?.rowNumbers ?? [];
+    const header = selection.value.headerRow;
+    const start = Math.max(0, header - 2);
+    return rows.slice(start, header + 4).map((cells, offset) => {
+      const index = start + offset;
+      return {
+        cells,
+        kind: index < header ? "title" : index === header ? "header" : "data",
+        rowNumber: numbers[index] ?? index + 1
+      };
+    });
+  });
+  function setSheet(name) {
+    const layout = detection.value?.sheets.find((entry) => entry.name === name);
+    selection.value = { headerRow: layout?.headerRow ?? 0, sheet: name };
+  }
+  function setHeaderRow(index) {
+    selection.value = { ...selection.value, headerRow: index };
+  }
+  return {
+    candidates,
+    dataRaws,
+    dataRowNumbers,
+    dataRows,
+    detected,
+    detection,
+    headers,
+    preview,
+    redetect,
+    selection,
+    setHeaderRow,
+    setSheet,
+    sheet
+  };
+}

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

@@ -0,0 +1,24 @@
+import type { SpreadsheetField, SpreadsheetFieldOptions, SpreadsheetRecord, SpreadsheetResolvedOption } from '../types/index.js';
+import type { SpreadsheetRowOptions } from '../utils/index.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';
+export interface UseSpreadsheetOptionsParams {
+    fields: ReturnType<typeof useSpreadsheetFields>;
+    columns: ReturnType<typeof useSpreadsheetColumns>;
+    layout: ReturnType<typeof useSpreadsheetLayout>;
+    edits: ReturnType<typeof useSpreadsheetEdits>;
+    context: ReturnType<typeof useSpreadsheetContext>;
+}
+/**
+ * Options of every select field: lists as they are, queries once loaded, and remote loaders
+ * resolved for the values the file holds, exactly.
+ */
+export declare function useSpreadsheetOptions(params: UseSpreadsheetOptionsParams): {
+    loading: import("vue").ComputedRef<boolean>;
+    options: import("vue").ComputedRef<Map<string, SpreadsheetFieldOptions>>;
+    optionsOf: (field: SpreadsheetField, row: SpreadsheetRecord) => SpreadsheetRowOptions;
+    search: (path: string, text: string) => Promise<readonly SpreadsheetResolvedOption[]>;
+};

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

@@ -0,0 +1,159 @@
+import { useQueryClient } from "@tanstack/vue-query";
+import { computed } from "vue";
+import { REMOTE_OPTIONS_FIRST_PAGE } from "#ui-tools/shared/utils/remote-options";
+import {
+  createSpreadsheetFieldOptions,
+  hashSpreadsheetText,
+  indexSpreadsheetOptions,
+  normalizeSpreadsheetText,
+  resolveSpreadsheetOptionsSource,
+  splitSpreadsheetItems,
+  toSpreadsheetOption,
+  toSpreadsheetText
+} from "../utils/index.js";
+import { useSpreadsheetQueries } from "./use-spreadsheet-queries.js";
+const MAX_SEARCHED_VALUES = 100;
+function isOptionList(value) {
+  return Array.isArray(value);
+}
+export function useSpreadsheetOptions(params) {
+  const queryClient = useQueryClient();
+  const sources = computed(
+    () => params.fields.fields.value.flatMap(
+      (field) => field.select && !field.select.rowOptions ? [
+        {
+          field,
+          source: resolveSpreadsheetOptionsSource(
+            field.select.source,
+            params.context.ctx.value
+          )
+        }
+      ] : []
+    )
+  );
+  function distinctTexts(field) {
+    const from = field.select?.from ?? null;
+    const column = params.columns.matches.value.get(from ?? field.path);
+    const values = /* @__PURE__ */ new Set();
+    for (const [index, row] of params.layout.dataRows.value.entries()) {
+      const edits = params.edits.edits.value.get(index);
+      const text = edits?.[field.path] ?? (from ? edits?.[from] : void 0) ?? (column === void 0 ? "" : toSpreadsheetText(row[column]));
+      for (const item of field.separator ? splitSpreadsheetItems(text, field.separator) : [text])
+        if (item) values.add(item);
+    }
+    return [...values];
+  }
+  const plan = computed(
+    () => sources.value.map((entry) => {
+      const { source, field } = entry;
+      if (source.kind === "list")
+        return { field, kind: "list", queries: [], items: source.items };
+      if (source.kind === "query")
+        return { field, kind: "query", queries: [source.query], items: [] };
+      const texts = distinctTexts(field);
+      const resolveLabels = source.loader.resolveLabels;
+      const queries = !texts.length ? [] : resolveLabels ? [resolveLabels({ labels: texts })] : texts.slice(0, MAX_SEARCHED_VALUES).map(
+        (text) => source.loader.load({
+          page: { ...REMOTE_OPTIONS_FIRST_PAGE, size: source.loader.pagination.size },
+          search: text
+        })
+      );
+      return { field, kind: "remote", queries, items: [] };
+    })
+  );
+  const results = useSpreadsheetQueries(() => plan.value.flatMap((entry) => entry.queries));
+  const options = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    let cursor = 0;
+    for (const entry of plan.value) {
+      if (entry.kind === "list") {
+        const list2 = entry.items.map(toSpreadsheetOption);
+        map.set(entry.field.path, {
+          error: null,
+          index: indexSpreadsheetOptions(list2),
+          options: list2,
+          remote: false,
+          status: "ready"
+        });
+        continue;
+      }
+      const slice = results.value.slice(cursor, cursor + entry.queries.length);
+      cursor += entry.queries.length;
+      const pending = slice.some((result) => result.pending);
+      const error = slice.find((result) => result.error)?.error ?? null;
+      const items = [];
+      for (const result of slice) {
+        const data = result.data;
+        if (isOptionList(data)) items.push(...data);
+        else if (data && typeof data === "object" && "options" in data && isOptionList(data.options))
+          items.push(...data.options);
+      }
+      const list = dedupe(items.map(toSpreadsheetOption));
+      map.set(entry.field.path, {
+        error,
+        index: indexSpreadsheetOptions(list),
+        options: list,
+        remote: entry.kind === "remote",
+        status: error ? "error" : pending ? "loading" : "ready"
+      });
+    }
+    return map;
+  });
+  const loading = computed(
+    () => [...options.value.values()].some((entry) => entry.status === "loading")
+  );
+  const rowCache = computed(() => {
+    void params.fields.fields.value;
+    return {
+      byList: /* @__PURE__ */ new WeakMap(),
+      bySignature: /* @__PURE__ */ new Map()
+    };
+  });
+  function optionsOf(field, row) {
+    const rowOptions = field.select?.rowOptions;
+    if (!rowOptions) return { options: options.value.get(field.path), scope: null };
+    const cache = rowCache.value;
+    const items = rowOptions.resolve(row);
+    const known = cache.byList.get(items);
+    if (known) return known;
+    const fieldOptions = createSpreadsheetFieldOptions(items);
+    const signature = `${field.path}\0${JSON.stringify(
+      fieldOptions.options.map((option) => [String(option.value), option.label, option.aliases])
+    )}`;
+    const shared = cache.bySignature.get(signature) ?? {
+      options: fieldOptions,
+      scope: hashSpreadsheetText(signature)
+    };
+    cache.bySignature.set(signature, shared);
+    cache.byList.set(items, shared);
+    return shared;
+  }
+  async function search(path, text) {
+    const entry = sources.value.find((candidate) => candidate.field.path === path);
+    if (!entry) return [];
+    if (entry.source.kind !== "remote") {
+      const query = normalizeSpreadsheetText(text);
+      return (options.value.get(path)?.options ?? []).filter(
+        (option) => normalizeSpreadsheetText(option.label).includes(query)
+      );
+    }
+    const loader = entry.source.loader;
+    const page = await queryClient.fetchQuery(
+      loader.load({
+        page: { ...REMOTE_OPTIONS_FIRST_PAGE, size: loader.pagination.size },
+        search: text
+      })
+    );
+    return page.options.map(toSpreadsheetOption);
+  }
+  return { loading, options, optionsOf, search };
+}
+function dedupe(options) {
+  const seen = /* @__PURE__ */ new Set();
+  return options.filter((option) => {
+    const key = String(option.value);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

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

@@ -0,0 +1,14 @@
+import type { QueryFnDefinition } from '#ui-tools/shared/types/query';
+/**
+ * Runs a reactive list of TanStack queries and reduces each result to what the import needs.
+ * Used for context entries, option lists, remote label lookups, and stored records.
+ */
+export declare function useSpreadsheetQueries(queries: () => readonly QueryFnDefinition<unknown>[]): Readonly<import("vue").Ref<{
+    data: unknown;
+    error: Error | null;
+    pending: boolean;
+}[], {
+    data: unknown;
+    error: Error | null;
+    pending: boolean;
+}[]>>;

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

@@ -0,0 +1,11 @@
+import { useQueries } from "@tanstack/vue-query";
+export function useSpreadsheetQueries(queries) {
+  return useQueries({
+    combine: (results) => results.map((result) => ({
+      data: result.data,
+      error: result.error,
+      pending: result.isPending
+    })),
+    queries: () => queries().map((query) => ({ ...query, retry: false }))
+  });
+}

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

@@ -1,173 +1,41 @@
-import type { ComputedRef } from 'vue';
-import type { SpreadsheetRecord, SpreadsheetRowIssue, SpreadsheetResolvedReferenceRow } from '../types/index.js';
-import { formatSpreadsheetCell, humanizeSpreadsheetKey } from '../utils/display.js';
-import { getSpreadsheetObjectEntries } from '../utils/object.js';
-export type SpreadsheetReviewTab = 'all' | 'valid' | 'invalid' | 'discarded';
-export type SpreadsheetReviewIssueFilter = 'all' | 'blocking' | 'warning';
-interface SpreadsheetReviewRow extends SpreadsheetResolvedReferenceRow<SpreadsheetRecord> {
-    rowObject: SpreadsheetRecord;
-}
+import type { SpreadsheetIssueLevel, SpreadsheetIssueType, SpreadsheetRecord, SpreadsheetReviewLevel, SpreadsheetReviewMode, SpreadsheetReviewTab, SpreadsheetRow } from '../types/index.js';
+import type { useSpreadsheetLayout } from './use-spreadsheet-layout.js';
+import type { useSpreadsheetRows } from './use-spreadsheet-rows.js';
 export interface UseSpreadsheetReviewParams {
-    resolvedRows: ComputedRef<readonly SpreadsheetResolvedReferenceRow<SpreadsheetRecord>[]>;
-    maxRecords: ComputedRef<number>;
+    rows: ReturnType<typeof useSpreadsheetRows>;
+    layout: ReturnType<typeof useSpreadsheetLayout>;
 }
+/**
+ * What the review shows: tab, filters, search, selection, and the inspected row. Shared by the
+ * table, its toolbar, and the row inspector wherever they are placed.
+ */
 export declare function useSpreadsheetReview(params: UseSpreadsheetReviewParams): {
-    activeTab: import("vue").Ref<SpreadsheetReviewTab, SpreadsheetReviewTab>;
-    canDiscardSelection: ComputedRef<boolean>;
-    canRestoreSelection: ComputedRef<boolean>;
-    closeInspection: () => void;
-    discardRow: (index: number) => void;
-    discardSelectedRows: () => void;
-    formatSpreadsheetCell: typeof formatSpreadsheetCell;
-    getIssueBadge: (issue: SpreadsheetRowIssue) => {
-        color: "error";
-        label: string;
-    } | {
-        color: "warning";
-        label: string;
-    };
-    getIssueRawValue: (rowData: SpreadsheetRecord, issue: SpreadsheetRowIssue) => unknown;
-    getIssueValue: (rowData: SpreadsheetRecord, issue: SpreadsheetRowIssue) => string;
-    getIssueValueTone: (issue: SpreadsheetRowIssue) => "bg-error/6" | "bg-warning/10";
-    getRelatedIssueCount: (issue: SpreadsheetRowIssue) => number;
-    getRowStatus: (index: number, issues: readonly SpreadsheetRowIssue[]) => {
-        color: "neutral";
-        icon: string;
-        label: string;
-    } | {
-        color: "error";
-        icon: string;
-        label: string;
-    } | {
-        color: "warning";
-        icon: string;
-        label: string;
-    } | {
-        color: "success";
-        icon: string;
-        label: string;
-    };
-    getRowToneClass: (row: {
-        index: number;
-        issues: readonly SpreadsheetRowIssue[];
-    }) => "" | "opacity-45" | "bg-error/5" | "bg-warning/5";
-    getSpreadsheetObjectEntries: typeof getSpreadsheetObjectEntries;
-    hasOverflow: ComputedRef<boolean>;
-    humanizeSpreadsheetKey: typeof humanizeSpreadsheetKey;
-    inspectNextIssueRow: () => void;
-    inspectPrevIssueRow: () => void;
-    inspectRow: (index: number) => void;
-    inspectedIssueRowPosition: ComputedRef<number>;
-    inspectedRow: ComputedRef<SpreadsheetReviewRow | null>;
-    isDiscarded: (index: number) => boolean;
-    isManuallyDiscarded: (index: number) => boolean;
-    issueFilter: import("vue").Ref<SpreadsheetReviewIssueFilter, SpreadsheetReviewIssueFilter>;
-    issueFilterItems: ComputedRef<({
-        key: "all";
-        label: string;
-    } | {
-        key: "blocking";
-        label: string;
-    } | {
-        key: "warning";
-        label: string;
-    })[]>;
-    issueRows: ComputedRef<SpreadsheetReviewRow[]>;
-    overflowCount: ComputedRef<number>;
-    restoreRow: (index: number) => void;
-    restoreSelectedRows: () => void;
-    reviewTableColumns: ComputedRef<({
-        accessorFn: (row: {
-            data: SpreadsheetRecord;
-        }) => string;
-        cell: ({ row }: {
-            row: {
-                original: {
-                    data: SpreadsheetRecord;
-                };
-            };
-        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>;
-        header: string;
-        id: string;
-        meta: {
-            class: {
-                td: string;
-                th: string;
-            };
-        };
-    } | {
-        cell: ({ row }: {
-            row: {
-                original: {
-                    index: number;
-                };
-            };
-        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>;
-        header: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>;
-        id: string;
-        meta: {
-            class: {
-                td: string;
-                th: string;
-            };
-        };
-        accessorFn?: undefined;
-    } | {
-        accessorFn: (row: {
-            index: number;
-        }) => number;
-        cell: ({ row, }: {
-            row: {
-                original: {
-                    index: number;
-                    issues: readonly SpreadsheetRowIssue[];
-                };
-            };
-        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-            [key: string]: any;
-        }>;
-        header: string;
-        id: string;
-        meta: {
-            class: {
-                td: string;
-                th: string;
-            };
-        };
-    })[]>;
-    rowSelection: import("vue").Ref<Record<string, boolean>, Record<string, boolean>>;
-    selectedRowIndexes: ComputedRef<number[]>;
-    setActiveTab: (value: SpreadsheetReviewTab) => void;
-    setIssueFilter: (value: SpreadsheetReviewIssueFilter) => void;
-    stats: ComputedRef<{
-        accentClass: string;
-        cardClass: string;
-        hint: string;
-        key: string;
-        label: string;
-        value: number;
-        valueClass: string;
-    }[]>;
-    tabItems: ComputedRef<({
-        key: "all";
-        label: string;
-    } | {
-        key: "valid";
-        label: string;
-    } | {
-        key: "invalid";
-        label: string;
-    } | {
-        key: "discarded";
-        label: string;
-    })[]>;
-    tableColumns: ComputedRef<string[]>;
-    visibleRows: ComputedRef<SpreadsheetReviewRow[]>;
+    clearSelection: () => void;
+    fieldIssues: import("vue").ComputedRef<Map<string, {
+        rowCount: number;
+        level: SpreadsheetIssueLevel;
+    }>>;
+    inspect: (index: number | null) => void;
+    inspected: import("vue").ComputedRef<SpreadsheetRow<SpreadsheetRecord, unknown> | null>;
+    issue: import("vue").ShallowRef<string, string>;
+    issueTypes: import("vue").ComputedRef<SpreadsheetIssueType[]>;
+    level: import("vue").ShallowRef<SpreadsheetReviewLevel, SpreadsheetReviewLevel>;
+    mode: import("vue").ShallowRef<SpreadsheetReviewMode, SpreadsheetReviewMode>;
+    next: () => void;
+    position: import("vue").ComputedRef<{
+        current: number;
+        total: number;
+    }>;
+    previous: () => void;
+    reset: () => void;
+    search: import("vue").ShallowRef<string, string>;
+    select: (indexes: readonly number[], selected: boolean) => void;
+    selection: import("vue").ShallowRef<ReadonlySet<number>, ReadonlySet<number>>;
+    setIssue: (value: string) => void;
+    setLevel: (value: SpreadsheetReviewLevel) => void;
+    setMode: (value: SpreadsheetReviewMode) => void;
+    setSearch: (value: string) => void;
+    setTab: (value: SpreadsheetReviewTab) => void;
+    tab: import("vue").ShallowRef<SpreadsheetReviewTab, SpreadsheetReviewTab>;
+    visible: import("vue").ComputedRef<readonly SpreadsheetRow<SpreadsheetRecord, unknown>[]>;
 };
-export {};