nuxt-ui-tools 1.11.2 → 1.13.0

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

@@ -0,0 +1,27 @@
+import type { SpreadsheetPrimitiveOption, SpreadsheetRecognizedValue, SpreadsheetValueAnswer, SpreadsheetValueQuestion, SpreadsheetValueTarget } from '../types/index.js';
+import type { useSpreadsheetAnswers } from './use-spreadsheet-answers.js';
+import type { useSpreadsheetFields } from './use-spreadsheet-fields.js';
+import type { useSpreadsheetOptions } from './use-spreadsheet-options.js';
+import type { useSpreadsheetRows } from './use-spreadsheet-rows.js';
+export interface UseSpreadsheetValuesParams {
+    fields: ReturnType<typeof useSpreadsheetFields>;
+    options: ReturnType<typeof useSpreadsheetOptions>;
+    answers: ReturnType<typeof useSpreadsheetAnswers>;
+    rows: ReturnType<typeof useSpreadsheetRows>;
+}
+/**
+ * Distinct values of select columns that match no option, as questions answered once for every
+ * row using them (per set of options, when options depend on the row); and the values that
+ * matched, for display.
+ */
+export declare function useSpreadsheetValues(params: UseSpreadsheetValuesParams): {
+    answer: (target: SpreadsheetValueTarget, choice: SpreadsheetValueAnswer | SpreadsheetPrimitiveOption) => void;
+    choices: (field: string, row?: number) => readonly import("..").SpreadsheetResolvedOption[];
+    clear: (target: SpreadsheetValueTarget) => void;
+    open: import("vue").ComputedRef<SpreadsheetValueQuestion<string>[]>;
+    questions: import("vue").ComputedRef<SpreadsheetValueQuestion<string>[]>;
+    recognized: import("vue").ComputedRef<(SpreadsheetRecognizedValue<string> & {
+        rows: number[];
+    })[]>;
+    search: (path: string, text: string) => Promise<readonly import("..").SpreadsheetResolvedOption[]>;
+};

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

