runeforge 0.0.25 → 0.0.26

package/dist/components/crud/GenericCRUD.svelte

@@ -11,6 +11,7 @@
 		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';
@@ -150,15 +151,41 @@
 			(meta
 				? (Object.entries(meta) as [string, AttributeMetadata][])
 						.filter(([, m]) => !m.excludedFromList)
-						.map(([k, m]) => ({
-							attribute: k as keyof T & string,
-							title: m.label ?? k,
-							type: m.type,
-							formatter: resolveFormatter(m, data),
-							component: m.component,
-							sortable: m.sortable,
-							filterable: m.filterable
-						}))
+						.map(([k, m]) => {
+							const embeddedFields =
+								m.type === 'embedded' && m.fields
+									? buildFieldDefinitions(m.fields, data, 'excludedFromList', new Set())
+									: undefined;
+							// Arrays of objects have no sensible raw cell value, so an
+							// 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 =
+								resolveFormatter(m, data) ??
+								(embeddedFields
+									? (value: unknown) =>
+											Array.isArray(value)
+												? value
+														.map((item) =>
+															m.itemLabel
+																? m.itemLabel(item as Record<string, unknown>)
+																: defaultItemLabel(embeddedFields, item as Record<string, unknown>)
+														)
+														.join(', ')
+												: ''
+									: undefined);
+							return {
+								attribute: k as keyof T & string,
+								title: m.label ?? k,
+								type: m.type,
+								formatter,
+								component: m.component,
+								sortable: m.sortable,
+								filterable: m.filterable,
+								fields: embeddedFields,
+								itemLabel: m.itemLabel
+							};
+						})
 				: entityData.length > 0
 					? (Object.keys(entityData[0]) as (keyof T & string)[])
 							.filter((k) => !excluded.has(k))

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

@@ -1,4 +1,5 @@
 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 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

@@ -20,6 +20,18 @@ export function seedField(f, raw) {
 export function emptyRecord(fields) {
     return Object.fromEntries(fields.map((f) => [f.attribute, seedField(f, f.default)]));
 }
+// 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
+// since the item-label summary and an export cell want different renderings
+// (omit-when-false vs. an explicit true/false column).
+export function formatEmbeddedFieldValue(f, raw) {
+    if (raw == null || raw === '')
+        return '';
+    if (f.type === 'select')
+        return f.options?.find((o) => o.value === String(raw))?.label ?? String(raw);
+    return String(raw);
+}
 // Default summary shown per item in an embedded list when the field has no
 // `itemLabel`: joins each sub-field's resolved display value so the list is
 // at least readable out of the box.
@@ -27,13 +39,9 @@ export function defaultItemLabel(fields, item) {
     return fields
         .map((f) => {
         const raw = item[f.attribute];
-        if (raw == null || raw === '')
-            return null;
-        if (f.type === 'select')
-            return f.options?.find((o) => o.value === String(raw))?.label ?? String(raw);
         if (f.type === 'boolean')
             return raw ? fieldLabel(f) : null;
-        return String(raw);
+        return formatEmbeddedFieldValue(f, raw) || null;
     })
         .filter((v) => !!v)
         .join(' · ');

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

@@ -4,4 +4,4 @@ export declare function resolveOptions(m: AttributeMetadata, d: unknown): Select
 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 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', excluded: Set<string>): FieldDefinition<T>[];
+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/table/export.d.ts

@@ -13,5 +13,9 @@ export interface XlsxModule {
     };
     writeFile: (workbook: unknown, filename: string) => void;
 }
+export declare function buildTable<T extends object>(rows: T[], columns: ColumnDefinition<T>[]): {
+    headers: string[];
+    body: string[][];
+};
 export declare function downloadCsv<T extends object>(rows: T[], columns: ColumnDefinition<T>[], filename: string): void;
 export declare function downloadXlsx<T extends object>(rows: T[], columns: ColumnDefinition<T>[], filename: string, xlsx: XlsxModule): void;

package/dist/components/table/export.js

@@ -1,7 +1,39 @@
 import { cellRenderedText } from './utils.js';
-function buildTable(rows, columns) {
-    const headers = columns.map((col) => col.title ?? col.attribute);
-    const body = rows.map((row) => columns.map((col) => cellRenderedText(row, col)));
+import { formatEmbeddedFieldValue } from '../crud/utils/embedded.js';
+function isEmbeddedColumn(col) {
+    return col.type === 'embedded' && !!col.fields?.length;
+}
+// Embedded columns hold one array of sub-records per row — there's no single
+// plain-text cell for that, so export (unlike the on-screen table, which
+// shows a joined summary) expands each one into its own row per item and one
+// sub-column per field, duplicating the row's other column values across
+// them. Rows are aligned by index across embedded columns rather than
+// cross-joined, since unrelated embedded lists on the same row (e.g. two
+// independent one-to-many relations) have no meaningful pairing.
+export function buildTable(rows, columns) {
+    const embeddedColumns = columns.filter(isEmbeddedColumn);
+    if (embeddedColumns.length === 0) {
+        const headers = columns.map((col) => col.title ?? col.attribute);
+        const body = rows.map((row) => columns.map((col) => cellRenderedText(row, col)));
+        return { headers, body };
+    }
+    const headers = columns.flatMap((col) => isEmbeddedColumn(col)
+        ? col.fields.map((f) => `${col.title ?? col.attribute} - ${f.title ?? f.attribute}`)
+        : [col.title ?? col.attribute]);
+    const body = [];
+    for (const row of rows) {
+        const itemCount = Math.max(1, ...embeddedColumns.map((col) => row[col.attribute]?.length ?? 0));
+        for (let i = 0; i < itemCount; i++) {
+            const line = columns.flatMap((col) => {
+                if (!isEmbeddedColumn(col))
+                    return [cellRenderedText(row, col)];
+                const items = row[col.attribute] ?? [];
+                const item = items[i];
+                return col.fields.map((f) => (item ? formatEmbeddedFieldValue(f, item[f.attribute]) : ''));
+            });
+            body.push(line);
+        }
+    }
     return { headers, body };
 }
 function escapeCsvCell(value) {

package/dist/types/crud.d.ts

@@ -11,6 +11,13 @@ export type ColumnDefinition<T extends object = Record<string, unknown>> = {
         formatter?: CellFormatter<T, T[K]>;
         sortable?: boolean;
         filterable?: boolean;
+        /** Embedded columns only: sub-field definitions for each item, used to
+         * render a default cell summary and to expand the column into one
+         * sub-column per field on CSV/XLSX export. */
+        fields?: FieldDefinition<Record<string, unknown>>[];
+        /** Embedded columns only: short label for an item, reused from the form
+         * field's `itemLabel` for the default cell summary. */
+        itemLabel?: (item: Record<string, unknown>) => string;
     };
 }[keyof T & string];
 export interface FieldDefinition<T extends object = Record<string, unknown>> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runeforge",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "SvelteKit toolkit for building metadata-driven CRUD interfaces with tables, forms, and actions",
   "license": "MIT",
   "author": "Ezequiel Puerta",