nuxt-ui-tools 1.11.2 → 1.13.0

package/dist/runtime/spreadsheet/utils/suggestions.d.ts

@@ -0,0 +1,20 @@
+import type { UiToolsTranslator } from '#ui-tools/i18n';
+import type { SpreadsheetField, SpreadsheetFieldOptions, SpreadsheetHeaderCell } from '../types/index.js';
+/** Share of sample values that must pass before a column is suggested for a field. */
+export declare const SPREADSHEET_SUGGESTION_PASS_RATE = 0.8;
+/**
+ * For each required field without a column, the first unused column whose sample values all read
+ * as the field's type and pass its rules. A suggestion is offered to the user, never applied.
+ */
+export declare function suggestSpreadsheetColumns(params: {
+    fields: readonly SpreadsheetField[];
+    headers: readonly SpreadsheetHeaderCell[];
+    rows: readonly (readonly string[])[];
+    raws: readonly (readonly unknown[] | undefined)[];
+    options: ReadonlyMap<string, SpreadsheetFieldOptions>;
+    ctx: unknown;
+    t: UiToolsTranslator;
+}): Map<string, {
+    header: SpreadsheetHeaderCell;
+    samples: readonly string[];
+}>;

package/dist/runtime/spreadsheet/utils/suggestions.js

@@ -0,0 +1,43 @@
+import { parseSpreadsheetRow } from "./rows.js";
+export const SPREADSHEET_SUGGESTION_PASS_RATE = 0.8;
+const SAMPLE_SIZE = 30;
+export function suggestSpreadsheetColumns(params) {
+  const suggestions = /* @__PURE__ */ new Map();
+  const taken = /* @__PURE__ */ new Set();
+  for (const field of params.fields) {
+    if (field.select?.rowOptions) continue;
+    const rules = field.staticRules ? field.rulesOf({}) : [];
+    if (field.kind === "text" && !rules.length && !field.parse) continue;
+    for (const header of params.headers) {
+      if (taken.has(header.index) || !header.text) continue;
+      const samples = params.rows.map((row, index) => ({ index, text: String(row[header.index] ?? "").trim() })).filter((entry) => entry.text).slice(0, SAMPLE_SIZE);
+      if (samples.length < 2) continue;
+      const passing = samples.filter((sample) => {
+        const parsed = parseSpreadsheetRow({
+          cells: params.rows[sample.index] ?? [],
+          context: {
+            answers: {},
+            columns: /* @__PURE__ */ new Map([[field.path, header.index]]),
+            ctx: params.ctx,
+            fields: [{ ...field, required: false, rulesOf: () => rules }],
+            headers: [],
+            optionsOf: () => ({ options: params.options.get(field.path), scope: null }),
+            t: params.t
+          },
+          edits: void 0,
+          index: sample.index,
+          raws: params.raws[sample.index]
+        });
+        return !parsed.issues.some((issue) => issue.level === "error") && !parsed.unmatched.length;
+      });
+      if (passing.length / samples.length < SPREADSHEET_SUGGESTION_PASS_RATE) continue;
+      suggestions.set(field.path, {
+        header,
+        samples: [...new Set(samples.map((sample) => sample.text))].slice(0, 3)
+      });
+      taken.add(header.index);
+      break;
+    }
+  }
+  return suggestions;
+}

package/dist/runtime/spreadsheet/utils/text.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Text used for exact matching: no case, no accents, one space between words, and no trailing
+ * `*` or `(required)` marker. Two values match when their normalized texts are equal.
+ */
+export declare function normalizeSpreadsheetText(value: unknown): string;
+/** Cell text as displayed: trimmed, empty for `null` and `undefined`. */
+export declare function toSpreadsheetText(value: unknown): string;
+/** Splits a cell into its items, trimmed, without empty ones. */
+export declare function splitSpreadsheetItems(text: string, separator: string): string[];

package/dist/runtime/spreadsheet/utils/text.js

