@happyvertical/smrt-svelte 0.55.7 → 0.55.8

package/dist/components/import-export/collection-adapter.d.ts

@@ -0,0 +1,35 @@
+import { type SmrtCrudFetchers, type SmrtWebCollectionDefinition } from '@happyvertical/smrt-web';
+import { type FieldsFromDefinitionOptions } from './fields.js';
+import type { ImportExportField } from './types.js';
+export interface LoadRowsOptions {
+    signal?: AbortSignal;
+    /** Rows per request. Default 500. */
+    pageSize?: number;
+    /** Safety cap on exported rows. Default 50000. */
+    maxRows?: number;
+    /** Extra list params (for example `where` or `orderBy`) merged into each page request. */
+    query?: Record<string, unknown>;
+}
+export interface CollectionImportExport {
+    fields: ImportExportField[];
+    createRecord: (values: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    loadRows: (options?: LoadRowsOptions) => Promise<Array<Record<string, unknown>>>;
+}
+export declare class ExportLimitError extends Error {
+    readonly maxRows: number;
+    constructor(maxRows: number);
+}
+/**
+ * Bind the import/export UI to a collection's generated CRUD fetchers. Rows go
+ * through the same REST create/list routes (and so the same authorization,
+ * tenancy, and validation) as any other client; this layer never writes SQL.
+ *
+ * `loadRows` pages with `limit`/`offset` and fails with
+ * {@link ExportLimitError} rather than silently truncating at `maxRows`.
+ */
+export declare function createCollectionImportExport(input: {
+    definition: Pick<SmrtWebCollectionDefinition, 'name' | 'fields'>;
+    fetchers: Pick<SmrtCrudFetchers, 'list' | 'create'>;
+    fieldOptions?: FieldsFromDefinitionOptions;
+}): CollectionImportExport;
+//# sourceMappingURL=collection-adapter.d.ts.map

package/dist/components/import-export/collection-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-adapter.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/collection-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,2BAA2B,EAGjC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,YAAY,EAAE,CACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACtC,QAAQ,EAAE,CACR,OAAO,CAAC,EAAE,eAAe,KACtB,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9C;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBACb,OAAO,EAAE,MAAM;CAK5B;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,UAAU,EAAE,IAAI,CAAC,2BAA2B,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC;IACjE,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC;IACpD,YAAY,CAAC,EAAE,2BAA2B,CAAC;CAC5C,GAAG,sBAAsB,CAwBzB"}

package/dist/components/import-export/collection-adapter.js

@@ -0,0 +1,42 @@
+import { unwrapItemResult, unwrapListResult, } from '@happyvertical/smrt-web';
+import { fieldsFromCollectionDefinition, } from './fields.js';
+export class ExportLimitError extends Error {
+    maxRows;
+    constructor(maxRows) {
+        super(`Export stopped at the ${maxRows} row limit`);
+        this.name = 'ExportLimitError';
+        this.maxRows = maxRows;
+    }
+}
+/**
+ * Bind the import/export UI to a collection's generated CRUD fetchers. Rows go
+ * through the same REST create/list routes (and so the same authorization,
+ * tenancy, and validation) as any other client; this layer never writes SQL.
+ *
+ * `loadRows` pages with `limit`/`offset` and fails with
+ * {@link ExportLimitError} rather than silently truncating at `maxRows`.
+ */
+export function createCollectionImportExport(input) {
+    const { definition, fetchers } = input;
+    return {
+        fields: fieldsFromCollectionDefinition(definition, input.fieldOptions),
+        async createRecord(values) {
+            const result = await fetchers.create(values);
+            return unwrapItemResult(result, `create(${definition.name})`);
+        },
+        async loadRows(options = {}) {
+            const pageSize = Math.max(1, options.pageSize ?? 500);
+            const maxRows = options.maxRows ?? 50_000;
+            const rows = [];
+            for (let offset = 0;; offset += pageSize) {
+                options.signal?.throwIfAborted();
+                const page = unwrapListResult(await fetchers.list({ ...options.query, limit: pageSize, offset }), definition.name);
+                rows.push(...page);
+                if (rows.length > maxRows)
+                    throw new ExportLimitError(maxRows);
+                if (page.length < pageSize)
+                    return rows;
+            }
+        },
+    };
+}

package/dist/components/import-export/csv.d.ts

@@ -0,0 +1,60 @@
+/**
+ * RFC 4180 delimited-text parsing and formatting. Pure; no DOM.
+ */
+export declare class CsvParseError extends Error {
+    readonly code: 'unterminated-quote' | 'too-many-rows' | 'empty';
+    readonly line: number;
+    constructor(code: 'unterminated-quote' | 'too-many-rows' | 'empty', line: number, message: string);
+}
+/** Strip a UTF-8 byte-order mark left by spreadsheet exports. */
+export declare function stripBom(text: string): string;
+/**
+ * Pick the delimiter that occurs most often, outside quotes, on the first
+ * non-empty line. Ties and empty input resolve to a comma.
+ */
+export declare function detectDelimiter(text: string): string;
+export interface ParseDelimitedOptions {
+    /** Defaults to {@link detectDelimiter}. */
+    delimiter?: string;
+    /** Throw `too-many-rows` when the file holds more records than this (header included). */
+    maxRecords?: number;
+}
+export interface ParsedRecords {
+    delimiter: string;
+    /** All non-blank records, header first. */
+    records: string[][];
+    /** 1-based file line each record starts on. */
+    lines: number[];
+}
+/**
+ * Parse delimited text into records. Handles quoted cells, doubled-quote
+ * escapes, embedded delimiters and newlines, CR/LF/CRLF endings, and a BOM.
+ * Blank lines are skipped. An unterminated quote is an error, never a
+ * silently swallowed remainder of the file.
+ */
+export declare function parseDelimited(input: string, options?: ParseDelimitedOptions): ParsedRecords;
+/**
+ * Parse a file into a header row and data rows. Throws `empty` when the file
+ * has no header.
+ */
+export declare function parseTable(input: string, options?: ParseDelimitedOptions): {
+    delimiter: string;
+    headers: string[];
+    rows: string[][];
+    lines: number[];
+};
+export interface FormatDelimitedOptions {
+    delimiter?: string;
+    eol?: string;
+}
+/** Serialize string cells to delimited text (no trailing newline). */
+export declare function formatDelimited(rows: ReadonlyArray<ReadonlyArray<string>>, options?: FormatDelimitedOptions): string;
+/**
+ * Defuse spreadsheet formula injection: a text cell starting with `= + - @`,
+ * a tab, or a CR is prefixed with an apostrophe so Excel/Sheets show it as
+ * text. Never apply to numeric cells.
+ */
+export declare function neutralizeFormula(value: string): string;
+/** Inverse of {@link neutralizeFormula}, applied to text cells on import. */
+export declare function restoreNeutralized(value: string): string;
+//# sourceMappingURL=csv.d.ts.map

package/dist/components/import-export/csv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/csv.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,eAAe,GAAG,OAAO,CAAC;IAChE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEpB,IAAI,EAAE,oBAAoB,GAAG,eAAe,GAAG,OAAO,EACtD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM;CAOlB;AAID,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA6BpD;AAED,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,+CAA+C;IAC/C,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC,aAAa,CAqFf;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAW7E;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAaD,sEAAsE;AACtE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAC1C,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAWR;AAID;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIxD"}

package/dist/components/import-export/csv.js

@@ -0,0 +1,192 @@
+/**
+ * RFC 4180 delimited-text parsing and formatting. Pure; no DOM.
+ */
+export class CsvParseError extends Error {
+    code;
+    line;
+    constructor(code, line, message) {
+        super(message);
+        this.name = 'CsvParseError';
+        this.code = code;
+        this.line = line;
+    }
+}
+const CANDIDATE_DELIMITERS = [',', ';', '\t', '|'];
+/** Strip a UTF-8 byte-order mark left by spreadsheet exports. */
+export function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+/**
+ * Pick the delimiter that occurs most often, outside quotes, on the first
+ * non-empty line. Ties and empty input resolve to a comma.
+ */
+export function detectDelimiter(text) {
+    const counts = new Map(CANDIDATE_DELIMITERS.map((d) => [d, 0]));
+    let inQuotes = false;
+    let sawContent = false;
+    for (const ch of stripBom(text)) {
+        if (ch === '"') {
+            inQuotes = !inQuotes;
+            sawContent = true;
+        }
+        else if (!inQuotes && (ch === '\n' || ch === '\r')) {
+            if (sawContent)
+                break;
+        }
+        else if (!inQuotes) {
+            sawContent = true;
+            const count = counts.get(ch);
+            if (count !== undefined)
+                counts.set(ch, count + 1);
+        }
+        else {
+            sawContent = true;
+        }
+    }
+    let best = ',';
+    let bestCount = 0;
+    for (const [delimiter, count] of counts) {
+        if (count > bestCount) {
+            best = delimiter;
+            bestCount = count;
+        }
+    }
+    return best;
+}
+/**
+ * Parse delimited text into records. Handles quoted cells, doubled-quote
+ * escapes, embedded delimiters and newlines, CR/LF/CRLF endings, and a BOM.
+ * Blank lines are skipped. An unterminated quote is an error, never a
+ * silently swallowed remainder of the file.
+ */
+export function parseDelimited(input, options = {}) {
+    const text = stripBom(input);
+    const delimiter = options.delimiter ?? detectDelimiter(text);
+    const records = [];
+    const lines = [];
+    let record = [];
+    let cell = '';
+    let inQuotes = false;
+    let cellQuoted = false;
+    let recordQuoted = false;
+    let line = 1;
+    let recordLine = 1;
+    let quoteLine = 1;
+    const finishCell = () => {
+        record.push(cell);
+        cell = '';
+        cellQuoted = false;
+    };
+    const finishRecord = () => {
+        finishCell();
+        // A line with no cells and no quoted cell is blank; skip it.
+        const blank = record.length === 1 && record[0] === '' && !recordQuoted;
+        if (!blank) {
+            if (options.maxRecords !== undefined &&
+                records.length >= options.maxRecords) {
+                throw new CsvParseError('too-many-rows', recordLine, `File has more than ${options.maxRecords} records`);
+            }
+            records.push(record);
+            lines.push(recordLine);
+        }
+        record = [];
+        recordQuoted = false;
+    };
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inQuotes) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') {
+                    cell += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                if (ch === '\n')
+                    line++;
+                cell += ch;
+            }
+            continue;
+        }
+        if (ch === '"' && cell === '' && !cellQuoted) {
+            inQuotes = true;
+            cellQuoted = true;
+            recordQuoted = true;
+            quoteLine = line;
+        }
+        else if (ch === delimiter) {
+            finishCell();
+        }
+        else if (ch === '\n' || ch === '\r') {
+            if (ch === '\r' && text[i + 1] === '\n')
+                i++;
+            finishRecord();
+            line++;
+            recordLine = line;
+        }
+        else {
+            cell += ch;
+        }
+    }
+    if (inQuotes) {
+        throw new CsvParseError('unterminated-quote', quoteLine, `Unterminated quoted cell starting on line ${quoteLine}`);
+    }
+    if (cell !== '' || record.length > 0 || cellQuoted)
+        finishRecord();
+    return { delimiter, records, lines };
+}
+/**
+ * Parse a file into a header row and data rows. Throws `empty` when the file
+ * has no header.
+ */
+export function parseTable(input, options = {}) {
+    const { delimiter, records, lines } = parseDelimited(input, options);
+    if (records.length === 0) {
+        throw new CsvParseError('empty', 1, 'File is empty');
+    }
+    return {
+        delimiter,
+        headers: records[0].map((h) => h.trim()),
+        rows: records.slice(1),
+        lines: lines.slice(1),
+    };
+}
+function quoteCell(value, delimiter) {
+    const needsQuotes = value.includes(delimiter) ||
+        value.includes('"') ||
+        value.includes('\n') ||
+        value.includes('\r') ||
+        value.startsWith(' ') ||
+        value.endsWith(' ');
+    return needsQuotes ? `"${value.replaceAll('"', '""')}"` : value;
+}
+/** Serialize string cells to delimited text (no trailing newline). */
+export function formatDelimited(rows, options = {}) {
+    const delimiter = options.delimiter ?? ',';
+    const eol = options.eol ?? '\r\n';
+    return rows
+        .map((row) => 
+    // A lone empty cell is quoted so the line is not read back as blank.
+    row.length === 1 && row[0] === ''
+        ? '""'
+        : row.map((cell) => quoteCell(cell, delimiter)).join(delimiter))
+        .join(eol);
+}
+const FORMULA_TRIGGER = /^[=+\-@\t\r]/;
+/**
+ * Defuse spreadsheet formula injection: a text cell starting with `= + - @`,
+ * a tab, or a CR is prefixed with an apostrophe so Excel/Sheets show it as
+ * text. Never apply to numeric cells.
+ */
+export function neutralizeFormula(value) {
+    return FORMULA_TRIGGER.test(value) ? `'${value}` : value;
+}
+/** Inverse of {@link neutralizeFormula}, applied to text cells on import. */
+export function restoreNeutralized(value) {
+    return value.startsWith("'") && FORMULA_TRIGGER.test(value.slice(1))
+        ? value.slice(1)
+        : value;
+}

