nuxt-ui-tools 1.12.0 → 1.13.0

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

@@ -1,26 +1,339 @@
-import { useSpreadsheetColumnMatching } from "./use-spreadsheet-column-matching.js";
-import { useSpreadsheetRowState } from "./use-spreadsheet-row-state.js";
+import { useQueryClient } from "@tanstack/vue-query";
+import { computed, shallowRef, watch } from "vue";
+import {
+  createSpreadsheetIssuesWorkbook,
+  detectSpreadsheetKeyFields,
+  diffSpreadsheetRow,
+  getSpreadsheetPathValue,
+  isSpreadsheetQueryDefinition,
+  isSpreadsheetRecord,
+  parseSpreadsheetRow,
+  resolveSpreadsheetExistingAction,
+  serializeSpreadsheetRowKey,
+  toSpreadsheetText
+} from "../utils/index.js";
+import { useSpreadsheetQueries } from "./use-spreadsheet-queries.js";
+const LEVEL_RANK = { error: 3, info: 1, warning: 2 };
+function mostSevere(issues) {
+  const byField = {};
+  for (const issue of issues) {
+    if (!issue.field || issue.code === "value.skipped") continue;
+    const current = byField[issue.field];
+    if (!current || LEVEL_RANK[issue.level] > LEVEL_RANK[current.level])
+      byField[issue.field] = issue;
+  }
+  return byField;
+}
+function isRecordList(value) {
+  return Array.isArray(value);
+}
 export function useSpreadsheetRows(params) {
-  const matching = useSpreadsheetColumnMatching({
-    contextData: params.contextData,
-    headers: params.headers,
-    schema: params.schema
-  });
-  const rowState = useSpreadsheetRowState({
-    columnMatches: matching.columnMatches,
-    contextData: params.contextData,
-    dynamicColumnMatches: matching.dynamicColumnMatches,
-    refreshSources: [
-      params.contextData,
-      params.headers,
-      params.rows,
-      matching.columnMatches,
-      matching.manualColumnAssignments
-    ],
-    rows: params.rows
+  const queryClient = useQueryClient();
+  const manualDiscards = shallowRef(/* @__PURE__ */ new Set());
+  const rejections = shallowRef(/* @__PURE__ */ new Map());
+  watch([params.layout.sheet, () => params.layout.selection.value.headerRow], () => {
+    manualDiscards.value = /* @__PURE__ */ new Set();
+    rejections.value = /* @__PURE__ */ new Map();
+  });
+  const parseContext = computed(() => {
+    void params.options.options.value;
+    return {
+      answers: params.answers.answers.value,
+      columns: params.columns.matches.value,
+      ctx: params.context.ctx.value,
+      fields: params.fields.fields.value,
+      headers: params.layout.headers.value.map((header) => header.text),
+      optionsOf: params.options.optionsOf,
+      t: params.t
+    };
+  });
+  let cacheContext = null;
+  const cache = /* @__PURE__ */ new Map();
+  const parsed = computed(() => {
+    const context = parseContext.value;
+    if (cacheContext !== context) {
+      cache.clear();
+      cacheContext = context;
+    }
+    const raws = params.layout.dataRaws.value;
+    return params.layout.dataRows.value.map((cells, index) => {
+      const edits = params.edits.edits.value.get(index);
+      const cached = cache.get(index);
+      if (cached && cached.cells === cells && cached.edits === edits) return cached.result;
+      const result = parseSpreadsheetRow({ cells, context, edits, index, raws: raws[index] });
+      cache.set(index, { cells, edits, result });
+      return result;
+    });
+  });
+  const validationCache = /* @__PURE__ */ new WeakMap();
+  const validated = computed(() => {
+    const validate = params.schema.value.validate;
+    const ctx = params.context.ctx.value;
+    return parsed.value.map((row) => {
+      if (!validate) return row.issues;
+      const cached = validationCache.get(row);
+      if (cached) return cached;
+      const extra = validate({
+        ctx,
+        issue: (field, message, options) => ({
+          code: options?.code ?? "validate",
+          field,
+          level: options?.level ?? "error",
+          message
+        }),
+        row: row.data
+      }).flatMap((entry) => entry ? [{ ...entry, field: entry.field }] : []);
+      const withExtra = extra.length ? [...row.issues, ...extra] : row.issues;
+      validationCache.set(row, withExtra);
+      return withExtra;
+    });
+  });
+  const keyOf = computed(() => params.schema.value.rows?.key);
+  const keys = computed(() => {
+    const key = keyOf.value;
+    if (!key) return parsed.value.map(() => null);
+    return parsed.value.map((row) => {
+      try {
+        const value = key(row.data);
+        const serialized = serializeSpreadsheetRowKey(value);
+        return serialized === null ? null : { serialized, value };
+      } catch {
+        return null;
+      }
+    });
+  });
+  const keyFields = computed(() => {
+    const key = keyOf.value;
+    const sample = parsed.value.find((row) => Object.keys(row.data).length)?.data;
+    return key && sample ? detectSpreadsheetKeyFields(key, sample) : [];
+  });
+  const duplicates = computed(() => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const [index, key] of keys.value.entries()) {
+      if (!key) continue;
+      const group = groups.get(key.serialized);
+      if (group) group.push(index);
+      else groups.set(key.serialized, [index]);
+    }
+    const policy = params.schema.value.rows?.duplicates ?? "error";
+    const blocked = /* @__PURE__ */ new Map();
+    const discarded2 = /* @__PURE__ */ new Set();
+    for (const group of groups.values()) {
+      if (group.length < 2) continue;
+      if (policy === "error")
+        for (const index of group)
+          blocked.set(index, group.find((other) => other !== index) ?? index);
+      else {
+        const kept = policy === "keep-first" ? group[0] : group.at(-1);
+        for (const index of group) if (index !== kept) discarded2.add(index);
+      }
+    }
+    return { blocked, discarded: discarded2 };
+  });
+  const lookupKeys = computed(() => {
+    const seen = /* @__PURE__ */ new Map();
+    for (const key of keys.value)
+      if (key && !seen.has(key.serialized)) seen.set(key.serialized, key.value);
+    return seen;
+  });
+  const existingQuery = computed(() => {
+    const existing = params.schema.value.rows?.existing;
+    if (!existing || !lookupKeys.value.size || !params.context.ready.value) return [];
+    const values = [...lookupKeys.value.values()];
+    const ctx = params.context.ctx.value;
+    return [
+      {
+        queryFn: async () => {
+          const result = existing.lookup({ ctx, keys: values });
+          return isSpreadsheetQueryDefinition(result) ? queryClient.fetchQuery(result) : await result;
+        },
+        queryKey: ["spreadsheet", params.schema.value.key, "existing", ...lookupKeys.value.keys()]
+      }
+    ];
+  });
+  const existingResults = useSpreadsheetQueries(() => existingQuery.value);
+  const existingLoading = computed(() => existingResults.value.some((result) => result.pending));
+  const existingByKey = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    const records = existingResults.value[0]?.data;
+    const definition = params.schema.value.rows?.existing;
+    const key = keyOf.value;
+    if (!isRecordList(records) || !definition || !key) return map;
+    for (const record of records) {
+      try {
+        const value = definition.keyOf ? definition.keyOf(record) : isSpreadsheetRecord(record) ? key(record) : null;
+        const serialized = serializeSpreadsheetRowKey(value);
+        if (serialized !== null) map.set(serialized, record);
+      } catch {
+      }
+    }
+    return map;
+  });
+  const maxRows = computed(() => params.schema.value.file?.maxRows ?? Infinity);
+  const fieldPaths = computed(() => params.fields.fields.value.map((field) => field.path));
+  const rows = computed(() => {
+    const t = params.t;
+    const numbers = params.layout.dataRowNumbers.value;
+    const definition = params.schema.value.rows?.existing;
+    const ctx = params.context.ctx.value;
+    return parsed.value.map((row, index) => {
+      const rowIssues = [...validated.value[index] ?? row.issues];
+      const key = keys.value[index];
+      const duplicateOf = duplicates.value.blocked.get(index);
+      if (duplicateOf !== void 0) {
+        const message = t("spreadsheet.issues.duplicate", {
+          row: numbers[duplicateOf] ?? duplicateOf + 1
+        });
+        const targets = keyFields.value.length ? keyFields.value : [null];
+        for (const field of targets)
+          rowIssues.push({ code: "row.duplicate", field, level: "error", message });
+      }
+      const existing = key ? existingByKey.value.get(key.serialized) : void 0;
+      let mode = "create";
+      let changed = [];
+      if (existing !== void 0 && definition) {
+        const action = resolveSpreadsheetExistingAction({
+          action: definition.action,
+          ctx,
+          existing,
+          row: row.data
+        });
+        mode = action === "skip" ? "skip" : "update";
+        if (action === "error")
+          rowIssues.push({
+            code: "row.exists",
+            field: keyFields.value[0] ?? null,
+            level: "error",
+            message: t("spreadsheet.issues.exists")
+          });
+        else changed = diffSpreadsheetRow({ data: row.data, existing, paths: fieldPaths.value });
+      }
+      rowIssues.push(...rejections.value.get(index) ?? []);
+      const discardReason = index >= maxRows.value ? "limit" : row.skipped ? "value" : duplicates.value.discarded.has(index) ? "duplicate" : mode === "skip" ? "existing" : manualDiscards.value.has(index) ? "manual" : null;
+      const errors = rowIssues.filter((issue) => issue.level === "error");
+      const warnings = rowIssues.filter((issue) => issue.level === "warning");
+      return {
+        changed,
+        data: row.data,
+        discardReason,
+        edited: Object.keys(params.edits.edits.value.get(index) ?? {}),
+        errors,
+        existing,
+        fieldIssues: mostSevere(rowIssues),
+        importable: !discardReason && !errors.length,
+        index,
+        issues: rowIssues,
+        mode,
+        rowNumber: numbers[index] ?? index + 1,
+        status: discardReason ? "discarded" : errors.length ? "blocking" : warnings.length ? "warning" : "valid",
+        warnings
+      };
+    });
   });