@@ -0,0 +1,121 @@
+import { computed } from "vue";
+import { normalizeSpreadsheetText, spreadsheetAnswerKey } from "../utils/index.js";
+function isAnswer(value) {
+  return typeof value === "object" && value !== null && "action" in value;
+}
+export function useSpreadsheetValues(params) {
+  function scopeOf(field, scope, rows) {
+    const dependsOn = (field.select?.rowOptions?.dependsOn ?? []).map((path) => {
+      const values = /* @__PURE__ */ new Set();
+      for (const index of rows) {
+        const display = params.rows.parsed.value[index]?.cells.get(path)?.display;
+        if (display) values.add(display);
+      }
+      return {
+        field: path,
+        label: params.fields.byPath.value.get(path)?.label ?? path,
+        values: [...values]
+      };
+    });
+    return { dependsOn, id: scope };
+  }
+  const questions = computed(() => {
+    const byId = /* @__PURE__ */ new Map();
+    const answers = params.answers.answers.value;
+    for (const [index, row] of params.rows.parsed.value.entries()) {
+      const reason = params.rows.rows.value[index]?.discardReason;
+      if (reason && reason !== "value") continue;
+      for (const token of row.unmatched) {
+        const key = spreadsheetAnswerKey(token.key, token.scope);
+        const id = `${token.field}::${key}`;
+        const existing = byId.get(id);
+        if (existing) {
+          existing.rows.push(index);
+          continue;
+        }
+        const field = params.fields.byPath.value.get(token.field);
+        const select = field?.select;
+        if (!field || !select) continue;
+        const userAnswer = answers[token.field]?.[key] ?? null;
+        const policyAnswer = select.unknown === "ask" || select.unknown === "error" ? null : { action: select.unknown };
+        const effective = userAnswer ?? policyAnswer;
+        byId.set(id, {
+          answer: effective,
+          answeredBy: userAnswer ? "user" : policyAnswer ? "policy" : null,
+          canCreate: Boolean(select.create),
+          choices: row.cells.get(token.field)?.choices ?? [],
+          field: token.field,
+          fieldLabel: field.group ? `${field.group.label} \xB7 ${field.label}` : field.label,
+          header: token.header,
+          id,
+          key,
+          policy: select.unknown,
+          remote: params.options.options.value.get(token.field)?.remote ?? false,
+          rows: [index],
+          scopeId: token.scope,
+          state: effective ? "answered" : "open",
+          value: token.value
+        });
+      }
+    }
+    return [...byId.values()].filter((question) => question.policy !== "error").map(({ scopeId, ...question }) => {
+      const field = params.fields.byPath.value.get(question.field);
+      return {
+        ...question,
+        scope: scopeId && field ? scopeOf(field, scopeId, question.rows) : null
+      };
+    });
+  });
+  const open = computed(() => questions.value.filter((question) => question.state === "open"));
+  const recognized = computed(() => {
+    const byId = /* @__PURE__ */ new Map();
+    for (const [index, row] of params.rows.parsed.value.entries()) {
+      for (const token of row.matched) {
+        const id = `${token.field}::${spreadsheetAnswerKey(token.key, token.scope)}`;
+        const existing = byId.get(id);
+        if (existing) existing.rows.push(index);
+        else
+          byId.set(id, {
+            field: token.field,
+            option: token.option,
+            rows: [index],
+            scope: token.scope,
+            value: token.value
+          });
+      }
+    }
+    return [...byId.values()];
+  });
+  function choices(field, row) {
+    if (row !== void 0) {
+      const cell = params.rows.parsed.value[row]?.cells.get(field);
+      if (cell) return cell.choices;
+    }
+    return params.options.options.value.get(field)?.options ?? [];
+  }
+  function keyOf(target) {
+    return spreadsheetAnswerKey(normalizeSpreadsheetText(target.value), target.scope?.id);
+  }
+  function answer(target, choice) {
+    const key = keyOf(target);
+    if (isAnswer(choice)) {
+      params.answers.set(target.field, key, choice);
+      return;
+    }
+    const question = questions.value.find(
+      (candidate) => candidate.field === target.field && candidate.key === key
+    );
+    const option = (question?.choices ?? choices(target.field)).find(
+      (entry) => entry.value === choice
+    );
+    params.answers.set(target.field, key, {
+      action: "map",
+      label: option?.label ?? String(choice),
+      value: choice
+    });
+  }
+  function clear(target) {
+    params.answers.remove(target.field, keyOf(target));
+  }
+  return { answer, choices, clear, open, questions, recognized, search: params.options.search };
+}

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

@@ -1,4 +1,3 @@
 export * from './composables/index.js';
 export * from './schema/index.js';
-export * from './utils/index.js';
 export type * from './types';

package/dist/runtime/spreadsheet/index.js

@@ -1,3 +1,2 @@
 export * from "./composables/index.js";
 export * from "./schema/index.js";
-export * from "./utils/index.js";

package/dist/runtime/spreadsheet/schema/builder.d.ts

@@ -0,0 +1,8 @@
+import type { SpreadsheetColumnFactory, SpreadsheetColumnsBuilder } from '../types/index.js';
+/**
+ * The `c` passed to `columns`. Each method records a column and returns a new builder; the
+ * runtime reads the columns from `'~entries'`.
+ */
+export declare function createSpreadsheetColumnsBuilder<TContext>(): SpreadsheetColumnsBuilder<TContext, NonNullable<unknown>>;
+/** The `c` passed to a dynamic group's `column`: each method returns one column. */
+export declare function createSpreadsheetColumnFactory(): SpreadsheetColumnFactory<never, never>;

package/dist/runtime/spreadsheet/schema/builder.js