@@ -0,0 +1,11 @@
+export function normalizeSpreadsheetText(value) {
+  return String(value ?? "").normalize("NFD").replaceAll(/[̀-ͯ]/gu, "").replaceAll(/\s*\*\s*$/gu, "").replaceAll(/\s*\(required\)\s*$/giu, "").replaceAll(/\s+/gu, " ").trim().toLowerCase();
+}
+export function toSpreadsheetText(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? "" : value.toISOString();
+  return String(value).trim();
+}
+export function splitSpreadsheetItems(text, separator) {
+  return text.split(separator).map((item) => item.trim()).filter(Boolean);
+}

package/dist/runtime/spreadsheet/utils/workbook.d.ts

@@ -0,0 +1,13 @@
+import type { SpreadsheetFileSource, SpreadsheetWorkbook } from '../types/index.js';
+/** Splits delimited text (CSV, TSV, or rows pasted from a spreadsheet) into rows of cells. */
+export declare function parseSpreadsheetDelimitedText(text: string, separator?: string): string[][];
+/** Reads an Excel or CSV file. CSV files may use commas, semicolons, or tabs, in UTF-8 or Windows-1252. */
+export declare function readSpreadsheetFile(params: {
+    source: SpreadsheetFileSource;
+    name: string;
+}): Promise<SpreadsheetWorkbook>;
+/** Reads text pasted from a spreadsheet, or the content of a CSV file. */
+export declare function readSpreadsheetText(params: {
+    text: string;
+    name: string;
+}): SpreadsheetWorkbook;

package/dist/runtime/spreadsheet/utils/workbook.js

@@ -0,0 +1,121 @@
+import { read, utils } from "xlsx";
+const TEXT_EXTENSIONS = /\.(?:csv|tsv|txt)$/iu;
+async function toBytes(source) {
+  if (source instanceof Uint8Array) return source;
+  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  return new Uint8Array(await source.arrayBuffer());
+}
+function decodeText(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes).replace(/^/u, "");
+  } catch {
+    return new TextDecoder("windows-1252").decode(bytes);
+  }
+}
+function detectSeparator(text) {
+  const firstLine = text.slice(0, text.search(/\r?\n/u) + 1 || text.length);
+  const counts = ["	", ";", ","].map((separator) => ({
+    count: firstLine.split(separator).length - 1,
+    separator
+  }));
+  return counts.reduce((best, entry) => entry.count > best.count ? entry : best).separator;
+}
+export function parseSpreadsheetDelimitedText(text, separator = detectSeparator(text)) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quoted) {
+      if (char === '"' && text[index + 1] === '"') {
+        cell += '"';
+        index += 1;
+      } else if (char === '"') quoted = false;
+      else cell += char;
+    } else if (char === '"' && cell === "") quoted = true;
+    else if (char === separator) {
+      row.push(cell);
+      cell = "";
+    } else if (char === "\n" || char === "\r") {
+      if (char === "\r" && text[index + 1] === "\n") index += 1;
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else cell += char;
+  }
+  if (cell !== "" || row.length) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows;
+}
+function toSheet(name, cells, raws) {
+  const rows = [];
+  const keptRaws = [];
+  const rowNumbers = [];
+  for (const [index, row] of cells.entries()) {
+    const texts = row.map((value) => value.trim());
+    if (!texts.some(Boolean)) continue;
+    rows.push(texts);
+    keptRaws.push(raws?.[index]);
+    rowNumbers.push(index + 1);
+  }
+  return { name, raws: keptRaws, rowNumbers, rows };
+}
+function cellText(cell) {
+  if (!cell || cell.v === void 0 || cell.v === null) return "";
+  return cell.w ?? String(cell.v);
+}
+function cellRaw(cell) {
+  if (!cell) return void 0;
+  if (cell.t === "n" || cell.t === "b" || cell.t === "d") return cell.v;
+  return void 0;
+}
+function readSheet(name, sheet) {
+  const reference = sheet?.["!ref"];
+  if (!sheet || !reference) return { name, raws: [], rowNumbers: [], rows: [] };
+  const range = utils.decode_range(reference);
+  const cells = [];
+  const raws = [];
+  for (let rowIndex = 0; rowIndex <= range.e.r; rowIndex += 1) {
+    const texts = [];
+    let typed;
+    for (let columnIndex = 0; columnIndex <= range.e.c; columnIndex += 1) {
+      const cell = sheet[utils.encode_cell({ c: columnIndex, r: rowIndex })];
+      texts.push(cellText(cell));
+      const raw = cellRaw(cell);
+      if (raw !== void 0) {
+        typed ??= [];
+        typed[columnIndex] = raw;
+      }
+    }
+    cells.push(texts);
+    raws.push(typed);
+  }
+  return toSheet(name, cells, raws);
+}
+export async function readSpreadsheetFile(params) {
+  const bytes = await toBytes(params.source);
+  if (TEXT_EXTENSIONS.test(params.name))
+    return readSpreadsheetText({ name: params.name, text: decodeText(bytes) });
+  const workbook = read(bytes, { cellDates: true, type: "array" });
+  return {
+    name: params.name,
+    sheets: workbook.SheetNames.map(
+      (sheetName) => readSheet(sheetName, workbook.Sheets[sheetName])
+    )
+  };
+}
+export function readSpreadsheetText(params) {
+  return {
+    name: params.name,
+    sheets: [
+      toSheet(
+        params.name.replace(/\.[^.]+$/u, "") || "Sheet 1",
+        parseSpreadsheetDelimitedText(params.text)
+      )
+    ]
+  };
+}