+  const valid = computed(() => rows.value.filter((row) => !row.discardReason && !row.errors.length));
+  const invalid = computed(
+    () => rows.value.filter((row) => !row.discardReason && row.errors.length > 0)
+  );
+  const discarded = computed(() => rows.value.filter((row) => row.discardReason));
+  const importable = computed(() => rows.value.filter((row) => row.importable));
+  const byMode = computed(() => ({
+    create: importable.value.filter((row) => row.mode === "create").length,
+    skip: rows.value.filter((row) => row.discardReason === "existing").length,
+    update: importable.value.filter((row) => row.mode === "update").length
+  }));
+  function cell(index, field) {
+    const row = rows.value[index];
+    const result = parsed.value[index]?.cells.get(field);
+    const edits = params.edits.edits.value.get(index);
+    const stored = row?.changed.includes(field) ? toSpreadsheetText(
+      getSpreadsheetPathValue(isSpreadsheetRecord(row.existing) ? row.existing : {}, field)
+    ) : null;
+    return {
+      choices: result?.choices ?? [],
+      created: result?.created ?? false,
+      defaulted: result?.defaulted ?? false,
+      display: result?.display ?? "",
+      edited: Boolean(edits && field in edits),
+      issue: row?.fieldIssues[field] ?? null,
+      original: result?.original ?? "",
+      stored,
+      text: result?.text ?? ""
+    };
+  }
+  function distinct(field) {
+    const values = /* @__PURE__ */ new Set();
+    for (const row of rows.value) {
+      if (row.discardReason) continue;
+      const display = parsed.value[row.index]?.cells.get(field)?.display;
+      if (display) values.add(display);
+    }
+    return [...values];
+  }
+  function issues(field) {
+    return rows.value.flatMap(
+      (row) => row.discardReason ? [] : row.issues.filter((issue) => field ? issue.field === field : true).map((issue) => ({ issue, row: row.index }))
+    );
+  }
+  function edit(index, field, text) {
+    params.edits.set(index, field, text);
+    if (rejections.value.has(index)) {
+      const next = new Map(rejections.value);
+      next.delete(index);
+      rejections.value = next;
+    }
+  }
+  function discard(indexes) {
+    manualDiscards.value = /* @__PURE__ */ new Set([...manualDiscards.value, ...indexes]);
+  }
+  function restore(indexes) {
+    const next = new Set(manualDiscards.value);
+    for (const index of indexes) next.delete(index);
+    manualDiscards.value = next;
+  }
+  function setRejections(next) {
+    rejections.value = next;
+  }
+  function exportInvalid(issuesHeader) {
+    const labels = new Map(params.fields.fields.value.map((field) => [field.path, field.label]));
+    const matches = params.columns.matches.value;
+    return createSpreadsheetIssuesWorkbook({
+      headers: params.layout.headers.value.map((header) => header.text),
+      issuesHeader,
+      labels,
+      rows: invalid.value.map((row) => {
+        const cells = [...params.layout.dataRows.value[row.index] ?? []];
+        for (const [field, text] of Object.entries(params.edits.edits.value.get(row.index) ?? {})) {
+          const column = matches.get(field);
+          if (column !== void 0) cells[column] = text;
+        }
+        return { cells, issues: row.issues };
+      })
+    });
+  }
+  function reset() {
+    manualDiscards.value = /* @__PURE__ */ new Set();
+    rejections.value = /* @__PURE__ */ new Map();
+  }
+  const loading = computed(() => existingLoading.value);
   return {
-    ...matching,
-    ...rowState
+    byMode,
+    cell,
+    discard,
+    discarded,
+    distinct,
+    edit,
+    exportInvalid,
+    importable,
+    invalid,
+    issues,
+    keyFields,
+    loading,
+    parsed,
+    rejections,
+    reset,
+    restore,
+    rows,
+    setRejections,
+    valid
   };
 }

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

