runeforge 0.0.52 → 0.0.54

package/README.md

@@ -46,6 +46,7 @@ A SvelteKit toolkit that forges forms, tables, actions, and CRUD workflows from
       - [Custom row actions](#custom-row-actions)
       - [Custom bulk actions](#custom-bulk-actions)
       - [Exporting data (CSV/XLSX)](#exporting-data-csvxlsx)
+      - [Reordering rows](#reordering-rows)
       - [Server-side pagination, sorting & filtering](#server-side-pagination-sorting--filtering)
     - [PaginatedTable](#paginatedtable)
     - [Form Components](#form-components)
@@ -86,6 +87,7 @@ Runeforge provides a set of composable, metadata-driven components for building
 - Tailwind CSS 4
 - DaisyUI 5
 - Cally
+- `sortablejs` (optional, only if you enable [drag-to-reorder](#reordering-rows))
 - `xlsx` (optional, only if you enable Excel export)
 
 ---
@@ -102,6 +104,7 @@ Runeforge provides a set of composable, metadata-driven components for building
 - **Embedded fields** — model one-to-many sub-documents (e.g. line items, adjustments) as an in-form add/edit list backed by a single JSON field.
 - **Custom row & bulk actions** — add entity-specific actions (in a panel or via redirect) alongside the built-in view/edit/delete, and bulk actions that operate on the current selection.
 - **CSV/XLSX export** — one-click export of the current table view, with optional Excel support via the `xlsx` package.
+- **Drag-to-reorder** — an opt-in row-reordering layer that persists a sequential order attribute after each drag.
 - **Server-side pagination, sorting & filtering** — point `GenericCRUD`/`PaginatedTable` at a paginated envelope and it drives page/sort/filter state through the URL for you.
 - **Pluggable icon system** — swap the default icon set or use the included Bootstrap Icons alternative via `setIconSet`.
 - **Standalone components** — table, form, and navigation components can be used independently without the full CRUD orchestrator.
@@ -697,19 +700,22 @@ Key props:
 - `columns` — `ColumnDefinition[]` for the table view
 - `fields` — `FieldDefinition[]` for form views
 - `creation`, `update`, `read`, `deletion` — `ActionConfiguration` objects that define handlers and permissions for each operation. Set `confirm: true` on `deletion` to show a confirmation dialog before any delete (single row or batch)
-- `actions` — `CustomAction[]`, extra per-row actions — see [Custom row actions](#custom-row-actions)
-- `customBulkActions` — `CustomBulkAction[]`, extra actions on the current selection — see [Custom bulk actions](#custom-bulk-actions)
-- `search` — `SearchConfiguration`, shows a free-text search box — see [Free-text search](#free-text-search)
-- `enableExport`, `onExport`, `xlsx` — CSV/Excel export — see [Exporting data](#exporting-data-csvxlsx)
+- `actions` — a `ListActions` object grouping the list view's extra actions:
+  - `actions.custom` — `CustomAction[]`, extra per-row actions — see [Custom row actions](#custom-row-actions)
+  - `actions.bulk` — `CustomBulkAction[]`, extra actions on the current selection — see [Custom bulk actions](#custom-bulk-actions)
+- `config` — a `ListConfig` object grouping the list view's opt-in behaviors:
+  - `config.search` — `SearchConfiguration`, shows a free-text search box — see [Free-text search](#free-text-search)
+  - `config.export` — `ExportConfiguration`, enables CSV/Excel export — see [Exporting data](#exporting-data-csvxlsx)
+  - `config.reorder` — `ReorderConfiguration`, enables drag-to-reorder rows — see [Reordering rows](#reordering-rows)
 
 #### Free-text search
 
-Passing `search` renders a debounced search box in the header. Typing updates a URL search param (`?search=...` by default), resets pagination and any open create/read/edit view, and leaves interpreting the term entirely to your `load` function — it's the same mechanism server-side pagination uses, so it composes naturally with it.
+Passing `config.search` renders a debounced search box in the header. Typing updates a URL search param (`?search=...` by default), resets pagination and any open create/read/edit view, and leaves interpreting the term entirely to your `load` function — it's the same mechanism server-side pagination uses, so it composes naturally with it.
 
 ```ts
 <GenericCRUD
   ...
-  search={{ param: 'q', placeholder: 'Search tasks...', debounceMs: 300 }}
+  config={{ search: { param: 'q', placeholder: 'Search tasks...', debounceMs: 300 } }}
 />
 ```
 
@@ -721,7 +727,7 @@ Passing `search` renders a debounced search box in the header. Typing updates a
 
 #### Custom row actions
 
-`actions` adds entries to the per-row action menu, alongside the built-in view/edit/delete. Each `CustomAction` resolves in one of two ways — provide exactly one of `view` or `href`:
+`actions.custom` adds entries to the per-row action menu, alongside the built-in view/edit/delete. Each `CustomAction` resolves in one of two ways — provide exactly one of `view` or `href`:
 
 - `href(item)` — plain navigation, e.g. deep-linking into another CRUD's filtered list.
 - `view` — a Svelte component of your own that `GenericCRUD` mounts directly (no wrapper) when the action runs. Since you own the whole component, you decide how it presents itself — typically as a modal built on the exported `Modal` component, sized however that action needs via `Modal`'s `class`/`width`/`maxWidth`/`height`/`maxHeight` props (see [Shared Components](#shared-components)).
@@ -746,13 +752,13 @@ const actions: CustomAction<IWidget>[] = [
 ];
 ```
 
-```svelte
-<GenericCRUD ... {actions} />
+```ts
+<GenericCRUD ... actions={{ custom: actions }} />
 ```
 
 A `view` component receives `instance`, `label`, `endpoint`, `serverError`, `onCancel`, and `onSuccess` — the same shape Create/Update use internally — so it can reuse `enhance`-based form submission while rendering as a parametrized modal:
 
-```svelte
+```ts
 <!-- ArchiveForm.svelte -->
 <script lang="ts">
   import { enhance } from '$app/forms';
@@ -782,15 +788,17 @@ A `view` component receives `instance`, `label`, `endpoint`, `serverError`, `onC
 
 #### Custom bulk actions
 
-`customBulkActions` adds buttons next to the built-in Delete button in the header, operating on the current row selection. Each one is disabled until at least one row is selected, and (like deletion) can require confirmation.
+`actions.bulk` adds buttons next to the built-in Delete button in the header, operating on the current row selection. Each one is disabled until at least one row is selected, and (like deletion) can require confirmation.
 
 ```ts
 <GenericCRUD
   ...
-  customBulkActions={[
-    { label: 'Complete', icon: CheckIcon, endpoint: '?/complete' },
-    { label: 'Mark pending', icon: UndoIcon, endpoint: '?/incomplete', variant: 'error', confirm: true },
-  ]}
+  actions={{
+    bulk: [
+      { kind: 'endpoint', label: 'Complete', icon: CheckIcon, endpoint: '?/complete' },
+      { kind: 'endpoint', label: 'Mark pending', icon: UndoIcon, endpoint: '?/incomplete', variant: 'error', confirm: true },
+    ],
+  }}
 />
 ```
 
@@ -798,7 +806,7 @@ A `view` component receives `instance`, `label`, `endpoint`, `serverError`, `onC
 
 #### Exporting data (CSV/XLSX)
 
-`enableExport` adds an export button to the header offering CSV (always) and Excel (when an `xlsx` module is supplied). Runeforge never bundles `xlsx` itself — install it separately and pass the resolved module in, so the dependency stays fully optional:
+`config.export` adds an export button to the header offering CSV (always) and Excel (when a `xlsx` module is supplied). Its mere presence enables the button — pass `{}` for CSV-only export. Runeforge never bundles `xlsx` itself — install it separately and pass the resolved module in, so the dependency stays fully optional:
 
 ```bash
 pnpm add xlsx
@@ -810,25 +818,116 @@ pnpm add xlsx
   import * as xlsx from 'xlsx';
 </script>
 
-<GenericCRUD ... enableExport {xlsx} />
+<GenericCRUD ... config={{ export: { xlsx } }} />
 ```
 
-In client-pagination mode, export includes every row currently matching the table's filters (not just the visible page). In [server-pagination mode](#server-side-pagination-sorting--filtering), pass `onExport` to fetch the full, unpaginated result set for the current query — without it, export falls back to just the currently loaded page:
+In client-pagination mode, export includes every row currently matching the table's filters (not just the visible page). In [server-pagination mode](#server-side-pagination-sorting--filtering), pass `config.export.callback` to fetch the full, unpaginated result set for the current query — without it, export falls back to just the currently loaded page:
 
 ```ts
 <GenericCRUD
   ...
-  enableExport
-  onExport={async (query) => {
-    const params = new URLSearchParams();
-    if (query.ordering) params.set('ordering', query.ordering);
-    // ...translate query.filters into your API's params
-    const res = await fetch(`/api/widgets/export?${params}`);
-    return res.json();
+  config={{
+    export: {
+      callback: async (query) => {
+        const params = new URLSearchParams();
+        if (query.ordering) params.set('ordering', query.ordering);
+        // ...translate query.filters into your API's params
+        const res = await fetch(`/api/widgets/export?${params}`);
+        return res.json();
+      },
+    },
   }}
 />
 ```
 
+#### Reordering rows
+
+`config.reorder` turns on drag-to-reorder: each row gets a drag handle (⋮⋮ by default — pass `icon` for something else, e.g. a hamburger or a grab-hand icon) with a thicker left border, and dragging a row persists a new sequential value for whichever attribute you point it at. Off by default; only appears once `config.reorder` is set.
+
+Runeforge never imports `sortablejs` itself — install it separately and pass the resolved default export in via `sortable`, the same way `xlsx` works for export, so the dependency stays fully optional:
+
+```bash
+pnpm add sortablejs
+```
+
+```ts
+<script>
+  import { GenericCRUD } from 'runeforge';
+  import Sortable from 'sortablejs';
+</script>
+
+<GenericCRUD
+  ...
+  config={{
+    reorder: { attribute: 'order', sortable: Sortable, endpoint: '?/reorder' },
+  }}
+/>
+```
+
+```ts
+// +page.server.ts
+export const actions: Actions = {
+  reorder: async ({ request }) => {
+    const data = await request.formData();
+    const id = String(data.get('id') ?? '');
+    const order = Number(data.get('order') ?? 0);
+    await setWidgetOrder(id, order);
+    return { success: true };
+  },
+};
+```
+
+`endpoint` is `POST`ed once per row whose `attribute` value actually changed (FormData: `id` plus the attribute, e.g. `order`) after a drag, then the list refreshes — the same convention `deletion`/bulk actions use. Pass `callback` instead to handle the changed rows yourself (each one already carries its new attribute value):
+
+```ts
+config={{
+  reorder: {
+    attribute: 'order',
+    sortable: Sortable,
+    callback: async (items) => {
+      await Promise.all(items.map((item) => api.updateWidget(item._id, { order: item.order })));
+    },
+  },
+}}
+```
+
+A few things worth knowing about how reorder mode behaves:
+
+- **The list is ordered by `attribute` ascending (or `compare`, see below) the whole time reorder is active** — not by `_id`, not by whatever order the backend/array happens to return, and not by clicking a column header either: column-header sorting is unavailable while `config.reorder` is set, since row order needs a single, unambiguous source of truth for dragging to mean anything. This holds even if `attribute` is `excludedFromList` and has no column of its own — ordering reads the raw row value regardless of what's rendered. Per-column filters are unavailable for the same reason (a filtered-out row's position would become undefined).
+- **Pagination stays on.** To move a row across a page boundary, drag it to the narrow zone at either edge of the table and hold — after `pageFlipThresholdMs` (default `2000`) it flips to the previous/next page; keep hovering (without letting go) to flip again. Drop once you're on the right page.
+- It's **not supported in [server-pagination mode](#server-side-pagination-sorting--filtering)** (a `PaginatedEnvelope` `data`) — cross-page drag positions aren't meaningful without a lot more server-side machinery, so `config.reorder` is ignored whenever server pagination is active.
+- Set `enabled: false` to keep the configuration in place (attribute, endpoint, icon) but temporarily turn dragging off, without having to remove the whole object.
+
+**Composite orders.** Sometimes the attribute that stores a row's position isn't unique on its own — e.g. an indicator's `order` only makes sense *within* its parent chapter, so two indicators in different chapters can share the same `order` value, and the true display order is really (chapter's order, indicator's own order). Pass `compare` to take full control of that ordering instead of the plain `attribute`-ascending default:
+
+```ts
+config={{
+  reorder: {
+    attribute: 'order',
+    sortable: Sortable,
+    compare: (a, b) => a.chapter.order - b.chapter.order || a.order - b.order,
+    endpoint: '?/reorder',
+  },
+}}
+```
+
+`attribute` is still what gets written back after a drag (as a plain sequential 0-based index across the whole reordered list) — `compare` only decides how rows are displayed and dragged. If a naive global renumbering doesn't fit your data model (as in the chapter example — you don't want every indicator in every chapter renumbered whenever one indicator moves within its own chapter), use `callback` instead of `endpoint` and remap the incoming rows' indices to whatever scoped scheme your backend actually expects before saving.
+
+**Multi-select drag.** Set `multiDrag: true` to let dragging one row of the current checkbox selection carry the whole selection along with it, via SortableJS's `MultiDrag` plugin — mount it on the module you pass in:
+
+```ts
+import Sortable, { MultiDrag } from 'sortablejs';
+Sortable.mount(new MultiDrag());
+```
+
+```ts
+config={{
+  reorder: { attribute: 'order', sortable: Sortable, multiDrag: true, endpoint: '?/reorder' },
+}}
+```
+
+The existing row-selection checkboxes *are* the multi-drag selection — there's no separate ctrl/cmd-click UI to learn. Note that `multiDrag` uses native HTML5 drag-and-drop rather than the mouse-simulated dragging the rest of reorder mode uses (SortableJS's `MultiDrag` plugin needs it to track a multi-row drag correctly) — runeforge switches automatically, but it's worth knowing if you're scripting drags for tests.
+
 #### Server-side pagination, sorting & filtering
 
 By default, `GenericCRUD` and `PaginatedTable` paginate, sort, and filter the full `data` array in the browser. For large datasets, return a `PaginatedEnvelope<T>` from your `load` function instead — `{ results, count, page, pageSize }` — and Runeforge switches to server mode automatically: it drives `page`, `ordering`, and per-column filter values through the URL, and expects your `load` function to read them back.
@@ -862,7 +961,7 @@ export const load: PageServerLoad = ({ url }) => {
 />
 ```
 
-No other prop changes are needed — column sorting/filtering UI, the paginator, and (with `onExport`) export all keep working the same way, just backed by the server instead of the in-memory array. Boolean-column filters send comma-separated values (`?active=true,false`); date-range filters send `<attribute>_from`/`<attribute>_to`.
+No other prop changes are needed — column sorting/filtering UI, the paginator, and (with `config.export.callback`) export all keep working the same way, just backed by the server instead of the in-memory array. Boolean-column filters send comma-separated values (`?active=true,false`); date-range filters send `<attribute>_from`/`<attribute>_to`.
 
 ### PaginatedTable
 
@@ -878,6 +977,8 @@ A standalone table component with built-in sort, filter, and pagination — the
 
 Sort and filter state can be managed externally via the exported `SortState` and `FilterState` classes. Pass a `pagination` prop (`ServerPagination`) plus `onPaginationChange` to opt into the same [server-driven mode](#server-side-pagination-sorting--filtering) `GenericCRUD` uses. `bind:visibleRows` and `bind:query` expose the currently filtered/sorted rows and query snapshot, useful for building your own export UI on top of the raw table.
 
+Pass a `reorder` prop (`{ attribute, sortable, compare?, icon?, multiDrag?, pageFlipThresholdMs? }` — same shape as `GenericCRUD`'s [`config.reorder`](#reordering-rows), minus `endpoint`/`callback`) plus `onReorder` to get the same drag-to-reorder behavior without the CRUD-level persistence wiring — `onReorder` fires with the complete reordered row list after each drag, and it's on you to decide what to do with it. Ignored whenever `pagination` is also set.
+
 ### Form Components
 
 Individual form primitives styled with DaisyUI:
@@ -1118,6 +1219,7 @@ All UI strings default to **Spanish** (Argentina). To switch to another language
 | `delete` | `string` | `Eliminar` |
 | `create` | `string` | `Crear` |
 | `searchPlaceholder` | `string` | `Buscar...` |
+| `reorder` | `string` | `Arrastrar para reordenar` |
 | `export` | `string` | `Exportar` |
 | `exportCsv` | `string` | `Exportar a CSV` |
 | `exportExcel` | `string` | `Exportar a Excel` |

package/dist/components/crud/GenericCRUD.svelte

@@ -1,27 +1,27 @@
 <script lang="ts" generics="T extends object = Record<string, unknown>">
 	import { page } from '$app/state';
 	import { goto } from '$app/navigation';
-	import List from './views/List.svelte';
+	import List from './views/list/List.svelte';
 	import Read from './views/Read.svelte';
 	import Create from './views/Create.svelte';
 	import Update from './views/Update.svelte';
 	import { AUTO_EXCLUDED } from './utils/constants.js';
 	import {
 		resolveFormatter,
+		truncateFormatter,
 		inferType,
 		buildFieldDefinitions
 	} from './utils/resolution.js';
 	import { defaultItemLabel } from './utils/embedded.js';
 	import { isFilterable } from '../table/utils.js';
-	import type { XlsxModule } from '../table/export.js';
 	import type { AttributeMetadata } from '../../types/attribute.js';
 	import type {
 		ActionConfiguration,
 		ColumnDefinition,
 		CustomAction,
-		CustomBulkAction,
 		FieldDefinition,
-		SearchConfiguration,
+		ListActions,
+		ListConfig,
 		ViewBasedCustomBulkAction
 	} from '../../types/crud.js';
 	import type {
@@ -44,16 +44,12 @@
 		update = {} as ActionConfiguration<T>,
 		read = {} as ActionConfiguration<T>,
 		deletion = {} as ActionConfiguration<T>,
-		actions = [] as CustomAction<T>[],
-		customBulkActions = [] as CustomBulkAction<T>[],
-		search = undefined as SearchConfiguration | undefined,
+		actions = {} as ListActions<T>,
+		config = {} as ListConfig<T>,
 		columns = undefined as ColumnDefinition<T>[] | undefined,
 		fields = undefined as FieldDefinition<T>[] | undefined,
 		meta = undefined as Partial<Record<string, AttributeMetadata>> | undefined,
-		form = null as { error?: string } | null,
-		enableExport = false,
-		onExport = undefined as ((query: TableQuery) => Promise<T[]>) | undefined,
-		xlsx = undefined as XlsxModule | undefined
+		form = null as { error?: string } | null
 	}: {
 		data?: Record<string, unknown>;
 		dataKey?: string;
@@ -67,16 +63,15 @@
 		update?: ActionConfiguration<T>;
 		read?: ActionConfiguration<T>;
 		deletion?: ActionConfiguration<T>;
-		actions?: CustomAction<T>[];
-		customBulkActions?: CustomBulkAction<T>[];
-		search?: SearchConfiguration;
+		/** Extra per-row (`custom`) and per-selection (`bulk`) actions. */
+		actions?: ListActions<T>;
+		/** Opt-in list behaviors: free-text search, CSV/Excel export, and
+		 * drag-to-reorder. */
+		config?: ListConfig<T>;
 		columns?: ColumnDefinition<T>[];
 		fields?: FieldDefinition<T>[];
 		meta?: Partial<Record<string, AttributeMetadata>>;
 		form?: { error?: string } | null;
-		enableExport?: boolean;
-		onExport?: (query: TableQuery) => Promise<T[]>;
-		xlsx?: XlsxModule;
 	} = $props();
 
 	function isEnvelope(value: unknown): value is PaginatedEnvelope<T> {
@@ -198,7 +193,7 @@
 							// embedded column without an explicit formatter falls back to
 							// joining each item's label (itemLabel, or the same
 							// sub-field-joining summary the embedded form list uses).
-							const formatter =
+							const resolvedFormatter =
 								resolveFormatter(m, data) ??
 								(embeddedFields
 									? (value: unknown) =>
@@ -212,6 +207,10 @@
 														.join(', ')
 												: ''
 									: undefined);
+							const formatter =
+								m.truncateUpTo != null
+									? truncateFormatter(resolvedFormatter, m.truncateUpTo)
+									: resolvedFormatter;
 							return {
 								attribute: k as keyof T & string,
 								title: m.label ?? k,
@@ -388,16 +387,12 @@
 		{read}
 		{deletion}
 		{actions}
-		{customBulkActions}
-		{search}
+		{config}
 		columns={resolvedColumns}
 		pagination={serverPagination}
 		{initialSort}
 		{initialFilters}
 		onPaginationChange={handlePaginationChange}
-		{enableExport}
-		{onExport}
-		{xlsx}
 		onCreate={navCreate}
 		onEdit={navEdit}
 		onView={navRead}

package/dist/components/crud/GenericCRUD.svelte.d.ts

@@ -1,7 +1,5 @@
-import type { XlsxModule } from '../table/export.js';
 import type { AttributeMetadata } from '../../types/attribute.js';
-import type { ActionConfiguration, ColumnDefinition, CustomAction, CustomBulkAction, FieldDefinition, SearchConfiguration } from '../../types/crud.js';
-import type { TableQuery } from '../../types/table.js';
+import type { ActionConfiguration, ColumnDefinition, FieldDefinition, ListActions, ListConfig } from '../../types/crud.js';
 declare function $$render<T extends object = Record<string, unknown>>(): {
     props: {
         data?: Record<string, unknown>;
@@ -15,18 +13,17 @@ declare function $$render<T extends object = Record<string, unknown>>(): {
         update?: ActionConfiguration<T>;
         read?: ActionConfiguration<T>;
         deletion?: ActionConfiguration<T>;
-        actions?: CustomAction<T>[];
-        customBulkActions?: CustomBulkAction<T>[];
-        search?: SearchConfiguration;
+        /** Extra per-row (`custom`) and per-selection (`bulk`) actions. */
+        actions?: ListActions<T>;
+        /** Opt-in list behaviors: free-text search, CSV/Excel export, and
+         * drag-to-reorder. */
+        config?: ListConfig<T>;
         columns?: ColumnDefinition<T>[];
         fields?: FieldDefinition<T>[];
         meta?: Partial<Record<string, AttributeMetadata>>;
         form?: {
             error?: string;
         } | null;
-        enableExport?: boolean;
-        onExport?: (query: TableQuery) => Promise<T[]>;
-        xlsx?: XlsxModule;
     };
     exports: {};
     bindings: "";

package/dist/components/crud/utils/embedded.d.ts

@@ -2,5 +2,6 @@ import type { FieldDefinition } from '../../../types/crud.js';
 export declare function seedField<T extends object = Record<string, unknown>>(f: FieldDefinition<T>, raw: unknown): unknown;
 export declare function emptyRecord<T extends object = Record<string, unknown>>(fields: FieldDefinition<T>[]): Record<string, unknown>;
 export declare function seedRecord<T extends object = Record<string, unknown>>(fields: FieldDefinition<T>[], source: Record<string, unknown>): Record<string, unknown>;
+export declare function applyDuplicateOmit<T extends object = Record<string, unknown>>(fields: FieldDefinition<T>[], record: Record<string, unknown>, omit?: string[]): Record<string, unknown>;
 export declare function formatEmbeddedFieldValue<T extends object = Record<string, unknown>>(f: FieldDefinition<T>, raw: unknown): string;
 export declare function defaultItemLabel<T extends object = Record<string, unknown>>(fields: FieldDefinition<T>[], item: Record<string, unknown>): string;

package/dist/components/crud/utils/embedded.js

@@ -39,6 +39,20 @@ export function seedRecord(fields, source) {
     }
     return seeded;
 }
+// Shared by Update.svelte and Create.svelte's "Duplicate" handling: returns a
+// copy of the just-saved record with `omit`-listed attributes reset to their
+// field default, so the new draft doesn't inherit values that only made sense
+// for the original instance (e.g. a publication date).
+export function applyDuplicateOmit(fields, record, omit = []) {
+    if (!omit.length)
+        return record;
+    const result = { ...record };
+    for (const f of fields) {
+        if (omit.includes(f.attribute))
+            result[f.attribute] = seedField(f, f.default);
+    }
+    return result;
+}
 // Shared by defaultItemLabel and the CSV/XLSX export column expansion: renders
 // one sub-field's raw stored value as display text, resolving a select's
 // option label instead of its stored value. Booleans are left to the caller

package/dist/components/crud/utils/formatters.d.ts

@@ -1,4 +1,3 @@
 export declare const formatBoolean: (trueLabel?: string, falseLabel?: string) => () => (value: boolean) => string;
 export declare const formatDatetime: (format?: string, timeZone?: string) => (() => (value: Date) => string);
-export declare function formatTruncateTextUpTo(maxLength: number): () => (value: string) => string;
 export declare function formatInstance<T extends Record<string, unknown>>(attribute: keyof T & string, instances: T[], urlPath: string, idKey?: keyof T & string): (value: unknown) => string;

package/dist/components/crud/utils/formatters.js

@@ -52,12 +52,6 @@ export const formatDatetime = (format = 'dd/mm/YYYY HH:MM', timeZone) => {
     };
     return () => fmt;
 };
-export function formatTruncateTextUpTo(maxLength) {
-    return () => (value) => {
-        const str = String(value ?? '');
-        return str.length > maxLength ? str.slice(0, maxLength) + '…' : str;
-    };
-}
 function escapeHtml(str) {
     return str
         .replace(/&/g, '&')

package/dist/components/crud/utils/reorder.d.ts

@@ -0,0 +1,4 @@
+/** Given the full row list in its new (post-drag) order, returns copies of
+ * only the rows whose `attribute` no longer matches their new sequential
+ * (0-based) position — the minimal set worth persisting. */
+export declare function computeReorderChanges<T extends object>(rows: T[], attribute: keyof T & string): T[];

package/dist/components/crud/utils/reorder.js

@@ -0,0 +1,13 @@
+/** Given the full row list in its new (post-drag) order, returns copies of
+ * only the rows whose `attribute` no longer matches their new sequential
+ * (0-based) position — the minimal set worth persisting. */
+export function computeReorderChanges(rows, attribute) {
+    const changed = [];
+    rows.forEach((row, index) => {
+        const current = Number(row[attribute]);
+        if (current !== index) {
+            changed.push({ ...row, [attribute]: index });
+        }
+    });
+    return changed;
+}

package/dist/components/crud/utils/resolution.d.ts

@@ -3,5 +3,6 @@ import type { FieldDefinition } from '../../../types/crud.js';
 export declare function resolveOptions(m: AttributeMetadata, d: unknown): SelectOption[] | undefined;
 export declare function resolveDefault(m: AttributeMetadata, d: unknown): unknown;
 export declare function resolveFormatter(m: AttributeMetadata, d: unknown): import("../../../index.ts").CellFormatter<any, any> | undefined;
+export declare function truncateFormatter<T extends object = Record<string, unknown>, V = unknown>(formatter: ((value: V, row: T) => string) | undefined, maxLength: number): (value: V, row: T) => string;
 export declare function inferType(key: string, value: unknown): AttributeType;
 export declare function buildFieldDefinitions<T extends object = Record<string, unknown>>(meta: Partial<Record<string, AttributeMetadata>>, data: unknown, excludedFlag: 'excludedFromCreate' | 'excludedFromRead' | 'excludedFromUpdate' | 'excludedFromList', excluded: Set<string>): FieldDefinition<T>[];

package/dist/components/crud/utils/resolution.js

@@ -9,6 +9,17 @@ export function resolveDefault(m, d) {
 export function resolveFormatter(m, d) {
     return m.formatter?.(d);
 }
+// List column only (GenericCRUD's resolvedColumns): wraps `formatter` (or,
+// absent one, the same raw String(value) TableBody falls back to) so a column
+// that needs to stay narrow can truncate its cell without that truncation
+// leaking into the Read view or the Create/Update forms, which call
+// `formatter` directly and never go through this wrapper.
+export function truncateFormatter(formatter, maxLength) {
+    return (value, row) => {
+        const str = formatter ? formatter(value, row) : String(value ?? '');
+        return str.length > maxLength ? str.slice(0, maxLength) + '…' : str;
+    };
+}
 export function inferType(key, value) {
     if (typeof value === 'boolean')
         return 'boolean';

package/dist/components/crud/views/Create.svelte

@@ -8,7 +8,7 @@
   import { defaultIconSet } from '../../../icons/sets/default.js';
   import { validateAll } from '../utils/validation.js';
   import { groupFields } from '../utils/grouping.js';
-  import { emptyRecord, seedRecord } from '../utils/embedded.js';
+  import { applyDuplicateOmit, emptyRecord, seedRecord } from '../utils/embedded.js';
   import type { ActionConfiguration, FieldDefinition } from '../../../types/crud.js';
   import { getStrings } from '../../../i18n/context.js';
 
@@ -136,6 +136,7 @@
             fieldErrors = {};
             internalError = '';
             flashSuccess();
+            record = applyDuplicateOmit(fields, record, creation.duplication?.omit);
           } else {
             onSuccess?.();
           }

package/dist/components/crud/views/Update.svelte

@@ -8,7 +8,7 @@
   import { defaultIconSet } from '../../../icons/sets/default.js';
   import { validateAll } from '../utils/validation.js';
   import { groupFields } from '../utils/grouping.js';
-  import { seedRecord } from '../utils/embedded.js';
+  import { applyDuplicateOmit, seedRecord } from '../utils/embedded.js';
   import type { ActionConfiguration, FieldDefinition } from '../../../types/crud.js';
   import { getStrings } from '../../../i18n/context.js';
 
@@ -123,7 +123,7 @@
             onContinue?.();
           } else if (duplicating) {
             duplicating = false;
-            onDuplicate?.(record);
+            onDuplicate?.(applyDuplicateOmit(fields, record, update.duplication?.omit));
           } else {
             onSuccess?.();
           }