nuxt-ui-tools 1.12.0 → 1.13.0

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

@@ -1,49 +1,12 @@
-import type { ComputedRef } from 'vue';
-import type { SpreadsheetNormalizedSchema } from '../types/index.js';
+import type { MaybeRefOrGetter } from 'vue';
 export interface UseSpreadsheetContextParams {
-    schema: ComputedRef<SpreadsheetNormalizedSchema>;
+    /** Entries of `options.context`: values, refs, getters, or queries. */
+    input: MaybeRefOrGetter<Readonly<Record<string, unknown>> | undefined>;
 }
+/** The context passed to every schema callback: plain entries as they are, queries once loaded. */
 export declare function useSpreadsheetContext(params: UseSpreadsheetContextParams): {
-    context: Readonly<import("vue").Ref<{
-        key: string;
-        data?: unknown;
-        error?: unknown;
-        isPending?: boolean;
-        isFetching?: boolean;
-        isSuccess?: boolean;
-        isRefetching?: boolean;
-        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
-    }[], {
-        key: string;
-        data?: unknown;
-        error?: unknown;
-        isPending?: boolean;
-        isFetching?: boolean;
-        isSuccess?: boolean;
-        isRefetching?: boolean;
-        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
-    }[]>>;
-    contextData: ComputedRef<Partial<{
-        [x: string]: unknown;
-    }>>;
-    contextItems: ComputedRef<readonly import("../types/index.js").SpreadsheetContextItem<string, unknown>[]>;
-    contextResults: ComputedRef<{
-        key: string;
-        data?: unknown;
-        error?: unknown;
-        isPending?: boolean;
-        isFetching?: boolean;
-        isSuccess?: boolean;
-        isRefetching?: boolean;
-        refetch: () => Promise<import("../types/index.js").SpreadsheetValue>;
-    }[]>;
-    error: ComputedRef<unknown>;
-    refreshContext: () => Promise<unknown[]>;
-    status: ComputedRef<{
-        initialized: boolean;
-        isFetching: boolean;
-        isPending: boolean;
-        isReady: boolean;
-        isRefreshing: boolean;
-    }>;
+    ctx: import("vue").ComputedRef<Record<string, unknown>>;
+    error: import("vue").ComputedRef<Error | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    ready: import("vue").ComputedRef<boolean>;
 };

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