@@ -0,0 +1,33 @@
+import type { SpreadsheetStep, SpreadsheetStepContext, SpreadsheetSteps } from '../types/index.js';
+type SpreadsheetStepPreset = Omit<SpreadsheetStep, 'key' | 'builtIn'> & {
+    key?: string;
+};
+/**
+ * The built-in steps. Each knows when it is ready and what blocks it; override any of `label`,
+ * `hint`, `show`, `ready`, `needed`, and `blockers`.
+ */
+export declare const spreadsheetSteps: {
+    columns: (options?: SpreadsheetStepPreset) => SpreadsheetStep;
+    file: (options?: SpreadsheetStepPreset) => SpreadsheetStep;
+    review: (options?: SpreadsheetStepPreset) => SpreadsheetStep;
+    submit: (options?: SpreadsheetStepPreset) => SpreadsheetStep;
+    values: (options?: SpreadsheetStepPreset) => SpreadsheetStep;
+};
+/**
+ * A wizard over an importer: the steps you list, in order, built-in or your own. Steps with
+ * `show: 'when-needed'` are skipped when they have nothing to do.
+ *
+ * @example
+ * ```ts
+ * const steps = useSpreadsheetSteps(importer, [
+ *   { key: 'center', label: 'Centre', ready: () => Boolean(centerId.value) },
+ *   spreadsheetSteps.file(),
+ *   spreadsheetSteps.columns({ show: 'when-needed' }),
+ *   spreadsheetSteps.values({ show: 'when-needed' }),
+ *   spreadsheetSteps.review(),
+ *   spreadsheetSteps.submit(),
+ * ])
+ * ```
+ */
+export declare function useSpreadsheetSteps(importer: SpreadsheetStepContext, steps?: readonly SpreadsheetStep[]): SpreadsheetSteps;
+export {};

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