@@ -0,0 +1,31 @@
+function createColumn(kind, key, config) {
+  return { config: config ?? {}, entry: "column", key, kind };
+}
+function columnMethods(add) {
+  return {
+    boolean: (key, options) => add(createColumn("boolean", key, options)),
+    date: (key, options) => add(createColumn("date", key, options)),
+    number: (key, options) => add(createColumn("number", key, options)),
+    select: (key, options) => add(createColumn("select", key, options)),
+    text: (key, options) => add(createColumn("text", key, options))
+  };
+}
+function createBuilder(entries) {
+  return {
+    ...columnMethods((column) => createBuilder([...entries, column])),
+    "~entries": entries,
+    dynamic: (key, options) => createBuilder([...entries, { config: options, entry: "dynamic", key }]),
+    group: (key, options, build) => {
+      const children = build(createBuilder([]))["~entries"].filter(
+        (entry) => entry.entry === "column"
+      );
+      return createBuilder([...entries, { children, config: options, entry: "group", key }]);
+    }
+  };
+}
+export function createSpreadsheetColumnsBuilder() {
+  return createBuilder([]);
+}
+export function createSpreadsheetColumnFactory() {
+  return columnMethods((column) => column);
+}

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

@@ -1,32 +1,24 @@
-import type { SpreadsheetColumnsDefinition, SpreadsheetContextDataFromItems, SpreadsheetContextItem, SpreadsheetFileDefinition, SpreadsheetHeaderStepDefinition, SpreadsheetMatchingStepDefinition, SpreadsheetReferenceBuilder, SpreadsheetSchemaWithRefine, SpreadsheetResolvedColumns, SpreadsheetReviewStepDefinition, SpreadsheetRowData, SpreadsheetSheetStepDefinition, SpreadsheetStepsDefinition } from '../types/index.js';
-type SpreadsheetResolvedColumnsInput<TColumns> = [TColumns] extends [
-    SpreadsheetColumnsDefinition<any>
-] ? SpreadsheetResolvedColumns<TColumns> : undefined;
-type SpreadsheetExtractedReference<TValue> = Extract<TValue, import('../types').SpreadsheetReferenceDefinition<any, any, any>>;
-type SpreadsheetResolvedReferences<TReferences> = TReferences extends (...args: infer _Args) => infer TResult ? TResult extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TResult[number]>[] : readonly [] : TReferences extends readonly unknown[] ? readonly SpreadsheetExtractedReference<TReferences[number]>[] : readonly [];
-interface SpreadsheetSchemaDefinition<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> {
-    importKey: TImportKey;
-    file?: SpreadsheetFileDefinition;
-    sheet?: SpreadsheetSheetStepDefinition;
-    header?: SpreadsheetHeaderStepDefinition;
-    matching?: SpreadsheetMatchingStepDefinition;
-    steps?: SpreadsheetStepsDefinition;
-    review?: SpreadsheetReviewStepDefinition;
-    context?: TContextItems;
-    columns?: TColumns;
-    references?: TReferences;
-    buildRow?: TBuildRow;
-}
-type SpreadsheetBuildRowInput<TContext, TRow, TResult> = (params: {
-    context: TContext;
-    row: TRow;
-}) => TResult | Promise<TResult>;
-type SpreadsheetSchemaReturn<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = Omit<SpreadsheetSchemaDefinition<TImportKey, TContextItems, TColumns, TReferences, TBuildRow>, 'columns'> & {
-    columns?: SpreadsheetResolvedColumnsInput<TColumns>;
-    __columnsInput?: TColumns;
-};
-type SpreadsheetDefinedSchemaReturn<TImportKey extends string, TContextItems extends readonly SpreadsheetContextItem<string, unknown>[], TColumns, TReferences, TBuildRow> = SpreadsheetSchemaWithRefine<SpreadsheetSchemaReturn<TImportKey, TContextItems, TColumns, TReferences, TBuildRow>>;
-export declare function defineSpreadsheetSchema<const TImportKey extends string, const TContextItems extends readonly SpreadsheetContextItem<string, unknown>[] = readonly [], TContextData = SpreadsheetContextDataFromItems<TContextItems>, const TColumns extends SpreadsheetColumnsDefinition<TContextData> | undefined = SpreadsheetColumnsDefinition<TContextData> | undefined, const TReferences extends readonly unknown[] | undefined = readonly unknown[] | undefined, TReferenceRow = SpreadsheetRowData<SpreadsheetResolvedColumnsInput<TColumns>, readonly []>, TResolvedReferences = SpreadsheetResolvedReferences<TReferences>, TFinalRow = SpreadsheetRowData<SpreadsheetResolvedColumnsInput<TColumns>, TResolvedReferences>, TBuildRowResult = never>(schema: SpreadsheetSchemaDefinition<TImportKey, TContextItems, TColumns, TReferences | ((reference: SpreadsheetReferenceBuilder<TReferenceRow>) => TReferences), SpreadsheetBuildRowInput<TContextData, TFinalRow, TBuildRowResult> | undefined> & {
-    relations?: undefined;
-}): SpreadsheetDefinedSchemaReturn<TImportKey, TContextItems, TColumns, TReferences, SpreadsheetBuildRowInput<TContextData, TFinalRow, TBuildRowResult> | undefined>;
-export * from './normalize.js';
+import type { SpreadsheetLookupResult, SpreadsheetPrettify, SpreadsheetRowKey, SpreadsheetSchema, SpreadsheetSchemaDefinition } from '../types/index.js';
+export { createSpreadsheetColumnsBuilder } from './builder.js';
+type SpreadsheetSchemaFactory<TContext> = <TRow, const TKeyValue extends SpreadsheetRowKey = never, TLookup extends SpreadsheetLookupResult = never, TOutput = SpreadsheetPrettify<TRow>>(definition: SpreadsheetSchemaDefinition<TContext, TRow, TKeyValue, TLookup, TOutput>) => SpreadsheetSchema<TContext, TRow, TKeyValue, TLookup, TOutput>;
+/**
+ * Declares an import: its columns, how their values match, the rules, row identity, and output.
+ * Pass the context type first when the columns depend on data the page provides; every callback
+ * then receives it as `ctx`. Columns are chained, and each column's callbacks read the columns
+ * declared above it as `row`.
+ *
+ * @example
+ * ```ts
+ * const assessmentsImport = defineSpreadsheetSchema<{ center: TestCenter; products: Product[] }>()({
+ *   key: 'assessments',
+ *   columns: (c) =>
+ *     c
+ *       .text('secureCode', { label: 'Secure code', required: true })
+ *       .select('productId', { options: ({ ctx }) => ctx.products.map(toOption), required: true })
+ *       .select('level', { options: ({ row, ctx }) => scaleOf(ctx, row.productId) }),
+ *   rows: { key: (row) => row.secureCode, existing: { lookup: ({ keys }) => assessmentsQuery(keys) } },
+ * })
+ * ```
+ */
+export declare function defineSpreadsheetSchema<TContext>(): SpreadsheetSchemaFactory<TContext>;
+export declare function defineSpreadsheetSchema<TRow, const TKeyValue extends SpreadsheetRowKey = never, TLookup extends SpreadsheetLookupResult = never, TOutput = SpreadsheetPrettify<TRow>>(definition: SpreadsheetSchemaDefinition<NonNullable<unknown>, TRow, TKeyValue, TLookup, TOutput>): SpreadsheetSchema<NonNullable<unknown>, TRow, TKeyValue, TLookup, TOutput>;

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

@@ -1,22 +1,5 @@
-import { resolveSpreadsheetColumns } from "../utils/builders/index.js";
-function withSpreadsheetRefine(schema) {
-  return {
-    ...schema,
-    refine(refinement) {
-      return withSpreadsheetRefine({
-        ...schema,
-        relations: refinement.relations
-      });
-    }
-  };
+export { createSpreadsheetColumnsBuilder } from "./builder.js";
+export function defineSpreadsheetSchema(definition) {
+  if (definition) return definition;
+  return (next) => next;
 }
-export function defineSpreadsheetSchema(schema) {
-  if (!schema.columns) {
-    return withSpreadsheetRefine(schema);
-  }
-  return withSpreadsheetRefine({
-    ...schema,
-    columns: resolveSpreadsheetColumns(schema.columns)
-  });
-}
-export * from "./normalize.js";