@@ -1,35 +1,31 @@
-import { useQueries } from "@tanstack/vue-query";
-import { computed } from "vue";
-import {
-  createSpreadsheetContextData,
-  createSpreadsheetContextQueries,
-  createSpreadsheetContextStatus
-} from "../utils/index.js";
+import { computed, toValue } from "vue";
+import { isSpreadsheetQueryDefinition } from "../utils/index.js";
+import { useSpreadsheetQueries } from "./use-spreadsheet-queries.js";
 export function useSpreadsheetContext(params) {
-  const contextItems = computed(() => params.schema.value.context);
-  const context = useQueries({
-    combine: (results) => results.map((result, index) => ({
-      key: contextItems.value[index]?.key,
-      ...result
-    })),
-    queries: () => createSpreadsheetContextQueries(contextItems.value)
-  });
-  const contextResults = computed(() => context.value);
-  const contextData = computed(
-    () => createSpreadsheetContextData(contextItems.value, contextResults.value)
+  const entries = computed(
+    () => Object.entries(toValue(params.input) ?? {}).map(([key, entry]) => {
+      const resolved = toValue(entry);
+      return isSpreadsheetQueryDefinition(resolved) ? { key, kind: "query", query: resolved } : { key, kind: "value", value: resolved };
+    })
+  );
+  const queries = computed(
+    () => entries.value.flatMap((entry) => entry.kind === "query" ? [entry.query] : [])
   );
-  const status = computed(() => createSpreadsheetContextStatus(contextResults.value));
-  const error = computed(() => contextResults.value.find((result) => result.error)?.error);
-  function refreshContext() {
-    return Promise.all(contextResults.value.map((result) => result.refetch()));
-  }
-  return {
-    context,
-    contextData,
-    contextItems,
-    contextResults,
-    error,
-    refreshContext,
-    status
-  };
+  const results = useSpreadsheetQueries(() => queries.value);
+  const ctx = computed(() => {
+    let queryIndex = 0;
+    const data = {};
+    for (const entry of entries.value) {
+      if (entry.kind === "value") data[entry.key] = entry.value;
+      else {
+        data[entry.key] = results.value[queryIndex]?.data;
+        queryIndex += 1;
+      }
+    }
+    return data;
+  });
+  const loading = computed(() => results.value.some((result) => result.pending));
+  const error = computed(() => results.value.find((result) => result.error)?.error ?? null);
+  const ready = computed(() => !loading.value && !error.value);
+  return { ctx, error, loading, ready };
 }

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

@@ -0,0 +1,11 @@
+/**
+ * Cell edits made in review, by row and field. An edit replaces the cell text and goes through the
+ * same parsing, options, and rules as the file.
+ */
+export declare function useSpreadsheetEdits(): {
+    clear: () => void;
+    count: import("vue").ComputedRef<number>;
+    edits: import("vue").ShallowRef<ReadonlyMap<number, Readonly<Record<string, string>>>, ReadonlyMap<number, Readonly<Record<string, string>>>>;
+    revert: (index: number, field: string) => void;
+    set: (index: number, field: string, text: string) => void;
+};

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

@@ -0,0 +1,25 @@
+import { computed, shallowRef } from "vue";
+export function useSpreadsheetEdits() {
+  const edits = shallowRef(/* @__PURE__ */ new Map());
+  function set(index, field, text) {
+    const next = new Map(edits.value);
+    next.set(index, { ...next.get(index), [field]: text });
+    edits.value = next;
+  }
+  function revert(index, field) {
+    const current = edits.value.get(index);
+    if (!current || !(field in current)) return;
+    const next = new Map(edits.value);
+    const rest = Object.fromEntries(Object.entries(current).filter(([key]) => key !== field));
+    if (Object.keys(rest).length) next.set(index, rest);
+    else next.delete(index);
+    edits.value = next;
+  }
+  function clear() {
+    edits.value = /* @__PURE__ */ new Map();
+  }
+  const count = computed(
+    () => [...edits.value.values()].reduce((total, fields) => total + Object.keys(fields).length, 0)
+  );
+  return { clear, count, edits, revert, set };
+}

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

@@ -0,0 +1,16 @@
+import type { ComputedRef } from 'vue';
+import type { UiToolsTranslator } from '#ui-tools/i18n';
+import type { SpreadsheetRuntimeSchema } from '../types/index.js';
+import type { useSpreadsheetContext } from './use-spreadsheet-context.js';
+export interface UseSpreadsheetFieldsParams {
+    schema: ComputedRef<SpreadsheetRuntimeSchema>;
+    context: ReturnType<typeof useSpreadsheetContext>;
+    t: UiToolsTranslator;
+}
+/** The schema's columns resolved for the current context, once the context is loaded. */
+export declare function useSpreadsheetFields(params: UseSpreadsheetFieldsParams): {
+    byPath: ComputedRef<Map<string, import("..").SpreadsheetField>>;
+    columnFields: ComputedRef<import("..").SpreadsheetField[]>;
+    fields: ComputedRef<import("..").SpreadsheetField[]>;
+    groups: ComputedRef<import("..").SpreadsheetFieldGroup[]>;
+};

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

@@ -0,0 +1,20 @@
+import { computed } from "vue";
+import { createSpreadsheetColumnsBuilder } from "../schema/builder.js";
+import { resolveSpreadsheetFields } from "../utils/index.js";
+export function useSpreadsheetFields(params) {
+  const builder = createSpreadsheetColumnsBuilder();
+  const entries = computed(() => params.schema.value.columns(builder)["~entries"]);
+  const resolved = computed(() => {
+    if (!params.context.ready.value) return { fields: [], groups: [] };
+    return resolveSpreadsheetFields({
+      ctx: params.context.ctx.value,
+      entries: entries.value,
+      t: params.t
+    });
+  });
+  const fields = computed(() => resolved.value.fields);
+  const groups = computed(() => resolved.value.groups);
+  const byPath = computed(() => new Map(fields.value.map((field) => [field.path, field])));
+  const columnFields = computed(() => fields.value.filter((field) => !field.select?.from));
+  return { byPath, columnFields, fields, groups };
+}

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

@@ -0,0 +1,14 @@
+import type { SpreadsheetFileSource, SpreadsheetWorkbook } from '../types/index.js';
+/** The file being imported: reading, errors, and its sheets. */
+export declare function useSpreadsheetFile(): {
+    clear: () => void;
+    error: import("vue").ShallowRef<unknown, unknown>;
+    load: (source: SpreadsheetFileSource, name?: string) => Promise<void>;
+    paste: (text: string, name?: string) => void;
+    reading: import("vue").ShallowRef<boolean, boolean>;
+    sheets: import("vue").ComputedRef<{
+        name: string;
+        rowCount: number;
+    }[]>;
+    workbook: import("vue").ShallowRef<SpreadsheetWorkbook | null, SpreadsheetWorkbook | null>;
+};

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

@@ -0,0 +1,44 @@
+import { computed, shallowRef } from "vue";
+import { readSpreadsheetFile, readSpreadsheetText } from "../utils/index.js";
+export function useSpreadsheetFile() {
+  const workbook = shallowRef(null);
+  const reading = shallowRef(false);
+  const error = shallowRef(null);
+  let run = 0;
+  async function load(source, name) {
+    const current = run += 1;
+    reading.value = true;
+    error.value = null;
+    const fileName = name ?? (source instanceof File ? source.name : "import.xlsx");
+    try {
+      const next = await readSpreadsheetFile({ name: fileName, source });
+      if (current === run) workbook.value = next;
+    } catch (nextError) {
+      if (current === run) {
+        workbook.value = null;
+        error.value = nextError;
+      }
+    } finally {
+      if (current === run) reading.value = false;
+    }
+  }
+  function paste(text, name = "clipboard.tsv") {
+    run += 1;
+    error.value = null;
+    reading.value = false;
+    workbook.value = readSpreadsheetText({ name, text });
+  }
+  function clear() {
+    run += 1;
+    workbook.value = null;
+    error.value = null;
+    reading.value = false;
+  }
+  const sheets = computed(
+    () => (workbook.value?.sheets ?? []).map((sheet) => ({
+      name: sheet.name,
+      rowCount: sheet.rows.length
+    }))
+  );
+  return { clear, error, load, paste, reading, sheets, workbook };
+}

package/dist/runtime/spreadsheet/composables/use-spreadsheet-import-context.d.ts

@@ -0,0 +1,12 @@
+import type { SpreadsheetImporter, SpreadsheetSteps } from '../types/index.js';
+interface SpreadsheetImportProvided {
+    readonly importer: SpreadsheetImporter;
+    readonly steps: SpreadsheetSteps | null;
+}
+/** Provides an importer, and optionally its steps, to the `SpreadsheetImport*` parts below. */
+export declare function provideSpreadsheetImport(provided: SpreadsheetImportProvided): void;
+/** The importer of a part: its own `importer` prop, or the one of the closest root. */
+export declare function useSpreadsheetImporter(own?: () => SpreadsheetImporter | undefined): import("vue").ComputedRef<SpreadsheetImporter<import("../types/index.js").SpreadsheetRuntimeSchema>>;
+/** The steps of a part: its own `steps` prop, the closest root's, or `null` outside a wizard. */
+export declare function useSpreadsheetStepsContext(own?: () => SpreadsheetSteps | undefined): import("vue").ComputedRef<SpreadsheetSteps | null>;
+export {};

package/dist/runtime/spreadsheet/composables/use-spreadsheet-import-context.js

@@ -0,0 +1,22 @@
+import { computed, inject, provide } from "vue";
+const SPREADSHEET_IMPORT = Symbol.for(
+  "nuxt-ui-tools.spreadsheet-import"
+);
+export function provideSpreadsheetImport(provided) {
+  provide(SPREADSHEET_IMPORT, provided);
+}
+export function useSpreadsheetImporter(own) {
+  const provided = inject(SPREADSHEET_IMPORT, null);
+  return computed(() => {
+    const importer = own?.() ?? provided?.importer;
+    if (!importer)
+      throw new Error(
+        "[spreadsheet] Pass `importer` to the part or place it in a `SpreadsheetImportRoot`."
+      );
+    return importer;
+  });
+}
+export function useSpreadsheetStepsContext(own) {
+  const provided = inject(SPREADSHEET_IMPORT, null);
+  return computed(() => own?.() ?? provided?.steps ?? null);
+}

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

@@ -1,8 +1,19 @@
 import type { MaybeRefOrGetter } from 'vue';
-import type { SpreadsheetImportApi } from '../types/index.js';
-import type { SpreadsheetInternals } from './use-spreadsheet-internals.js';
-export declare function useSpreadsheetImport<TSchema extends {
-    importKey: string;
-}>(schema: MaybeRefOrGetter<TSchema>): SpreadsheetImportApi<TSchema> & {
-    __internals: SpreadsheetInternals<TSchema>;
-};
+import type { SpreadsheetImporter, SpreadsheetImportOptions, SpreadsheetRuntimeSchema } from '../types/index.js';
+/**
+ * The import runtime of a schema: file, layout, columns, values, rows, review, and submit, each a
+ * reactive model readable in templates and scripts. Use it headless, with the `SpreadsheetImport*`
+ * parts, or with the ready-made `<SpreadsheetImport>`.
+ *
+ * @example
+ * ```ts
+ * const importer = useSpreadsheetImport(assessmentsImport, {
+ *   context: { center: () => center.value, products: productsQuery() },
+ *   onSubmit: ({ create, update }) => api.assessments.import({ create, update }),
+ * })
+ * importer.file.load(file)
+ * await importer.ready()
+ * importer.readiness.canSubmit
+ * ```
+ */
+export declare function useSpreadsheetImport<const TSchema extends SpreadsheetRuntimeSchema>(schema: MaybeRefOrGetter<TSchema>, ...args: [keyof NonNullable<TSchema['~context']>] extends [never] ? [options?: SpreadsheetImportOptions<TSchema>] : [options: SpreadsheetImportOptions<TSchema>]): SpreadsheetImporter<TSchema>;