@@ -0,0 +1,126 @@
+import { computed, shallowRef, watch } from "vue";
+function preset(builtIn, defaults) {
+  return (options = {}) => ({
+    ...defaults,
+    ...options,
+    builtIn,
+    key: options.key ?? builtIn
+  });
+}
+export const spreadsheetSteps = {
+  columns: preset("columns", {
+    blockers: (importer) => importer.columns.missing.length,
+    needed: (importer) => importer.columns.missing.length > 0,
+    ready: (importer) => !importer.columns.missing.length
+  }),
+  file: preset("file", {
+    ready: (importer) => importer.file.loaded && !importer.file.reading && !importer.readiness.loading
+  }),
+  review: preset("review", {
+    ready: (importer) => importer.readiness.importable > 0 && !importer.readiness.loading
+  }),
+  submit: preset("submit", {
+    ready: (importer) => importer.submit.status === "done"
+  }),
+  values: preset("values", {
+    blockers: (importer) => importer.values.open.length,
+    needed: (importer) => importer.values.questions.length > 0,
+    ready: (importer) => !importer.values.open.length
+  })
+};
+export function useSpreadsheetSteps(importer, steps = [
+  spreadsheetSteps.file(),
+  spreadsheetSteps.columns({ show: "when-needed" }),
+  spreadsheetSteps.values({ show: "when-needed" }),
+  spreadsheetSteps.review(),
+  spreadsheetSteps.submit()
+]) {
+  const current = shallowRef(steps[0]?.key ?? "");
+  const visited = shallowRef(/* @__PURE__ */ new Set([current.value]));
+  watch(current, (key) => {
+    if (!visited.value.has(key)) visited.value = /* @__PURE__ */ new Set([...visited.value, key]);
+  });
+  const list = computed(() => {
+    const currentIndex = Math.max(
+      steps.findIndex((step2) => step2.key === current.value),
+      0
+    );
+    return steps.map((step2, index2) => {
+      const skipped = step2.show === "when-needed" && !visited.value.has(step2.key) && !(step2.needed?.(importer) ?? true);
+      return {
+        blockers: step2.blockers?.(importer) ?? 0,
+        builtIn: step2.builtIn ?? null,
+        hint: step2.hint,
+        key: step2.key,
+        label: step2.label,
+        position: index2 + 1,
+        ready: step2.ready?.(importer) ?? true,
+        skipped,
+        state: index2 === currentIndex ? "current" : index2 < currentIndex ? skipped ? "skipped" : "done" : skipped ? "skipped" : "upcoming"
+      };
+    });
+  });
+  const index = computed(
+    () => Math.max(
+      list.value.findIndex((step2) => step2.key === current.value),
+      0
+    )
+  );
+  const step = computed(() => list.value[index.value] ?? null);
+  function move(direction) {
+    for (let next2 = index.value + direction; next2 >= 0 && next2 < list.value.length; next2 += direction) {
+      const candidate = list.value[next2];
+      if (candidate && !candidate.skipped) {
+        current.value = candidate.key;
+        return;
+      }
+    }
+  }
+  function next() {
+    if (step.value?.ready) move(1);
+  }
+  function back() {
+    move(-1);
+  }
+  function goTo(key) {
+    const target = list.value.findIndex((entry) => entry.key === key);
+    if (target >= 0 && target <= index.value) current.value = key;
+  }
+  function reset() {
+    current.value = steps[0]?.key ?? "";
+    visited.value = /* @__PURE__ */ new Set([current.value]);
+  }
+  watch(
+    () => importer.file.loaded,
+    (loaded) => {
+      if (loaded) return;
+      const fileStep = steps.findIndex((entry) => entry.builtIn === "file");
+      if (fileStep >= 0 && index.value > fileStep)
+        current.value = steps[fileStep]?.key ?? current.value;
+    }
+  );
+  return {
+    back,
+    get canBack() {
+      return list.value.slice(0, index.value).some((entry) => !entry.skipped);
+    },
+    get canNext() {
+      return Boolean(step.value?.ready) && index.value < list.value.length - 1;
+    },
+    get current() {
+      return current.value;
+    },
+    goTo,
+    get isLast() {
+      return index.value === list.value.length - 1;
+    },
+    get list() {
+      return list.value;
+    },
+    next,
+    reset,
+    get step() {
+      return step.value;
+    }
+  };
+}

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

