@happyvertical/smrt-svelte 0.55.7 → 0.55.9

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

@@ -0,0 +1,12 @@
+import type { ColumnMapping, ImportExportField } from './types.js';
+/** Normalize a header or field name so `Created At`, `created_at` and `createdAt` agree. */
+export declare function normalizeHeader(value: string): string;
+/**
+ * Suggest a target field for each source header. Matching is by normalized
+ * field name, then label, then declared alias; a field is claimed by at most
+ * one column (the first match), and non-importable fields are never targets.
+ */
+export declare function autoMapColumns(headers: readonly string[], fields: readonly ImportExportField[]): (string | null)[];
+/** Replace one column's target, clearing any other column that held the same field. */
+export declare function setColumnTarget(mapping: ColumnMapping, index: number, target: string | null): (string | null)[];
+//# sourceMappingURL=mapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMrD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAsBnB;AAED,uFAAuF;AACvF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAKnB"}

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

@@ -0,0 +1,38 @@
+/** Normalize a header or field name so `Created At`, `created_at` and `createdAt` agree. */
+export function normalizeHeader(value) {
+    return value
+        .normalize('NFKD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-zA-Z0-9]+/g, '')
+        .toLowerCase();
+}
+/**
+ * Suggest a target field for each source header. Matching is by normalized
+ * field name, then label, then declared alias; a field is claimed by at most
+ * one column (the first match), and non-importable fields are never targets.
+ */
+export function autoMapColumns(headers, fields) {
+    const importable = fields.filter((f) => f.importable);
+    const claimed = new Set();
+    return headers.map((header) => {
+        const key = normalizeHeader(header);
+        if (!key)
+            return null;
+        const match = importable.find((f) => !claimed.has(f.name) && normalizeHeader(f.name) === key) ??
+            importable.find((f) => !claimed.has(f.name) && normalizeHeader(f.label) === key) ??
+            importable.find((f) => !claimed.has(f.name) &&
+                (f.aliases ?? []).some((alias) => normalizeHeader(alias) === key));
+        if (!match)
+            return null;
+        claimed.add(match.name);
+        return match.name;
+    });
+}
+/** Replace one column's target, clearing any other column that held the same field. */
+export function setColumnTarget(mapping, index, target) {
+    return mapping.map((current, i) => {
+        if (i === index)
+            return target;
+        return target !== null && current === target ? null : current;
+    });
+}

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

@@ -0,0 +1,34 @@
+import type { ExportFile, ImportExportField, ImportRunResult } from './types.js';
+export interface ImportExportProps {
+    /** Columns, usually from `fieldsFromCollectionDefinition` (manifest + resolved policy). */
+    fields: ImportExportField[];
+    /** Heading context, for example the collection's plural label. */
+    collectionLabel?: string;
+    /**
+     * Persist one validated row. Providing it enables import; reject to fail just
+     * that row. `createCollectionImportExport(...).createRecord` fits.
+     */
+    createRecord?: (values: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * Load the rows to export. Providing it enables export. Throw to report a
+     * failure. `createCollectionImportExport(...).loadRows` fits.
+     */
+    loadRows?: (options: {
+        signal?: AbortSignal;
+    }) => Promise<Array<Record<string, unknown>>>;
+    /** Base name for exported files. Default `export`. */
+    filename?: string;
+    /** Largest accepted file in bytes. Default 5 MiB. */
+    maxFileBytes?: number;
+    /** Most data rows accepted per file. Default 10,000. */
+    maxRows?: number;
+    /** Parallel create requests. Default 3. */
+    concurrency?: number;
+    /** Which sections to show. Default `both`; a missing callback hides its side. */
+    mode?: 'both' | 'import' | 'export';
+    /** Receives every generated file. Default triggers a browser download. */
+    ondownload?: (file: ExportFile) => void;
+    /** Called after an import run finishes (including a stopped run). */
+    onimported?: (result: ImportRunResult) => void;
+}
+//# sourceMappingURL=props.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/props.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,iBAAiB;IAChC,2FAA2F;IAC3F,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrE;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE;QACnB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9C,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpC,0EAA0E;IAC1E,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACxC,qEAAqE;IACrE,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAChD"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+import type { ExportFile, ImportIssue, ImportIssueCode } from './types.js';
+/** English defaults; the component overrides these with translated strings. */
+export declare const DEFAULT_ISSUE_MESSAGES: Record<ImportIssueCode, string>;
+export type IssueMessages = Partial<Record<ImportIssueCode, string>>;
+/** Human message for an issue, with `detail` appended when present. */
+export declare function describeIssue(issue: ImportIssue, messages?: IssueMessages): string;
+/**
+ * CSV error report: one row per issue with the file line, the source column,
+ * the target field, the offending value, and the problem. Echoed values are
+ * formula-neutralized because the report is meant to be opened in a spreadsheet.
+ */
+export declare function buildErrorReport(issues: readonly ImportIssue[], messages?: IssueMessages, filename?: string): ExportFile;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/report.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE3E,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAkBlE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;AAErE,uEAAuE;AACvE,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,QAAQ,GAAE,aAAkB,GAC3B,MAAM,CAGR;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,QAAQ,GAAE,aAAkB,EAC5B,QAAQ,SAAkB,GACzB,UAAU,CAkBZ"}

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

@@ -0,0 +1,50 @@
+import { formatDelimited, neutralizeFormula } from './csv.js';
+/** English defaults; the component overrides these with translated strings. */
+export const DEFAULT_ISSUE_MESSAGES = {
+    required: 'A value is required.',
+    'invalid-integer': 'Expected a whole number.',
+    'out-of-range': 'The number is outside the supported range.',
+    'invalid-decimal': 'Expected a number.',
+    'invalid-boolean': 'Expected true/false, yes/no or 1/0.',
+    'invalid-datetime': 'Expected an ISO 8601 date or date-time (YYYY-MM-DD or YYYY-MM-DDThh:mm:ss).',
+    'invalid-json': 'Expected valid JSON.',
+    'invalid-enum': 'Not one of the allowed values.',
+    'invalid-email': 'Expected an email address.',
+    'invalid-url': 'Expected an http(s) URL.',
+    'invalid-reference': 'Expected an id with no spaces.',
+    'duplicate-value': 'This value repeats an earlier row.',
+    'duplicate-mapping': 'More than one column maps to this field.',
+    'unmapped-required': 'This required field has no column mapped.',
+    'extra-cells': 'The row has more cells than the header.',
+    'import-failed': 'The server rejected this row.',
+};
+/** Human message for an issue, with `detail` appended when present. */
+export function describeIssue(issue, messages = {}) {
+    const base = messages[issue.code] ?? DEFAULT_ISSUE_MESSAGES[issue.code];
+    return issue.detail ? `${base} (${issue.detail})` : base;
+}
+const REPORT_HEADER = ['line', 'column', 'field', 'value', 'problem'];
+/**
+ * CSV error report: one row per issue with the file line, the source column,
+ * the target field, the offending value, and the problem. Echoed values are
+ * formula-neutralized because the report is meant to be opened in a spreadsheet.
+ */
+export function buildErrorReport(issues, messages = {}, filename = 'import-errors') {
+    const table = [
+        REPORT_HEADER,
+        ...issues.map((issue) => [
+            issue.line > 0 ? String(issue.line) : '',
+            neutralizeFormula(issue.column ?? ''),
+            neutralizeFormula(issue.field ?? ''),
+            neutralizeFormula(issue.value ?? ''),
+            neutralizeFormula(describeIssue(issue, messages)),
+        ]),
+    ];
+    return {
+        filename: `${filename}.csv`,
+        mimeType: 'text/csv;charset=utf-8',
+        content: `${formatDelimited(table)}`,
+        rowCount: issues.length,
+        columnCount: REPORT_HEADER.length,
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { ImportRunResult, ValidRecord } from './types.js';
+export interface RunImportOptions {
+    records: readonly ValidRecord[];
+    /** Persist one record; reject to fail just that row. */
+    createRecord: (values: Record<string, unknown>) => Promise<unknown>;
+    /** Parallel requests. Default 3; 1 keeps file order on the server. */
+    concurrency?: number;
+    signal?: AbortSignal;
+    onProgress?: (done: number, total: number) => void;
+}
+/**
+ * Create the validated records through the supplied collection call, one
+ * request per row, continuing past row failures so one bad row never loses the
+ * rest. Aborting stops starting new rows; in-flight rows finish and are counted.
+ */
+export declare function runImport(options: RunImportOptions): Promise<ImportRunResult>;
+//# sourceMappingURL=runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC,wDAAwD;IACxD,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACpE,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD;AAMD;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CAiC1B"}

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

@@ -0,0 +1,39 @@
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Create the validated records through the supplied collection call, one
+ * request per row, continuing past row failures so one bad row never loses the
+ * rest. Aborting stops starting new rows; in-flight rows finish and are counted.
+ */
+export async function runImport(options) {
+    const { records, createRecord, signal, onProgress } = options;
+    const concurrency = Math.max(1, Math.floor(options.concurrency ?? 3));
+    const failed = [];
+    let created = 0;
+    let attempted = 0;
+    let done = 0;
+    let next = 0;
+    async function worker() {
+        while (next < records.length && !signal?.aborted) {
+            const record = records[next++];
+            attempted++;
+            try {
+                await createRecord(record.values);
+                created++;
+            }
+            catch (error) {
+                failed.push({
+                    code: 'import-failed',
+                    line: record.line,
+                    detail: messageOf(error),
+                });
+            }
+            done++;
+            onProgress?.(done, records.length);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, records.length) }, worker));
+    failed.sort((a, b) => a.line - b.line);
+    return { attempted, created, failed, aborted: signal?.aborted === true };
+}

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

@@ -0,0 +1,100 @@
+/**
+ * Shared types for the import/export module. Everything here is plain data so
+ * the CSV layer (csv.ts, validate.ts, export.ts, runner.ts) runs in Node with
+ * no Svelte, DOM, or Provider.
+ */
+/** Column value kinds the importer understands (a superset-free mapping of the manifest types). */
+export type ImportExportFieldType = 'text' | 'integer' | 'decimal' | 'boolean' | 'datetime' | 'json' | 'reference' | 'enum';
+/** Presentation hint that also drives light validation (`email`, `url`). */
+export type ImportExportWidget = 'textarea' | 'currency' | 'email' | 'url' | 'phone';
+/**
+ * One importable/exportable column of a collection. Derive it from a
+ * collection definition and resolved field policy with
+ * `fieldsFromCollectionDefinition`, or author it by hand.
+ */
+export interface ImportExportField {
+    /** Property name on the record (also the default CSV header). */
+    name: string;
+    /** Human label (default for header matching and `headerStyle: 'label'`). */
+    label: string;
+    type: ImportExportFieldType;
+    /** Required with no default: an empty or unmapped cell fails validation. */
+    required: boolean;
+    /** False for read-only, locked, hidden, or system fields: never written by import. */
+    importable: boolean;
+    /** False for hidden or tenant-internal fields: never written to an export. */
+    exportable: boolean;
+    /** Allowed values for `type: 'enum'` (matched case-insensitively). */
+    options?: readonly string[];
+    widget?: ImportExportWidget;
+    /** Help text surfaced beside the mapping row. */
+    help?: string;
+    /** A resolved policy/manifest default; fills empty or unmapped cells. */
+    hasDefault?: boolean;
+    defaultValue?: unknown;
+    /**
+     * An org-locked field: not importable, but its resolved default is still
+     * written to every record. A non-importable field that is not `locked`
+     * (hidden, tenant, system) never enters the payload, defaults included.
+     */
+    locked?: boolean;
+    /** Reject a second row repeating the same value within one file. */
+    unique?: boolean;
+    /** Extra header spellings the auto-mapper should accept. */
+    aliases?: readonly string[];
+}
+/** A parsed delimited file: header row plus data rows with their file line numbers. */
+export interface ParsedTable {
+    delimiter: string;
+    headers: string[];
+    rows: string[][];
+    /** 1-based file line each entry of `rows` starts on (for error reports). */
+    lines: number[];
+}
+/** Per-source-column target: a field name, or null to skip the column. */
+export type ColumnMapping = ReadonlyArray<string | null>;
+export type ImportIssueCode = 'required' | 'invalid-integer' | 'out-of-range' | 'invalid-decimal' | 'invalid-boolean' | 'invalid-datetime' | 'invalid-json' | 'invalid-enum' | 'invalid-email' | 'invalid-url' | 'invalid-reference' | 'duplicate-value' | 'duplicate-mapping' | 'unmapped-required' | 'extra-cells' | 'import-failed';
+/** One validation or import problem. `line` is 0 for mapping-level issues. */
+export interface ImportIssue {
+    code: ImportIssueCode;
+    /** 1-based file line of the offending record; 0 when not row-specific. */
+    line: number;
+    field?: string;
+    /** Source column header the value came from. */
+    column?: string;
+    /** The offending raw cell (truncated to 200 chars). */
+    value?: string;
+    /** Extra context (the server error for `import-failed`, the allowed values for `invalid-enum`). */
+    detail?: string;
+}
+/** A row that passed validation, ready for `createRecord`. */
+export interface ValidRecord {
+    /** Index into the parsed `rows`. */
+    index: number;
+    line: number;
+    values: Record<string, unknown>;
+}
+export interface ValidationResult {
+    totalRows: number;
+    records: ValidRecord[];
+    /** Row-level issues, capped at `maxIssues`; see `issuesTruncated`. */
+    issues: ImportIssue[];
+    issuesTruncated: boolean;
+    /** Mapping-level issues (duplicate target, unmapped required field). */
+    mappingIssues: ImportIssue[];
+    invalidRows: number;
+}
+export interface ImportRunResult {
+    attempted: number;
+    created: number;
+    failed: ImportIssue[];
+    aborted: boolean;
+}
+export interface ExportFile {
+    filename: string;
+    mimeType: string;
+    content: string;
+    rowCount: number;
+    columnCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mGAAmG;AACnG,MAAM,MAAM,qBAAqB,GAC7B,MAAM,GACN,SAAS,GACT,SAAS,GACT,SAAS,GACT,UAAU,GACV,MAAM,GACN,WAAW,GACX,MAAM,CAAC;AAEX,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,UAAU,GACV,OAAO,GACP,KAAK,GACL,OAAO,CAAC;AAEZ;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,qBAAqB,CAAC;IAC5B,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,sFAAsF;IACtF,UAAU,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,UAAU,EAAE,OAAO,CAAC;IACpB,sEAAsE;IACtE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC7B;AAED,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,0EAA0E;AAC1E,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAEzD,MAAM,MAAM,eAAe,GACvB,UAAU,GACV,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,eAAe,GACf,aAAa,GACb,mBAAmB,GACnB,iBAAiB,GACjB,mBAAmB,GACnB,mBAAmB,GACnB,aAAa,GACb,eAAe,CAAC;AAEpB,8EAA8E;AAC9E,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,eAAe,CAAC;IACtB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mGAAmG;IACnG,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,8DAA8D;AAC9D,MAAM,WAAW,WAAW;IAC1B,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,sEAAsE;IACtE,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;IACzB,wEAAwE;IACxE,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB"}

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

@@ -0,0 +1,6 @@
+/**
+ * Shared types for the import/export module. Everything here is plain data so
+ * the CSV layer (csv.ts, validate.ts, export.ts, runner.ts) runs in Node with
+ * no Svelte, DOM, or Provider.
+ */
+export {};

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

@@ -0,0 +1,39 @@
+import type { ColumnMapping, ImportExportField, ImportIssue, ImportIssueCode, ValidationResult } from './types.js';
+export type CoerceResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    code: ImportIssueCode;
+    detail?: string;
+};
+/**
+ * Coerce one non-empty, trimmed cell to the field's type. Empty-cell handling
+ * (required, defaults) belongs to the caller.
+ *
+ * Datetimes are strict ISO 8601 (`2026-03-05`, `2026-03-05T09:30`,
+ * `2026-03-05T09:30:00-05:00`); a missing offset means UTC. Locale formats
+ * such as `3/5/2026` are rejected rather than guessed.
+ */
+export declare function coerceCell(raw: string, field: ImportExportField): CoerceResult;
+/** Mapping-level problems: two columns on one field, or a required field with no source. */
+export declare function validateMapping(headers: readonly string[], mapping: ColumnMapping, fields: readonly ImportExportField[]): ImportIssue[];
+export interface ValidateRowsInput {
+    headers: readonly string[];
+    /** Data rows (header excluded). */
+    rows: ReadonlyArray<ReadonlyArray<string>>;
+    /** 1-based file line of each row. Defaults to row index + 2. */
+    lines?: readonly number[];
+    mapping: ColumnMapping;
+    fields: readonly ImportExportField[];
+    /** Stop collecting row issues past this many (counts keep running). */
+    maxIssues?: number;
+}
+/**
+ * Validate and coerce every row against the mapped fields. Pure: this is the
+ * dry run, nothing is written. A row with any issue is excluded from
+ * `records`; `invalidRows` counts it once however many issues it has. While
+ * `mappingIssues` is non-empty `records` is empty.
+ */
+export declare function validateRows(input: ValidateRowsInput): ValidationResult;
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/components/import-export/validate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAapB,MAAM,MAAM,YAAY,GACpB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC5B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA8B1D;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,iBAAiB,GACvB,YAAY,CA8Dd;AAED,4FAA4F;AAC5F,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,WAAW,EAAE,CA0Bf;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,mCAAmC;IACnC,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,gEAAgE;IAChE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,uEAAuE;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAQD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,CAyHvE"}

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

@@ -0,0 +1,268 @@
+import { restoreNeutralized } from './csv.js';
+const MAX_ECHOED_VALUE = 200;
+const TRUE_WORDS = new Set(['true', 't', 'yes', 'y', '1', 'on']);
+const FALSE_WORDS = new Set(['false', 'f', 'no', 'n', '0', 'off']);
+const INTEGER = /^[+-]?\d+$/;
+const DECIMAL = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const DATETIME = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+function parseDatetime(raw) {
+    const m = DATETIME.exec(raw);
+    if (!m)
+        return null;
+    const [, y, mo, d, h = '00', mi = '00', s = '00', frac = '0', zone] = m;
+    const year = Number(y);
+    const month = Number(mo);
+    const day = Number(d);
+    const probe = new Date(Date.UTC(year, month - 1, day));
+    if (probe.getUTCFullYear() !== year ||
+        probe.getUTCMonth() !== month - 1 ||
+        probe.getUTCDate() !== day ||
+        Number(h) > 23 ||
+        Number(mi) > 59 ||
+        Number(s) > 59) {
+        return null;
+    }
+    const millis = frac.slice(0, 3).padEnd(3, '0');
+    let offset = 'Z';
+    if (zone && zone !== 'Z') {
+        offset = zone.includes(':') ? zone : `${zone.slice(0, 3)}:${zone.slice(3)}`;
+    }
+    const iso = `${y}-${mo}-${d}T${h}:${mi}:${s}.${millis}${offset}`;
+    const time = Date.parse(iso);
+    return Number.isNaN(time) ? null : new Date(time).toISOString();
+}
+/**
+ * Coerce one non-empty, trimmed cell to the field's type. Empty-cell handling
+ * (required, defaults) belongs to the caller.
+ *
+ * Datetimes are strict ISO 8601 (`2026-03-05`, `2026-03-05T09:30`,
+ * `2026-03-05T09:30:00-05:00`); a missing offset means UTC. Locale formats
+ * such as `3/5/2026` are rejected rather than guessed.
+ */
+export function coerceCell(raw, field) {
+    switch (field.type) {
+        case 'integer': {
+            if (!INTEGER.test(raw))
+                return { ok: false, code: 'invalid-integer' };
+            const n = Number(raw);
+            if (!Number.isSafeInteger(n))
+                return { ok: false, code: 'out-of-range' };
+            return { ok: true, value: n };
+        }
+        case 'decimal': {
+            if (!DECIMAL.test(raw))
+                return { ok: false, code: 'invalid-decimal' };
+            const n = Number(raw);
+            if (!Number.isFinite(n))
+                return { ok: false, code: 'out-of-range' };
+            return { ok: true, value: n };
+        }
+        case 'boolean': {
+            const word = raw.toLowerCase();
+            if (TRUE_WORDS.has(word))
+                return { ok: true, value: true };
+            if (FALSE_WORDS.has(word))
+                return { ok: true, value: false };
+            return { ok: false, code: 'invalid-boolean' };
+        }
+        case 'datetime': {
+            const iso = parseDatetime(raw);
+            return iso === null
+                ? { ok: false, code: 'invalid-datetime' }
+                : { ok: true, value: iso };
+        }
+        case 'json': {
+            try {
+                return { ok: true, value: JSON.parse(raw) };
+            }
+            catch {
+                return { ok: false, code: 'invalid-json' };
+            }
+        }
+        case 'enum': {
+            const options = field.options ?? [];
+            const hit = options.find((o) => o.toLowerCase() === raw.toLowerCase());
+            return hit === undefined
+                ? { ok: false, code: 'invalid-enum', detail: options.join(', ') }
+                : { ok: true, value: hit };
+        }
+        case 'reference':
+            return /\s/.test(raw)
+                ? { ok: false, code: 'invalid-reference' }
+                : { ok: true, value: raw };
+        default: {
+            const text = restoreNeutralized(raw);
+            if (field.widget === 'email' && !EMAIL.test(text)) {
+                return { ok: false, code: 'invalid-email' };
+            }
+            if (field.widget === 'url') {
+                try {
+                    const url = new URL(text);
+                    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+                        return { ok: false, code: 'invalid-url' };
+                    }
+                }
+                catch {
+                    return { ok: false, code: 'invalid-url' };
+                }
+            }
+            return { ok: true, value: text };
+        }
+    }
+}
+/** Mapping-level problems: two columns on one field, or a required field with no source. */
+export function validateMapping(headers, mapping, fields) {
+    const issues = [];
+    const seen = new Map();
+    mapping.forEach((target, index) => {
+        if (target === null)
+            return;
+        if (seen.has(target)) {
+            issues.push({
+                code: 'duplicate-mapping',
+                line: 0,
+                field: target,
+                column: headers[index],
+            });
+        }
+        seen.set(target, index);
+    });
+    for (const field of fields) {
+        if (field.required &&
+            field.importable &&
+            !field.hasDefault &&
+            !seen.has(field.name)) {
+            issues.push({ code: 'unmapped-required', line: 0, field: field.name });
+        }
+    }
+    return issues;
+}
+function echo(value) {
+    return value.length > MAX_ECHOED_VALUE
+        ? `${value.slice(0, MAX_ECHOED_VALUE)}…`
+        : value;
+}
+/**
+ * Validate and coerce every row against the mapped fields. Pure: this is the
+ * dry run, nothing is written. A row with any issue is excluded from
+ * `records`; `invalidRows` counts it once however many issues it has. While
+ * `mappingIssues` is non-empty `records` is empty.
+ */
+export function validateRows(input) {
+    const { headers, rows, mapping, fields } = input;
+    const maxIssues = input.maxIssues ?? 1000;
+    const byName = new Map(fields.map((f) => [f.name, f]));
+    const mappingIssues = validateMapping(headers, mapping, fields);
+    const blocked = new Set(mappingIssues
+        .filter((i) => i.code === 'duplicate-mapping')
+        .map((i) => i.field));
+    const columns = [];
+    mapping.forEach((target, index) => {
+        const field = target === null ? undefined : byName.get(target);
+        if (field?.importable && !blocked.has(field.name)) {
+            columns.push({ index, field });
+        }
+    });
+    const mappedNames = new Set(columns.map((c) => c.field.name));
+    const records = [];
+    const issues = [];
+    let issuesTruncated = false;
+    let invalidRows = 0;
+    const unique = new Map();
+    for (const field of fields)
+        if (field.unique)
+            unique.set(field.name, new Set());
+    rows.forEach((row, index) => {
+        const line = input.lines?.[index] ?? index + 2;
+        const rowIssues = [];
+        const values = {};
+        const pendingUnique = [];
+        if (row.length > headers.length) {
+            rowIssues.push({
+                code: 'extra-cells',
+                line,
+                detail: `${row.length} cells, ${headers.length} columns`,
+            });
+        }
+        for (const { index: col, field } of columns) {
+            const raw = (row[col] ?? '').trim();
+            if (raw === '')
+                continue;
+            const result = coerceCell(raw, field);
+            if (!result.ok) {
+                rowIssues.push({
+                    code: result.code,
+                    line,
+                    field: field.name,
+                    column: headers[col],
+                    value: echo(raw),
+                    detail: result.detail,
+                });
+                continue;
+            }
+            if (field.unique) {
+                const key = JSON.stringify(result.value);
+                const set = unique.get(field.name);
+                if (set?.has(key)) {
+                    rowIssues.push({
+                        code: 'duplicate-value',
+                        line,
+                        field: field.name,
+                        column: headers[col],
+                        value: echo(raw),
+                    });
+                    continue;
+                }
+                if (set)
+                    pendingUnique.push([set, key]);
+            }
+            values[field.name] = result.value;
+        }
+        for (const field of fields) {
+            // Only importable and org-locked fields take a default; hidden, tenant
+            // and system fields never enter the payload.
+            if (!(field.name in values) &&
+                field.hasDefault &&
+                (field.importable || field.locked === true)) {
+                values[field.name] = field.defaultValue;
+            }
+            if (field.required && field.importable && !(field.name in values)) {
+                const mappedColumn = columns.find((c) => c.field.name === field.name);
+                // An unmapped required field is a mapping issue, reported once.
+                if (mappedNames.has(field.name)) {
+                    rowIssues.push({
+                        code: 'required',
+                        line,
+                        field: field.name,
+                        column: mappedColumn ? headers[mappedColumn.index] : undefined,
+                    });
+                }
+            }
+        }
+        if (rowIssues.length > 0) {
+            invalidRows++;
+            for (const issue of rowIssues) {
+                if (issues.length < maxIssues)
+                    issues.push(issue);
+                else
+                    issuesTruncated = true;
+            }
+        }
+        else {
+            for (const [set, key] of pendingUnique)
+                set.add(key);
+            records.push({ index, line, values });
+        }
+    });
+    return {
+        totalRows: rows.length,
+        // Nothing is importable until the mapping itself is sound: an unmapped
+        // required field would otherwise be written without its value.
+        records: mappingIssues.length > 0 ? [] : records,
+        issues,
+        issuesTruncated,
+        mappingIssues,
+        invalidRows,
+    };
+}