package/dist/runtime/table/components/filters/tags/boolean-filter-tag.d.vue.ts

@@ -27,12 +27,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/boolean-filter-tag.vue.d.ts

@@ -27,12 +27,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/date-filter-tag.d.vue.ts

@@ -29,12 +29,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/date-filter-tag.vue.d.ts

@@ -29,12 +29,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/number-filter-tag.d.vue.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/number-filter-tag.vue.d.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/option-filter-tag.d.vue.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/option-filter-tag.vue.d.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/text-filter-tag.d.vue.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/filters/tags/text-filter-tag.vue.d.ts

@@ -28,12 +28,12 @@ type __VLS_Slots = {} & {
     trigger?: (props: typeof __VLS_10) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    dismiss: () => any;
     back: () => any;
+    dismiss: () => any;
     sessionClosed: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onDismiss?: (() => any) | undefined;
     onBack?: (() => any) | undefined;
+    onDismiss?: (() => any) | undefined;
     onSessionClosed?: (() => any) | undefined;
 }>, {
     header: boolean;

package/dist/runtime/table/components/table/table-cell-ellipsis.d.ts

@@ -26,8 +26,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: StringConstructor;
     };
 }>> & Readonly<{}>, {
-    disabled: boolean;
     title: string;
+    disabled: boolean;
     wrapperClass: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/runtime/table/composables/use-table-actions.d.ts

@@ -21,7 +21,7 @@ export declare function useTableActions(options: UseTableActionsParams): {
     actions: ComputedRef<TableActionController[]>;
     bulkActions: ComputedRef<TableActionController[]>;
     definitions: ComputedRef<TableActionDefinition[]>;
-    execute: (definition: TableActionDefinition) => Promise<void>;
+    execute: (definition: TableActionDefinition) => Promise<boolean>;
     runningKeys: import("vue").Ref<string[], string[]>;
     toolbarActions: ComputedRef<TableActionController[]>;
 };

package/dist/runtime/table/composables/use-table-actions.js

@@ -1,4 +1,5 @@
 import { computed, ref } from "vue";
+import { isRecord } from "../../shared/utils/path.js";
 import { isFunction } from "../../shared/utils/predicate.js";
 import { resolveTableActionDefinitions } from "../utils/actions.js";
 export function useTableActions(options) {
@@ -46,10 +47,10 @@ export function useTableActions(options) {
   async function execute(definition) {
     const state = resolveState(definition);
     if (!state.visible || state.disabled || state.loading || state.running) {
-      return;
+      return false;
     }
     if (!definition.action) {
-      return;
+      return false;
     }
     const actionContext = context.value;
     runningKeys.value = [...runningKeys.value, definition.key];
@@ -58,10 +59,14 @@ export function useTableActions(options) {
       selectionApi.clear();
     }
     try {
-      await definition.action(actionContext);
+      const result = await definition.action(actionContext);
+      if (isFailedActionResult(result)) {
+        return false;
+      }
       if (selectionClear === "success") {
         selectionApi.clear();
       }
+      return true;
     } finally {
       runningKeys.value = runningKeys.value.filter((key) => key !== definition.key);
     }
@@ -111,6 +116,9 @@ function resolveFlag(value, context) {
 function isBooleanResolver(value) {
   return isFunction(value);
 }
+function isFailedActionResult(result) {
+  return result === false || isRecord(result) && result.success === false;
+}
 function toPlainRecord(value) {
   return Object.fromEntries(Object.entries(value));
 }

package/dist/runtime/table/composables/use-table-internals.d.ts

@@ -22,7 +22,7 @@ declare function createTableInternals<TSchema>(options: {
             [x: string]: unknown;
         }, {
             [x: string]: unknown;
-        }>) => Promise<void>;
+        }>) => Promise<boolean>;
         runningKeys: import("vue").Ref<string[], string[]>;
         toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
     };
@@ -618,7 +618,7 @@ declare function useProvideTableInternals<TSchema>(options: {
             [x: string]: unknown;
         }, {
             [x: string]: unknown;
-        }>) => Promise<void>;
+        }>) => Promise<boolean>;
         runningKeys: import("vue").Ref<string[], string[]>;
         toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
     };