@@ -0,0 +1,37 @@
+import type { ComputedRef } from 'vue';
+import type { UiToolsTranslator } from '#ui-tools/i18n';
+import type { SpreadsheetRuntimeSchema, SpreadsheetSubmitParams, SpreadsheetSubmitRejection, SpreadsheetSubmitResult, SpreadsheetSubmitStatus } from '../types/index.js';
+import type { useSpreadsheetContext } from './use-spreadsheet-context.js';
+import type { useSpreadsheetFields } from './use-spreadsheet-fields.js';
+import type { useSpreadsheetRows } from './use-spreadsheet-rows.js';
+import type { useSpreadsheetValues } from './use-spreadsheet-values.js';
+export interface UseSpreadsheetSubmitParams {
+    schema: ComputedRef<SpreadsheetRuntimeSchema>;
+    context: ReturnType<typeof useSpreadsheetContext>;
+    fields: ReturnType<typeof useSpreadsheetFields>;
+    rows: ReturnType<typeof useSpreadsheetRows>;
+    values: ReturnType<typeof useSpreadsheetValues>;
+    onSubmit?: (params: SpreadsheetSubmitParams<unknown, unknown, unknown>) => void | SpreadsheetSubmitResult | Promise<void | SpreadsheetSubmitResult>;
+    batchSize?: number;
+    t: UiToolsTranslator;
+}
+/**
+ * The import itself: creates the new values, builds the payloads with `output`, sends them in
+ * batches, and sends rows the server refused back to review.
+ */
+export declare function useSpreadsheetSubmit(params: UseSpreadsheetSubmitParams): {
+    error: import("vue").ShallowRef<unknown, unknown>;
+    imported: import("vue").ShallowRef<number, number>;
+    progress: import("vue").ShallowRef<{
+        done: number;
+        total: number;
+    }, {
+        done: number;
+        total: number;
+    }>;
+    rejected: import("vue").ShallowRef<readonly SpreadsheetSubmitRejection[], readonly SpreadsheetSubmitRejection[]>;
+    reset: () => void;
+    retryRejected: () => Promise<void>;
+    run: () => Promise<void>;
+    status: import("vue").ShallowRef<SpreadsheetSubmitStatus, SpreadsheetSubmitStatus>;
+};

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