package/dist/components/import-export/download.d.ts

@@ -0,0 +1,4 @@
+import type { ExportFile } from './types.js';
+/** Hand a generated file to the browser as a download. No-op without a DOM. */
+export declare function downloadFile(file: ExportFile): void;
+//# sourceMappingURL=download.d.ts.map

package/dist/components/import-export/download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/download.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAmBnD"}

package/dist/components/import-export/download.js

@@ -0,0 +1,17 @@
+/** Hand a generated file to the browser as a download. No-op without a DOM. */
+export function downloadFile(file) {
+    if (typeof document === 'undefined' ||
+        typeof URL.createObjectURL !== 'function') {
+        return;
+    }
+    const url = URL.createObjectURL(new Blob([file.content], { type: file.mimeType }));
+    const anchor = document.createElement('a');
+    anchor.href = url;
+    anchor.download = file.filename;
+    anchor.rel = 'noopener';
+    document.body.append(anchor);
+    anchor.click();
+    anchor.remove();
+    // Revoke after the click has been dispatched so the download can start.
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}

package/dist/components/import-export/export.d.ts

@@ -0,0 +1,25 @@
+import type { ExportFile, ImportExportField } from './types.js';
+export type ExportFormat = 'csv' | 'tsv';
+export interface BuildExportOptions {
+    rows: ReadonlyArray<Record<string, unknown>>;
+    fields: readonly ImportExportField[];
+    /** Field names to export, in order. Defaults to every exportable field. */
+    columns?: readonly string[];
+    format?: ExportFormat;
+    includeHeader?: boolean;
+    /** `name` keeps the file re-importable by exact match; `label` is friendlier. */
+    headerStyle?: 'name' | 'label';
+    /** Defuse spreadsheet formula injection in text cells. Default true. */
+    neutralizeFormulas?: boolean;
+    /** Prefix a UTF-8 BOM (CSV only) so Excel detects the encoding. Default true. */
+    bom?: boolean;
+    /** Base file name without extension. Default `export`. */
+    filename?: string;
+}
+/** Fields eligible for export, honoring an explicit ordered selection. */
+export declare function selectExportFields(fields: readonly ImportExportField[], columns?: readonly string[]): ImportExportField[];
+/** Render one record value as cell text. */
+export declare function serializeCell(value: unknown): string;
+/** Build a downloadable CSV/TSV file from loaded rows. Pure. */
+export declare function buildExportFile(options: BuildExportOptions): ExportFile;
+//# sourceMappingURL=export.d.ts.map