@@ -1211,7 +1211,7 @@ declare function useTableInternals(): {
             [x: string]: unknown;
         }, {
             [x: string]: unknown;
-        }>) => Promise<void>;
+        }>) => Promise<boolean>;
         runningKeys: import("vue").Ref<string[], string[]>;
         toolbarActions: import("vue").ComputedRef<import("./use-table-actions.js").TableActionController[]>;
     };

package/dist/runtime/table/types/actions.d.ts

@@ -18,10 +18,16 @@ export interface TableToolbarAction<TRow extends GenericObject = GenericObject,
     condition?: boolean | ((context: TContext) => boolean);
     disabled?: boolean | ((context: TableActionContext<TRow, TContext, TPageContext>) => boolean);
     loading?: boolean | ((context: TableActionContext<TRow, TContext, TPageContext>) => boolean);
+    /**
+     * Runs the action. Returning `false` or `{ success: false }` marks the run as failed without
+     * throwing, like a form submit handler: the selection is kept and `execute()` resolves `false`.
+     * A rejection also keeps the selection and propagates to the caller.
+     */
     action?: (context: TableActionContext<TRow, TContext, TPageContext>) => MaybePromise<unknown>;
 }
 export interface TableBulkAction<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableToolbarAction<TRow, TContext, TPageContext> {
     requiresSelection?: boolean;
+    /** When the selection clears: before the action runs, after it succeeds, or never. */
     selectionClear?: 'trigger' | 'success' | 'never';
 }
 /** Runtime state exposed for a configured toolbar or bulk action. */
@@ -42,7 +48,8 @@ export interface TableActionSlotProps<TRow extends GenericObject = GenericObject
     state: TableActionState;
     running: boolean;
     selection: TableApi['selection'];
-    execute: () => Promise<void>;
+    /** Runs the action and resolves `true` when it ran and succeeded. */
+    execute: () => Promise<boolean>;
 }
 export interface TableRowActionContext<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject, TPageContext extends GenericObject = GenericObject> extends TableRowRenderParams<TRow, TContext, TPageContext> {
     layout: TableLayout;

package/dist/runtime/table/utils/data-list-ui.d.ts

@@ -122,6 +122,6 @@ export declare function resolveDataListTableDensity(density: DataListDensity): {
 export declare function resolveDataListContentShellClass(options: {
     layout: 'table' | 'grid';
     surface: DataListContentSurface;
-}): "overflow-hidden" | "grid gap-5 overflow-hidden rounded-md border border-default bg-default" | "grid gap-5" | "overflow-hidden rounded-md border border-default bg-default";
+}): "grid gap-5" | "overflow-hidden" | "grid gap-5 overflow-hidden rounded-md border border-default bg-default" | "overflow-hidden rounded-md border border-default bg-default";
 /** Merges application and root DataList defaults without losing nested UI slots. */
 export declare function mergeDataListUiConfig(appUi: DataListUiConfig | undefined, componentUi: DataListUiConfig | undefined, density?: DataListDensity, size?: DataListControlSize): DataListUiConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-ui-tools",