@@ -0,0 +1,136 @@
+import { shallowRef } from "vue";
+import {
+  getSpreadsheetPathValue,
+  normalizeSpreadsheetText,
+  setSpreadsheetPathValue
+} from "../utils/index.js";
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+export function useSpreadsheetSubmit(params) {
+  const status = shallowRef("idle");
+  const progress = shallowRef({ done: 0, total: 0 });
+  const rejected = shallowRef([]);
+  const imported = shallowRef(0);
+  const error = shallowRef(null);
+  let controller = null;
+  async function createValues() {
+    const created = /* @__PURE__ */ new Map();
+    const ctx = params.context.ctx.value;
+    for (const question of params.values.questions.value) {
+      if (question.answer?.action !== "create") continue;
+      const create = params.fields.byPath.value.get(question.field)?.select?.create;
+      if (!create) continue;
+      const key = normalizeSpreadsheetText(question.value);
+      const byKey = created.get(question.field) ?? /* @__PURE__ */ new Map();
+      if (byKey.has(key)) continue;
+      const option = await create.handler({ ctx, label: question.value });
+      const value = typeof option === "object" && option !== null && "value" in option ? option.value : option;
+      byKey.set(key, value);
+      created.set(question.field, byKey);
+    }
+    return created;
+  }
+  function withCreatedValues(data, created) {
+    if (!created.size) return data;
+    const next = cloneRecord(data);
+    for (const [field, byKey] of created) {
+      const replace = (item) => byKey.get(normalizeSpreadsheetText(item)) ?? item;
+      const value = getSpreadsheetPathValue(next, field);
+      setSpreadsheetPathValue(
+        next,
+        field,
+        Array.isArray(value) ? value.map(replace) : replace(value)
+      );
+    }
+    return next;
+  }
+  async function send(only) {
+    if (status.value === "running") return;
+    const selected = params.rows.importable.value.filter((row) => !only || only.has(row.index));
+    status.value = "running";
+    error.value = null;
+    rejected.value = [];
+    imported.value = 0;
+    progress.value = { done: 0, total: selected.length };
+    const current = new AbortController();
+    controller = current;
+    const { signal } = current;
+    const ctx = params.context.ctx.value;
+    const output = params.schema.value.output;
+    try {
+      const created = await createValues();
+      if (signal.aborted) return;
+      const submitRows = [];
+      for (const row of selected) {
+        const mode = row.mode === "update" ? "update" : "create";
+        const data = withCreatedValues(row.data, created);
+        const payload = output ? await output({ ctx, existing: row.existing, mode, row: data }) : data;
+        submitRows.push({ existing: row.existing, index: row.index, mode, payload });
+      }
+      if (signal.aborted) return;
+      const size = params.batchSize && params.batchSize > 0 ? params.batchSize : Math.max(submitRows.length, 1);
+      const batches = [];
+      for (let start = 0; start < submitRows.length; start += size)
+        batches.push(submitRows.slice(start, start + size));
+      const refused = [];
+      let done = 0;
+      for (const [index, batch] of batches.entries()) {
+        const base = done;
+        const result = await params.onSubmit?.({
+          batch: { count: batches.length, index },
+          create: batch.filter((row) => row.mode === "create").map((row) => row.payload),
+          ctx,
+          reportProgress: (count) => {
+            if (signal.aborted) return;
+            progress.value = { done: base + Math.min(count, batch.length), total: selected.length };
+          },
+          rows: batch,
+          signal,
+          update: batch.filter((row) => row.mode === "update").map((row) => row.payload)
+        });
+        if (signal.aborted) return;
+        refused.push(...result?.rejected ?? []);
+        done += batch.length;
+        progress.value = { done, total: selected.length };
+      }
+      rejected.value = refused;
+      imported.value = selected.length - new Set(refused.map((entry) => entry.index)).size;
+      const issues = /* @__PURE__ */ new Map();
+      for (const entry of refused) {
+        const list = issues.get(entry.index) ?? [];
+        list.push({
+          code: "server",
+          field: entry.field ?? null,
+          level: "error",
+          message: entry.message
+        });
+        issues.set(entry.index, list);
+      }
+      params.rows.setRejections(issues);
+      status.value = "done";
+    } catch (nextError) {
+      if (signal.aborted) return;
+      error.value = nextError;
+      status.value = "error";
+    } finally {
+      if (controller === current) controller = null;
+    }
+  }
+  async function retryRejected() {
+    const indexes = new Set(rejected.value.map((entry) => entry.index));
+    if (!indexes.size) return;
+    params.rows.setRejections(/* @__PURE__ */ new Map());
+    status.value = "idle";
+    await send(indexes);
+  }
+  function reset() {
+    controller?.abort();
+    status.value = "idle";
+    progress.value = { done: 0, total: 0 };
+    rejected.value = [];
+    imported.value = 0;
+    error.value = null;
+  }
+  return { error, imported, progress, rejected, reset, retryRejected, run: () => send(), status };
+}