@navette-js/panels 1.0.0-beta.3 → 1.0.0-beta.4

package/THIRD-PARTY-NOTICES.md

@@ -4,7 +4,7 @@ Navette is an independent project, not affiliated with or endorsed by the Filame
 
 | Work | Used for | License | License file |
 |---|---|---|---|
-| [Filament](https://github.com/filamentphp/filament) © Filament | HTML markup derived from its Blade views, compiled CSS and JavaScript (`@navette-js/panels/dist/filament`), English translations (`@navette-js/support/data`) | MIT | `packages/panels/dist/FILAMENT-LICENSE.md` |
+| [Filament](https://github.com/filamentphp/filament) © Filament | HTML markup derived from its Blade views, compiled CSS and JavaScript (`@navette-js/panels/dist/filament`), English translations (`@navette-js/support/data`), image editor icons (`@navette-js/support/icons/filament`) | MIT | `packages/panels/dist/FILAMENT-LICENSE.md`, `packages/support/icons/filament/LICENSE.md` |
 | [Livewire](https://github.com/livewire/livewire) © Caleb Porzio | Client script `livewire.js` (`@navette-js/wire/vendor`); the server runtime follows its protocol | MIT | `packages/wire/vendor/LIVEWIRE-LICENSE.md` |
 | [Heroicons](https://github.com/tailwindlabs/heroicons) | SVG icons (`@navette-js/support/icons`) | MIT | `packages/support/icons/HEROICONS-LICENSE.md` |
 | [Inter](https://github.com/rsms/inter) © The Inter Project Authors | Default font files (`@navette-js/panels/dist/filament/fonts`) | SIL Open Font License 1.1 | `packages/panels/dist/filament/fonts/INTER-LICENSE.txt` |

package/lib/import-export.d.ts

@@ -0,0 +1,142 @@
+import { Action } from '@navette-js/actions';
+type StoredFile = {
+    owner: string;
+    name: string;
+    type: string;
+    content: Buffer;
+    expires: number;
+};
+/**
+ * Files offered for download to one user (exports, failed import rows), kept in memory for a limited time. They are lost
+ * when the process restarts and are not shared between processes.
+ */
+export declare class DownloadStore {
+    private files;
+    private readonly ttl;
+    private readonly maxFiles;
+    constructor(options?: {
+        ttl?: number;
+        maxFiles?: number;
+    });
+    /** Stores a file for a user and returns its token (part of the download URL). */
+    put(owner: string | number, name: string, type: string, content: string | Buffer): string;
+    /** The file of a token, only for the user who created it. */
+    get(token: string, owner: string | number): StoredFile | null;
+}
+/**
+ * A CSV cell. Text starting with `=`, `+`, `-`, `@`, a tab or a carriage return is prefixed with `'`, so that spreadsheet
+ * software does not run it as a formula (CSV injection).
+ */
+export declare function csvCell(value: unknown): string;
+export declare const csvLine: (cells: unknown[]) => string;
+/** Parses CSV text (quoted cells, doubled quotes, line breaks inside quotes). */
+export declare function parseCsv(text: string, maxRows?: number): string[][];
+/** Column of an export: its header and the value written for each record. */
+export declare class ExportColumn {
+    readonly name: string;
+    private _label;
+    private _state;
+    private _format;
+    private _enabledByDefault;
+    constructor(name: string);
+    static make(name: string): ExportColumn;
+    label(label: string | null): this;
+    getLabel(): string;
+    /** Value from the record, instead of the attribute with the column's name (dots read relationships: `author.name`). */
+    state(resolver: ((record: any) => unknown) | null): this;
+    formatStateUsing(format: ((state: unknown, record: any) => unknown) | null): this;
+    /** `false`: unchecked in the export modal. */
+    enabledByDefault(condition?: boolean): this;
+    isEnabledByDefault(): boolean;
+    getValue(record: any): unknown;
+}
+/** Describes an export: its columns, and optionally the query and the notification. */
+export declare abstract class Exporter {
+    static getColumns(): ExportColumn[];
+    /** Changes the query of the exported records (e.g. eager loading). */
+    static modifyQuery(_query: any): void;
+    /** Body of the "Export completed" notification. */
+    static getCompletedNotificationBody(count: number): string;
+    /** File name, without extension. */
+    static getFileName(_count: number): string;
+}
+export type ExportActionInstance = Action & {
+    exporter(exporter: typeof Exporter): ExportActionInstance;
+    /** Refuses exports of more rows (10,000 by default, 100,000 at most). */
+    maxRows(count: number): ExportActionInstance;
+    /** `false`: no column selection, every column is exported (the modal only confirms). */
+    columnMapping(condition: boolean): ExportActionInstance;
+    /** Files offered for download: `['csv', 'xlsx']` (both by default). */
+    formats(formats: ('csv' | 'xlsx')[]): ExportActionInstance;
+};
+/** Exports the records of the table (with its filters, search and sort) to a CSV file. */
+export declare class ExportAction {
+    static make(name?: string): ExportActionInstance;
+}
+/** Exports the selected records to a CSV file. */
+export declare class ExportBulkAction {
+    static make(name?: string): ExportActionInstance;
+}
+type ImportRule = string | ((value: unknown, row: Record<string, unknown>) => string | null);
+/** Column of an import: the file column it is read from, its validation and how the value is cast. */
+export declare class ImportColumn {
+    readonly name: string;
+    private _label;
+    private _guesses;
+    private _required;
+    private _rules;
+    private _cast;
+    private _example;
+    private _fill;
+    constructor(name: string);
+    static make(name: string): ImportColumn;
+    label(label: string | null): this;
+    getLabel(): string;
+    /** Other file headers that map to this column (compared case-insensitively). */
+    guess(headers: string[]): this;
+    /** The file must contain this column. */
+    requiredMapping(condition?: boolean): this;
+    isMappingRequired(): boolean;
+    /** `required`, `email`, `numeric`, `integer`, `boolean`, `min:n`, `max:n`, `in:a,b`, or a function returning an error message. */
+    rules(rules: ImportRule[]): this;
+    /** Converts the text of the cell before it is saved. */
+    castStateUsing(cast: ((value: string | null) => unknown) | null): this;
+    numeric(): this;
+    boolean(): this;
+    /** Value written in the example file. */
+    example(value: string | null): this;
+    getExample(): string;
+    /** Writes the value into the record yourself, instead of the attribute with the column's name. */
+    fillRecordUsing(fill: ((record: Record<string, unknown>, value: unknown) => void) | null): this;
+    matches(header: string): boolean;
+    validate(value: string | null, row: Record<string, unknown>): string | null;
+    cast(value: string | null): unknown;
+    fill(record: Record<string, unknown>, value: unknown): void;
+}
+/** Describes an import: its columns, how a row finds or creates its record, and hooks. */
+export declare abstract class Importer {
+    static getColumns(): ImportColumn[];
+    /**
+     * Existing record a row updates, or `null` to create one (the default). For example, find a product by its SKU with the
+     * data adapter. Only return records the user may change.
+     */
+    static resolveRecord(_data: Record<string, unknown>, _ctx: {
+        livewire: any;
+    }): Promise<any | null>;
+    /** Runs before a record is saved; `data` may be changed. */
+    static beforeSave(_data: Record<string, unknown>, _record: any | null): Promise<void>;
+    static afterSave(_record: any): Promise<void>;
+    static getCompletedNotificationBody(imported: number, failed: number): string;
+}
+export type ImportActionInstance = Action & {
+    importer(importer: typeof Importer): ImportActionInstance;
+    /** Refuses files with more rows (1,000 by default, 10,000 at most). */
+    maxRows(count: number): ImportActionInstance;
+    /** Largest accepted file, in kilobytes (5,120 by default). */
+    maxFileSize(kilobytes: number): ImportActionInstance;
+};
+/** Imports the rows of a CSV file: each row is validated, then creates or updates a record through the data adapter. */
+export declare class ImportAction {
+    static make(name?: string): ImportActionInstance;
+}
+export {};

package/lib/import-export.js

@@ -0,0 +1,370 @@
+// Import and export actions: CSV files read and written during the request (no queue), and a per-user download store.
+import { buildXlsx } from "./xlsx.js";
+import { randomBytes } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { Action } from '@navette-js/actions';
+import { CheckboxList, FileUpload } from '@navette-js/forms';
+import { configured } from '@navette-js/support';
+import { t, tc } from '@navette-js/support/i18n';
+import { getTableQuery } from '@navette-js/tables';
+import { Notification } from "./notifications.js";
+/**
+ * Files offered for download to one user (exports, failed import rows), kept in memory for a limited time. They are lost
+ * when the process restarts and are not shared between processes.
+ */
+export class DownloadStore {
+    files = new Map();
+    ttl;
+    maxFiles;
+    constructor(options = {}) { this.ttl = options.ttl ?? 24 * 60 * 60 * 1000; this.maxFiles = options.maxFiles ?? 500; }
+    /** Stores a file for a user and returns its token (part of the download URL). */
+    put(owner, name, type, content) {
+        const now = Date.now();
+        for (const [token, file] of this.files)
+            if (file.expires < now)
+                this.files.delete(token);
+        while (this.files.size >= this.maxFiles)
+            this.files.delete(this.files.keys().next().value);
+        const token = randomBytes(24).toString('base64url');
+        this.files.set(token, { owner: String(owner), name, type, content: Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8'), expires: now + this.ttl });
+        return token;
+    }
+    /** The file of a token, only for the user who created it. */
+    get(token, owner) {
+        const file = this.files.get(token);
+        if (!file || file.expires < Date.now() || file.owner !== String(owner))
+            return null;
+        return file;
+    }
+}
+// ------------------------------------------------------------------ CSV
+/**
+ * A CSV cell. Text starting with `=`, `+`, `-`, `@`, a tab or a carriage return is prefixed with `'`, so that spreadsheet
+ * software does not run it as a formula (CSV injection).
+ */
+export function csvCell(value) {
+    let text = value === null || value === undefined ? '' : value instanceof Date ? value.toISOString() : String(value);
+    if (/^[=+\-@\t\r]/.test(text) && !/^-?\d+(\.\d+)?$/.test(text))
+        text = `'${text}`;
+    return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+export const csvLine = (cells) => cells.map(csvCell).join(',');
+/** Parses CSV text (quoted cells, doubled quotes, line breaks inside quotes). */
+export function parseCsv(text, maxRows = Infinity) {
+    const rows = [];
+    let row = [], cell = '', quoted = false;
+    const source = text.replace(/^/, '');
+    for (let index = 0; index < source.length; index++) {
+        const char = source[index];
+        if (quoted) {
+            if (char === '"' && source[index + 1] === '"') {
+                cell += '"';
+                index++;
+            }
+            else if (char === '"')
+                quoted = false;
+            else
+                cell += char;
+            continue;
+        }
+        if (char === '"')
+            quoted = true;
+        else if (char === ',') {
+            row.push(cell);
+            cell = '';
+        }
+        else if (char === '\n' || char === '\r') {
+            if (char === '\r' && source[index + 1] === '\n')
+                index++;
+            row.push(cell);
+            cell = '';
+            if (row.some((value) => value !== ''))
+                rows.push(row);
+            row = [];
+            if (rows.length > maxRows)
+                return rows;
+        }
+        else
+            cell += char;
+    }
+    row.push(cell);
+    if (row.some((value) => value !== ''))
+        rows.push(row);
+    return rows;
+}
+// ------------------------------------------------------------------ export
+/** Column of an export: its header and the value written for each record. */
+export class ExportColumn {
+    name;
+    _label = null;
+    _state = null;
+    _format = null;
+    _enabledByDefault = true;
+    constructor(name) { this.name = name; }
+    static make(name) { return configured(new ExportColumn(name)); }
+    label(label) { this._label = label; return this; }
+    getLabel() { return this._label ?? this.name.replace(/[_.]+/g, ' ').replace(/^./, (c) => c.toUpperCase()); }
+    /** Value from the record, instead of the attribute with the column's name (dots read relationships: `author.name`). */
+    state(resolver) { this._state = resolver; return this; }
+    formatStateUsing(format) { this._format = format; return this; }
+    /** `false`: unchecked in the export modal. */
+    enabledByDefault(condition = true) { this._enabledByDefault = condition; return this; }
+    isEnabledByDefault() { return this._enabledByDefault; }
+    getValue(record) {
+        const state = this._state ? this._state(record) : this.name.split('.').reduce((value, key) => (value === null || value === undefined ? value : value[key]), record);
+        return this._format ? this._format(state, record) : state;
+    }
+}
+/** Describes an export: its columns, and optionally the query and the notification. */
+export class Exporter {
+    static getColumns() { return []; }
+    /** Changes the query of the exported records (e.g. eager loading). */
+    static modifyQuery(_query) { }
+    /** Body of the "Export completed" notification. */
+    static getCompletedNotificationBody(count) { return `Your export has completed and ${count.toLocaleString('en-US')} ${count === 1 ? 'row' : 'rows'} exported.`; }
+    /** File name, without extension. */
+    static getFileName(_count) { return `export-${new Date().toISOString().slice(0, 10)}`; }
+}
+const DEFAULT_MAX_EXPORT_ROWS = 10000, HARD_MAX_EXPORT_ROWS = 100000, CHUNK = 1000;
+const fileNameOf = (name) => name.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 120) || 'export';
+function makeExportAction(name, bulk) {
+    let exporter = null, maxRows = DEFAULT_MAX_EXPORT_ROWS, mapping = true, formats = ['csv', 'xlsx'];
+    const columnsOf = () => { if (!exporter)
+        throw new Error('ExportAction: call exporter() with an Exporter class.'); return exporter.getColumns(); };
+    const action = Action.make(name).color('gray').icon('m-arrow-down-tray')
+        // Exporting reads the records: the resource's `viewAny` ability (or the host's own checks) applies.
+        .authorize(async ({ livewire }) => (typeof livewire?.resource?.can === 'function' ? livewire.resource.can('viewAny', livewire._ctx?.user ?? null) : true))
+        .label(({ livewire }) => t('filament-actions::export.label', { label: livewire?.resource?.getPluralModelLabel?.() ?? '' }).trim())
+        .modalHeading(({ livewire }) => t('filament-actions::export.modal.heading', { label: livewire?.resource?.getPluralModelLabel?.() ?? '' }).trim())
+        .modalSubmitActionLabel(t('filament-actions::export.modal.actions.export.label'))
+        .modalWidth('md')
+        .schema(() => (mapping ? [CheckboxList.make('columns').label(t('filament-actions::export.modal.form.columns.label')).options(columnsOf().map((column) => [column.name, column.getLabel()])).columns(2)] : []))
+        .fillForm(() => ({ columns: columnsOf().filter((column) => column.isEnabledByDefault()).map((column) => column.name) }))
+        .action(async ({ livewire, data }) => {
+        // Only declared columns are exported, whatever list the browser sends.
+        const requested = mapping ? (Array.isArray(data.columns) ? data.columns.map(String) : []) : columnsOf().map((column) => column.name);
+        const columns = columnsOf().filter((column) => requested.includes(column.name));
+        if (!columns.length) {
+            Notification.make().danger().title(t('filament-actions::export.notifications.no_columns.title')).body(t('filament-actions::export.notifications.no_columns.body')).send();
+            return;
+        }
+        const adapter = livewire.getDataAdapterForTable();
+        const table = livewire.getTable();
+        // The table's current query (filters, search, sort); a bulk export only takes the selected records.
+        const query = { ...getTableQuery(table, livewire), modifiers: [...(getTableQuery(table, livewire).modifiers ?? []), (q) => exporter.modifyQuery(q)] };
+        if (bulk)
+            query.keys = await livewire.getSelectedRecordKeys();
+        const first = await adapter.paginate({ ...query, page: 1, perPage: CHUNK });
+        const limit = Math.min(maxRows, HARD_MAX_EXPORT_ROWS);
+        if (first.total > limit) {
+            Notification.make().danger().title(t('filament-actions::export.notifications.max_rows.title')).body(tc('filament-actions::export.notifications.max_rows.body', limit, { count: limit.toLocaleString('en-US') })).send();
+            return;
+        }
+        const rows = [columns.map((column) => column.getLabel())];
+        for (let page = 1; page <= first.lastPage; page++) {
+            const { records } = page === 1 ? first : await adapter.paginate({ ...query, page, perPage: CHUNK });
+            for (const record of records)
+                rows.push(columns.map((column) => column.getValue(record)));
+        }
+        const count = rows.length - 1;
+        const user = livewire._ctx?.user;
+        const panel = livewire._ctx?.panel;
+        const fileName = fileNameOf(exporter.getFileName(count));
+        const links = [];
+        if (formats.includes('csv'))
+            links.push({ label: t('filament-actions::export.notifications.completed.actions.download_csv.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.csv`, 'text/csv; charset=utf-8', `\uFEFF${rows.map(csvLine).join('\r\n')}\r\n`)) });
+        if (formats.includes('xlsx'))
+            links.push({ label: t('filament-actions::export.notifications.completed.actions.download_xlsx.label'), url: panel.getDownloadUrl(panel.getDownloads().put(user.id, `${fileName}.xlsx`, 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', buildXlsx(rows))) });
+        Notification.make().success().persistent().title(t('filament-actions::export.notifications.completed.title')).body(exporter.getCompletedNotificationBody(count))
+            .actions(links).send();
+        if (bulk)
+            livewire.deselectAllTableRecords();
+    });
+    action.exporter = (value) => { exporter = value; return action; };
+    action.maxRows = (count) => { maxRows = Math.max(1, Math.floor(count)); return action; };
+    action.formats = (list) => { const allowed = list.filter((format) => format === 'csv' || format === 'xlsx'); if (!allowed.length)
+        throw new Error('ExportAction: formats() needs csv and/or xlsx.'); formats = [...new Set(allowed)]; return action; };
+    action.columnMapping = (condition) => { mapping = condition; if (!condition)
+        action.requiresConfirmation(); return action; };
+    return action;
+}
+/** Exports the records of the table (with its filters, search and sort) to a CSV file. */
+export class ExportAction {
+    static make(name = 'export') { return makeExportAction(name, false); }
+}
+/** Exports the selected records to a CSV file. */
+export class ExportBulkAction {
+    static make(name = 'export') { return makeExportAction(name, true); }
+}
+/** Column of an import: the file column it is read from, its validation and how the value is cast. */
+export class ImportColumn {
+    name;
+    _label = null;
+    _guesses = [];
+    _required = false;
+    _rules = [];
+    _cast = null;
+    _example = null;
+    _fill = null;
+    constructor(name) { this.name = name; }
+    static make(name) { return configured(new ImportColumn(name)); }
+    label(label) { this._label = label; return this; }
+    getLabel() { return this._label ?? this.name.replace(/[_.]+/g, ' ').replace(/^./, (c) => c.toUpperCase()); }
+    /** Other file headers that map to this column (compared case-insensitively). */
+    guess(headers) { this._guesses = headers; return this; }
+    /** The file must contain this column. */
+    requiredMapping(condition = true) { this._required = condition; return this; }
+    isMappingRequired() { return this._required; }
+    /** `required`, `email`, `numeric`, `integer`, `boolean`, `min:n`, `max:n`, `in:a,b`, or a function returning an error message. */
+    rules(rules) { this._rules = rules; return this; }
+    /** Converts the text of the cell before it is saved. */
+    castStateUsing(cast) { this._cast = cast; return this; }
+    numeric() { return this.castStateUsing((value) => (value === null || value === '' ? null : Number(value))); }
+    boolean() { return this.castStateUsing((value) => (value === null || value === '' ? null : ['1', 'true', 'yes', 'y', 'on'].includes(value.toLowerCase()) ? 1 : 0)); }
+    /** Value written in the example file. */
+    example(value) { this._example = value; return this; }
+    getExample() { return this._example ?? ''; }
+    /** Writes the value into the record yourself, instead of the attribute with the column's name. */
+    fillRecordUsing(fill) { this._fill = fill; return this; }
+    matches(header) { const normalized = header.trim().toLowerCase(); return [this.name, this.getLabel(), ...this._guesses].some((candidate) => candidate.toLowerCase() === normalized); }
+    validate(value, row) {
+        const label = this.getLabel().toLowerCase();
+        const blank = value === null || value.trim() === '';
+        for (const rule of this._rules) {
+            if (typeof rule === 'function') {
+                const message = rule(value, row);
+                if (message)
+                    return message;
+                continue;
+            }
+            const [name, parameter = ''] = rule.split(':');
+            if (name === 'required' && blank)
+                return `The ${label} field is required.`;
+            if (blank)
+                continue;
+            const text = value.trim();
+            if (name === 'email' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(text))
+                return `The ${label} field must be a valid email address.`;
+            if (name === 'numeric' && !Number.isFinite(Number(text)))
+                return `The ${label} field must be a number.`;
+            if (name === 'integer' && !/^-?\d+$/.test(text))
+                return `The ${label} field must be an integer.`;
+            if (name === 'boolean' && !['0', '1', 'true', 'false', 'yes', 'no'].includes(text.toLowerCase()))
+                return `The ${label} field must be true or false.`;
+            if (name === 'max' && text.length > Number(parameter))
+                return `The ${label} field must not be greater than ${parameter} characters.`;
+            if (name === 'min' && text.length < Number(parameter))
+                return `The ${label} field must be at least ${parameter} characters.`;
+            if (name === 'in' && !parameter.split(',').includes(text))
+                return `The selected ${label} is invalid.`;
+        }
+        return null;
+    }
+    cast(value) { return this._cast ? this._cast(value) : value === '' ? null : value; }
+    fill(record, value) { if (this._fill)
+        this._fill(record, value);
+    else
+        record[this.name] = value; }
+}
+/** Describes an import: its columns, how a row finds or creates its record, and hooks. */
+export class Importer {
+    static getColumns() { return []; }
+    /**
+     * Existing record a row updates, or `null` to create one (the default). For example, find a product by its SKU with the
+     * data adapter. Only return records the user may change.
+     */
+    static async resolveRecord(_data, _ctx) { return null; }
+    /** Runs before a record is saved; `data` may be changed. */
+    static async beforeSave(_data, _record) { }
+    static async afterSave(_record) { }
+    static getCompletedNotificationBody(imported, failed) {
+        return `Your import has completed and ${imported.toLocaleString('en-US')} ${imported === 1 ? 'row' : 'rows'} imported.${failed ? ` ${failed.toLocaleString('en-US')} ${failed === 1 ? 'row' : 'rows'} failed to import.` : ''}`;
+    }
+}
+const DEFAULT_MAX_IMPORT_ROWS = 1000, HARD_MAX_IMPORT_ROWS = 10000;
+/** Imports the rows of a CSV file: each row is validated, then creates or updates a record through the data adapter. */
+export class ImportAction {
+    static make(name = 'import') {
+        let importer = null, maxRows = DEFAULT_MAX_IMPORT_ROWS, maxKilobytes = 5120;
+        const columnsOf = () => { if (!importer)
+            throw new Error('ImportAction: call importer() with an Importer class.'); return importer.getColumns(); };
+        const example = Action.make('downloadExample').label(t('filament-actions::import.modal.actions.download_example.label')).color('gray').link()
+            .action(({ livewire }) => {
+            const columns = columnsOf();
+            const csv = `${csvLine(columns.map((column) => column.name))}\r\n${csvLine(columns.map((column) => column.getExample()))}\r\n`;
+            const panel = livewire._ctx?.panel;
+            livewire.redirect(panel.getDownloadUrl(panel.getDownloads().put(livewire._ctx.user.id, 'import-example.csv', 'text/csv; charset=utf-8', csv)));
+        });
+        const action = Action.make(name).color('gray').icon('m-arrow-up-tray')
+            // Importing creates or updates records: the resource's `create` ability applies.
+            .authorize(async ({ livewire }) => (typeof livewire?.resource?.can === 'function' ? livewire.resource.can('create', livewire._ctx?.user ?? null) : true))
+            .label(({ livewire }) => t('filament-actions::import.label', { label: livewire?.resource?.getPluralModelLabel?.() ?? '' }).trim())
+            .modalHeading(({ livewire }) => t('filament-actions::import.modal.heading', { label: livewire?.resource?.getPluralModelLabel?.() ?? '' }).trim())
+            .modalSubmitActionLabel(t('filament-actions::import.modal.actions.import.label'))
+            .modalWidth('md')
+            .schema(() => [FileUpload.make('file').label(t('filament-actions::import.modal.form.file.label')).acceptedFileTypes(['text/csv', 'text/plain', 'application/vnd.ms-excel', '.csv']).maxSize(maxKilobytes).storeFiles(false).required()])
+            .extraModalFooterActions([example])
+            .action(async ({ livewire, data }) => {
+            const entry = Array.isArray(data.file) ? data.file[0] : data.file;
+            const path = entry?.file?.path;
+            // Only a temporary upload of this request is read, never a path sent by the browser.
+            if (typeof path !== 'string' || statSync(path).size > maxKilobytes * 1024)
+                return;
+            const limit = Math.min(maxRows, HARD_MAX_IMPORT_ROWS);
+            const rows = parseCsv(readFileSync(path, 'utf8'), limit + 1);
+            const header = rows.shift() ?? [];
+            if (rows.length > limit) {
+                Notification.make().danger().title(t('filament-actions::import.notifications.max_rows.title')).body(tc('filament-actions::import.notifications.max_rows.body', limit, { count: limit.toLocaleString('en-US') })).send();
+                return;
+            }
+            const columns = columnsOf();
+            const mapping = new Map(columns.map((column) => [column, header.findIndex((cell) => column.matches(cell))]));
+            const missing = columns.filter((column) => column.isMappingRequired() && mapping.get(column) === -1);
+            if (missing.length) {
+                Notification.make().danger().title(t('filament-actions::import.notifications.completed.title'))
+                    .body(missing.map((column) => t('filament-actions::import.failure_csv.column_mapping_required_for_new_record', { attribute: column.getLabel() })).join(' ')).send();
+                return;
+            }
+            const adapter = livewire.getDataAdapterForTable();
+            let imported = 0;
+            const failures = [];
+            for (const cells of rows) {
+                const raw = {};
+                for (const [column, index] of mapping)
+                    raw[column.name] = index === -1 ? null : (cells[index] ?? null);
+                const error = columns.map((column) => (mapping.get(column) === -1 ? null : column.validate(raw[column.name], raw))).find((message) => message !== null);
+                if (error) {
+                    failures.push(csvLine([...cells, error]));
+                    continue;
+                }
+                try {
+                    const record = await importer.resolveRecord(raw, { livewire });
+                    const values = {};
+                    for (const column of columns)
+                        if (mapping.get(column) !== -1)
+                            column.fill(values, column.cast(raw[column.name]));
+                    await importer.beforeSave(values, record);
+                    const saved = record ? await adapter.update(adapter.getKey(record), values) : await adapter.create(values);
+                    await importer.afterSave(saved);
+                    imported++;
+                }
+                catch (failure) {
+                    console.error(failure);
+                    failures.push(csvLine([...cells, t('filament-actions::import.failure_csv.system_error')]));
+                }
+            }
+            const notification = Notification.make().title(t('filament-actions::import.notifications.completed.title')).body(importer.getCompletedNotificationBody(imported, failures.length)).persistent();
+            if (failures.length) {
+                const panel = livewire._ctx?.panel;
+                const csv = `${[csvLine([...header, t('filament-actions::import.failure_csv.error_header')]), ...failures].join('\r\n')}\r\n`;
+                const token = panel.getDownloads().put(livewire._ctx.user.id, 'import-failed-rows.csv', 'text/csv; charset=utf-8', csv);
+                notification.actions([{ label: tc('filament-actions::import.notifications.completed.actions.download_failed_rows_csv.label', failures.length), url: panel.getDownloadUrl(token) }]);
+            }
+            (imported ? (failures.length ? notification.warning() : notification.success()) : notification.danger()).send();
+        });
+        action.importer = (value) => { importer = value; return action; };
+        action.maxRows = (count) => { maxRows = Math.max(1, Math.floor(count)); return action; };
+        action.maxFileSize = (kilobytes) => { maxKilobytes = Math.max(1, Math.floor(kilobytes)); return action; };
+        return action;
+    }
+}