-  "version": "1.11.2",
+  "version": "1.13.0",
   "description": "Nuxt module and runtime toolkit for UI-heavy Nuxt applications",
   "homepage": "https://github.com/ChronicStone/nuxt-ui-tools#readme",
   "bugs": "https://github.com/ChronicStone/nuxt-ui-tools/issues",
@@ -43,6 +43,9 @@
       ],
       "table": [
         "./dist/runtime/table/index.d.ts"
+      ],
+      "spreadsheet": [
+        "./dist/runtime/spreadsheet/index.d.ts"
       ]
     }
   },
@@ -110,6 +113,14 @@
     "#ui-tools/table/*": {
       "types": "./dist/runtime/table/*.d.ts",
       "default": "./dist/runtime/table/*.js"
+    },
+    "#ui-tools/spreadsheet": {
+      "types": "./dist/runtime/spreadsheet/index.d.ts",
+      "default": "./dist/runtime/spreadsheet/index.js"
+    },
+    "#ui-tools/spreadsheet/*": {
+      "types": "./dist/runtime/spreadsheet/*.d.ts",
+      "default": "./dist/runtime/spreadsheet/*.js"
     }
   },
   "exports": {
@@ -148,6 +159,10 @@
     "./table": {
       "types": "./dist/runtime/table/index.d.ts",
       "import": "./dist/runtime/table/index.js"
+    },
+    "./spreadsheet": {
+      "types": "./dist/runtime/spreadsheet/index.d.ts",
+      "import": "./dist/runtime/spreadsheet/index.js"
     }
   },
   "publishConfig": {
@@ -217,7 +232,7 @@
     "vitest": "5.0.2",
     "vue-draggable-plus": "0.6.1",
     "vue-tsc": "3.3.11",
-    "xlsx": "0.18.5"
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "peerDependencies": {
     "@internationalized/date": ">=3.12.0",
@@ -234,7 +249,7 @@
     "vue": ">=3.5.41",
     "vue-draggable-plus": ">=0.6.1",
     "vue-router": ">=4.6.4",
-    "xlsx": ">=0.18.5"
+    "xlsx": ">=0.20.2"
   },
   "peerDependenciesMeta": {
     "@unovis/ts": {

package/dist/runtime/spreadsheet/components/layout/spreadsheet-import-file-bar.vue

@@ -1,31 +0,0 @@
-<script setup>
-import UIcon from "@nuxt/ui/components/Icon.vue";
-defineProps({
-  fileName: { type: String, required: false },
-  totalSheets: { type: Number, required: true },
-  rowCount: { type: Number, required: true },
-  hasWorkbook: { type: Boolean, required: true }
-});
-</script>
-
-<template>
-  <div
-    class="flex min-h-10 flex-wrap items-center gap-3 border border-default/70 bg-default px-4 py-2.5"
-  >
-    <template v-if="hasWorkbook">
-      <UIcon name="i-lucide-file-spreadsheet" class="size-4 text-success" />
-      <span class="font-mono text-xs font-medium text-highlighted">
-        {{ fileName ?? "Untitled workbook" }}
-      </span>
-      <div class="h-4 w-px bg-default/70" />
-      <span class="font-mono text-[11px] text-muted">
-        {{ totalSheets }} sheets · {{ rowCount }} rows
-      </span>
-    </template>
-
-    <template v-else>
-      <UIcon name="i-lucide-file-spreadsheet" class="size-[18px] text-muted" />
-      <span class="font-mono text-[11px] text-muted"> No file loaded </span>
-    </template>
-  </div>
-</template>

package/dist/runtime/spreadsheet/components/layout/spreadsheet-import-footer.d.vue.ts

@@ -1,24 +0,0 @@
-type __VLS_Props = {
-    hint?: string;
-    showPrevious?: boolean;
-    previousLabel?: string;
-    primaryLabel: string;
-    primaryDisabled?: boolean;
-    primaryLoading?: boolean;
-    showExport?: boolean;
-    exportLabel?: string;
-    metaText?: string;
-    primaryColor?: 'primary' | 'success';
-    primaryIcon?: string;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    previous: () => any;
-    primary: () => any;
-    export: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onPrevious?: (() => any) | undefined;
-    onPrimary?: (() => any) | undefined;
-    onExport?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;