package/dist/components/import-export/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/export.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,CAAC;AAEzC,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,2EAA2E;IAC3E,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iFAAiF;IACjF,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAID,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,iBAAiB,EAAE,EACpC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAC1B,iBAAiB,EAAE,CAQrB;AAED,4CAA4C;AAC5C,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAcpD;AAOD,gEAAgE;AAChE,wBAAgB,eAAe,CAAC,OAAO,EAAE,kBAAkB,GAAG,UAAU,CAqCvE"}

package/dist/components/import-export/export.js

@@ -0,0 +1,68 @@
+import { formatDelimited, neutralizeFormula } from './csv.js';
+const NUMERIC_TYPES = new Set(['integer', 'decimal', 'boolean']);
+/** Fields eligible for export, honoring an explicit ordered selection. */
+export function selectExportFields(fields, columns) {
+    const eligible = fields.filter((f) => f.exportable);
+    if (!columns)
+        return eligible;
+    const byName = new Map(eligible.map((f) => [f.name, f]));
+    return columns.flatMap((name) => {
+        const field = byName.get(name);
+        return field ? [field] : [];
+    });
+}
+/** Render one record value as cell text. */
+export function serializeCell(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return String(value);
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? '' : value.toISOString();
+    }
+    try {
+        return JSON.stringify(value) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function safeFilename(base) {
+    const cleaned = base.replace(/[^\w.-]+/g, '-').replace(/^-+|-+$/g, '');
+    return cleaned || 'export';
+}
+/** Build a downloadable CSV/TSV file from loaded rows. Pure. */
+export function buildExportFile(options) {
+    const format = options.format ?? 'csv';
+    const selected = selectExportFields(options.fields, options.columns);
+    const guard = options.neutralizeFormulas !== false;
+    const delimiter = format === 'tsv' ? '\t' : ',';
+    const table = [];
+    if (options.includeHeader !== false) {
+        table.push(selected.map((f) => (options.headerStyle === 'label' ? f.label : f.name)));
+    }
+    for (const row of options.rows) {
+        table.push(selected.map((field) => {
+            const text = serializeCell(row[field.name]);
+            // Numbers and booleans keep their sign; only free text can carry a formula.
+            return guard && !NUMERIC_TYPES.has(field.type)
+                ? neutralizeFormula(text)
+                : text;
+        }));
+    }
+    const body = selected.length === 0 ? '' : formatDelimited(table, { delimiter });
+    const withBom = format === 'csv' && options.bom !== false;
+    return {
+        filename: `${safeFilename(options.filename ?? 'export')}.${format}`,
+        mimeType: format === 'tsv'
+            ? 'text/tab-separated-values;charset=utf-8'
+            : 'text/csv;charset=utf-8',
+        content: `${withBom ? '' : ''}${body}`,
+        rowCount: options.rows.length,
+        columnCount: selected.length,
+    };
+}

package/dist/components/import-export/fields.d.ts

@@ -0,0 +1,48 @@
+import type { SmrtWebCollectionDefinition } from '@happyvertical/smrt-web';
+import type { ImportExportField } from './types.js';
+/**
+ * The slice of a resolved field policy (`ResolvedFieldPolicy` from
+ * `@happyvertical/smrt-fields`) the import/export layer reads. Declared
+ * structurally so this package takes no dependency on smrt-fields: pass the
+ * resolver's `fields` record as-is.
+ */
+export interface ImportExportFieldPolicy {
+    visibility?: 'basic' | 'advanced' | 'hidden';
+    label?: string | null;
+    help?: string | null;
+    order?: number | null;
+    /** An org-locked field keeps its resolved default and is never overwritten by import. */
+    locked?: boolean;
+    hasDefault?: boolean;
+    defaultValue?: unknown;
+    required?: boolean;
+}
+export interface FieldsFromDefinitionOptions {
+    /** Resolved policy per field name (`ResolvedObjectFieldPolicy.fields`). */
+    policy?: Readonly<Record<string, ImportExportFieldPolicy>>;
+    /** Enumerations the manifest does not carry: field name to allowed values. */
+    enums?: Readonly<Record<string, readonly string[]>>;
+    /** Field names that must be unique within an imported file. */
+    unique?: readonly string[];
+    /** Field names to leave out entirely. */
+    exclude?: readonly string[];
+}
+/** `publishedAt` becomes `Published At`. */
+export declare function humanizeFieldName(name: string): string;
+/**
+ * Derive import/export columns from a generated collection definition (the
+ * manifest) and, optionally, the resolved field policy:
+ *
+ * - system fields (`createdAt`, `updatedAt`, ...) and `_`-prefixed storage
+ *   fields are skipped; `id` is exportable but never imported; tenant fields
+ *   are neither
+ * - a supplied policy is an allowlist: a field the policy omits is neither
+ *   imported nor exported (manifest defaults apply only with no policy)
+ * - a policy `hidden` field is neither imported nor exported, so an export
+ *   cannot reveal what the UI hides
+ * - a policy `locked` field is not importable and keeps its resolved default
+ * - policy label, help, order, default and required override the manifest seed
+ * - order is policy order, then `ui.order`, then manifest declaration order
+ */
+export declare function fieldsFromCollectionDefinition(definition: Pick<SmrtWebCollectionDefinition, 'fields'>, options?: FieldsFromDefinitionOptions): ImportExportField[];
+//# sourceMappingURL=fields.d.ts.map

package/dist/components/import-export/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,iBAAiB,EAAyB,MAAM,YAAY,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,2BAA2B;IAC1C,2EAA2E;IAC3E,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAC;IAC3D,8EAA8E;IAC9E,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,CAAC;IACpD,+DAA+D;IAC/D,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,yCAAyC;IACzC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAyBD,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,IAAI,CAAC,2BAA2B,EAAE,QAAQ,CAAC,EACvD,OAAO,GAAE,2BAAgC,GACxC,iBAAiB,EAAE,CAoErB"}

package/dist/components/import-export/fields.js

@@ -0,0 +1,103 @@
+/** Managed by the framework or the server; never imported or exported by default. */
+const SYSTEM_FIELDS = new Set([
+    'createdAt',
+    'updatedAt',
+    'created_at',
+    'updated_at',
+    'context',
+]);
+/** Set from the session by tenant-scoped collections. */
+const TENANT_FIELDS = new Set(['tenantId', 'tenant_id']);
+const TYPE_MAP = {
+    text: 'text',
+    decimal: 'decimal',
+    integer: 'integer',
+    boolean: 'boolean',
+    datetime: 'datetime',
+    json: 'json',
+    foreignKey: 'reference',
+    crossPackageRef: 'reference',
+};
+/** `publishedAt` becomes `Published At`. */
+export function humanizeFieldName(name) {
+    const spaced = name
+        .replace(/[_-]+/g, ' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .trim();
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+/**
+ * Derive import/export columns from a generated collection definition (the
+ * manifest) and, optionally, the resolved field policy:
+ *
+ * - system fields (`createdAt`, `updatedAt`, ...) and `_`-prefixed storage
+ *   fields are skipped; `id` is exportable but never imported; tenant fields
+ *   are neither
+ * - a supplied policy is an allowlist: a field the policy omits is neither
+ *   imported nor exported (manifest defaults apply only with no policy)
+ * - a policy `hidden` field is neither imported nor exported, so an export
+ *   cannot reveal what the UI hides
+ * - a policy `locked` field is not importable and keeps its resolved default
+ * - policy label, help, order, default and required override the manifest seed
+ * - order is policy order, then `ui.order`, then manifest declaration order
+ */
+export function fieldsFromCollectionDefinition(definition, options = {}) {
+    const { policy, enums = {}, unique = [], exclude = [] } = options;
+    const skip = new Set(exclude);
+    const uniqueSet = new Set(unique);
+    const entries = [];
+    let seq = 0;
+    for (const [name, def] of Object.entries(definition.fields)) {
+        seq++;
+        if (name.startsWith('_') || SYSTEM_FIELDS.has(name) || skip.has(name))
+            continue;
+        if (name === 'id')
+            continue; // re-added below with fixed semantics
+        const p = policy?.[name];
+        // A supplied resolved policy is an allowlist: the resolver omits sensitive,
+        // transient and read-gated fields, so a field absent from it never appears.
+        if (policy && !p)
+            continue;
+        const tenant = TENANT_FIELDS.has(name);
+        const hidden = p?.visibility === 'hidden';
+        const locked = p?.locked === true;
+        const enumValues = enums[name];
+        const hasDefault = p?.hasDefault === true ||
+            (p?.hasDefault === undefined && def.default !== undefined);
+        const defaultValue = p?.hasDefault === true ? p.defaultValue : def.default;
+        const required = p?.required ?? (def.required === true && def.nullable !== true);
+        entries.push({
+            field: {
+                name,
+                label: p?.label || humanizeFieldName(name),
+                type: enumValues ? 'enum' : TYPE_MAP[def.type],
+                required: required && !hasDefault,
+                importable: !tenant && !hidden && !locked,
+                exportable: !tenant && !hidden,
+                ...(enumValues ? { options: enumValues } : {}),
+                ...(def.ui?.widget ? { widget: def.ui.widget } : {}),
+                ...((p?.help ?? def.description)
+                    ? { help: (p?.help ?? def.description) }
+                    : {}),
+                ...(hasDefault ? { hasDefault: true, defaultValue } : {}),
+                ...(locked && !hidden && !tenant ? { locked: true } : {}),
+                ...(uniqueSet.has(name) ? { unique: true } : {}),
+            },
+            order: p?.order ?? def.ui?.order ?? Number.POSITIVE_INFINITY,
+            seq,
+        });
+    }
+    entries.sort((a, b) => a.order === b.order ? a.seq - b.seq : a.order - b.order);
+    const fields = entries.map((e) => e.field);
+    if (!skip.has('id')) {
+        fields.unshift({
+            name: 'id',
+            label: 'ID',
+            type: 'reference',
+            required: false,
+            importable: false,
+            exportable: true,
+        });
+    }
+    return fields;
+}

package/dist/components/import-export/index.d.ts

@@ -0,0 +1,12 @@
+export { type CollectionImportExport, createCollectionImportExport, ExportLimitError, type LoadRowsOptions, } from './collection-adapter.js';
+export { CsvParseError, detectDelimiter, formatDelimited, neutralizeFormula, parseDelimited, parseTable, restoreNeutralized, stripBom, } from './csv.js';
+export { type BuildExportOptions, buildExportFile, type ExportFormat, selectExportFields, serializeCell, } from './export.js';
+export { type FieldsFromDefinitionOptions, fieldsFromCollectionDefinition, humanizeFieldName, type ImportExportFieldPolicy, } from './fields.js';
+export { default as ImportExport } from './ImportExport.svelte';
+export { autoMapColumns, normalizeHeader, setColumnTarget } from './mapping.js';
+export type { ImportExportProps } from './props.js';
+export { buildErrorReport, DEFAULT_ISSUE_MESSAGES, describeIssue, type IssueMessages, } from './report.js';
+export { type RunImportOptions, runImport } from './runner.js';
+export type { ColumnMapping, ExportFile, ImportExportField, ImportExportFieldType, ImportExportWidget, ImportIssue, ImportIssueCode, ImportRunResult, ParsedTable, ValidationResult, ValidRecord, } from './types.js';
+export { type CoerceResult, coerceCell, type ValidateRowsInput, validateMapping, validateRows, } from './validate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/import-export/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,gBAAgB,EAChB,KAAK,eAAe,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,QAAQ,GACT,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,kBAAkB,EACvB,eAAe,EACf,KAAK,YAAY,EACjB,kBAAkB,EAClB,aAAa,GACd,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,KAAK,2BAA2B,EAChC,8BAA8B,EAC9B,iBAAiB,EACjB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAChF,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,aAAa,EACb,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/D,YAAY,EACV,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,YAAY,EACjB,UAAU,EACV,KAAK,iBAAiB,EACtB,eAAe,EACf,YAAY,GACb,MAAM,eAAe,CAAC"}

package/dist/components/import-export/index.js

@@ -0,0 +1,9 @@
+export { createCollectionImportExport, ExportLimitError, } from './collection-adapter.js';
+export { CsvParseError, detectDelimiter, formatDelimited, neutralizeFormula, parseDelimited, parseTable, restoreNeutralized, stripBom, } from './csv.js';
+export { buildExportFile, selectExportFields, serializeCell, } from './export.js';
+export { fieldsFromCollectionDefinition, humanizeFieldName, } from './fields.js';
+export { default as ImportExport } from './ImportExport.svelte';
+export { autoMapColumns, normalizeHeader, setColumnTarget } from './mapping.js';
+export { buildErrorReport, DEFAULT_ISSUE_MESSAGES, describeIssue, } from './report.js';
+export { runImport } from './runner.js';
+export { coerceCell, validateMapping, validateRows, } from './validate.js';