shutro-erp 0.2.0 → 0.3.0

package/dist/import/web/ImportWizard.js

@@ -0,0 +1,217 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The import screen (RFC 0014 §5.8): three steps in a wide dialog. The file (with a sample workbook to start from);
+ * the columns (each with its first values and the field it fills, the mode and key, what to do with errors, saved
+ * mappings); the result (counts, the errors with their row and column, the rejected rows, undo). Large files run
+ * in the background and the dialog follows their progress. The server reads, converts and checks everything; the
+ * screen only shows what it says.
+ */
+import { Alert, ApiError, Button, Checkbox, Dialog, Input, Label, Select, } from '../../ui/index.js';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { Download, Save, Undo2, Upload } from 'lucide-react';
+import { useId, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const ACCEPT = '.csv,.xlsx,text/csv,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+const SKIP = '__skip';
+function saveFile(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+}
+const message = (error) => (error instanceof ApiError ? error.message : String(error));
+const cell = (value) => value === null || value === undefined ? '' : typeof value === 'string' ? value : String(value);
+export function ImportWizard({ api, model, open, onOpenChange, }) {
+    const { t } = useTranslation('import');
+    const id = useId();
+    const queryClient = useQueryClient();
+    const [file, setFile] = useState(null);
+    const [session, setSession] = useState(null);
+    const [step, setStep] = useState('file');
+    const [errorColumn, setErrorColumn] = useState('all');
+    const [mappingName, setMappingName] = useState('');
+    const [share, setShare] = useState(false);
+    const [savedName, setSavedName] = useState(null);
+    const [undone, setUndone] = useState(null);
+    const mappings = useQuery({
+        queryKey: ['import', 'mappings', model],
+        queryFn: () => api.call('GET', `/api/v1/import-mappings?model=${encodeURIComponent(model)}`),
+        enabled: open,
+    });
+    // A background run: follow it until it ends.
+    const running = session?.state === 'running';
+    useQuery({
+        queryKey: ['import', 'session', session?.id],
+        queryFn: async () => {
+            const next = await api.call('GET', `/api/v1/imports/${session?.id}`);
+            setSession(next);
+            if (next.state !== 'running') {
+                setStep('result');
+                if (next.state === 'done')
+                    void queryClient.invalidateQueries();
+            }
+            return next;
+        },
+        enabled: running,
+        refetchInterval: running ? 1000 : false,
+    });
+    const reset = () => {
+        setFile(null);
+        setSession(null);
+        setStep('file');
+        setUndone(null);
+        setErrorColumn('all');
+    };
+    const upload = useMutation({
+        mutationFn: (chosen) => api.upload(`/api/v1/imports?model=${encodeURIComponent(model)}`, chosen, chosen.name),
+        onSuccess: (created) => {
+            setSession(created);
+            setStep('columns');
+        },
+    });
+    const map = useMutation({
+        mutationFn: (change) => api.call('PUT', `/api/v1/imports/${session?.id}/mapping`, {
+            columns: (change.columns ?? session?.columns ?? []).map((c) => ({
+                index: c.index,
+                field: c.field,
+            })),
+            options: change.options ?? session?.options ?? {},
+        }),
+        onSuccess: setSession,
+    });
+    const apply = useMutation({
+        mutationFn: (mapping) => api.call('POST', `/api/v1/imports/${session?.id}/apply-mapping`, { mapping }),
+        onSuccess: setSession,
+    });
+    const save = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/imports/${session?.id}/save-mapping`, {
+            name: mappingName.trim(),
+            shared: share,
+        }),
+        onSuccess: () => {
+            setSavedName(mappingName.trim());
+            setMappingName('');
+            void mappings.refetch();
+        },
+    });
+    const run = useMutation({
+        mutationFn: async (dry) => {
+            const path = `/api/v1/imports/${session?.id}/${dry ? 'dry-run' : 'commit'}`;
+            try {
+                return { dry, answer: await api.call('POST', path, {}) };
+            }
+            catch (error) {
+                // A commit that stopped on errors answers 422 with its result.
+                if (error instanceof ApiError && error.status === 422 && !dry) {
+                    const again = await api.call('GET', `/api/v1/imports/${session?.id}`);
+                    return { dry, answer: again };
+                }
+                throw error;
+            }
+        },
+        onSuccess: ({ answer }) => {
+            if ('state' in answer) {
+                setSession(answer);
+                if (answer.state !== 'running')
+                    setStep('result');
+                return;
+            }
+            void api.call('GET', `/api/v1/imports/${session?.id}`).then((next) => {
+                setSession(next);
+                setStep('result');
+                if (next.state === 'done')
+                    void queryClient.invalidateQueries();
+            });
+        },
+    });
+    const undo = useMutation({
+        mutationFn: () => api.call('POST', `/api/v1/imports/${session?.id}/undo`, {}),
+        onSuccess: async (result) => {
+            setUndone(result);
+            setSession(await api.call('GET', `/api/v1/imports/${session?.id}`));
+            void queryClient.invalidateQueries();
+        },
+    });
+    const download = useMutation({
+        mutationFn: async (path) => {
+            const { blob, filename } = await api.download(path, undefined, 'GET');
+            saveFile(blob, filename);
+        },
+    });
+    const fields = session?.fields ?? [];
+    const mapped = new Set((session?.columns ?? []).flatMap((c) => (c.field === null ? [] : [c.field])));
+    const options = session?.options ?? {};
+    const mode = options.mode ?? 'create';
+    const missing = mode === 'create'
+        ? fields.filter((f) => f.required && f.line === undefined && !mapped.has(f.key))
+        : [];
+    const keyChoices = fields.filter((f) => f.keyable && mapped.has(f.key));
+    const needsKey = mode !== 'create' && (options.key === undefined || !mapped.has(options.key));
+    const result = session?.result ?? null;
+    const fieldOptions = [
+        { value: SKIP, label: t('skip') },
+        ...fields.map((f) => ({
+            value: f.key,
+            label: `${f.line === undefined ? '' : `${t('lineFields')}: `}${f.label}${f.required ? ` (${t('required')})` : ''}`,
+        })),
+    ];
+    const setOption = (change) => map.mutate({
+        options: Object.fromEntries(Object.entries({ ...options, ...change }).filter(([, v]) => v !== undefined)),
+    });
+    const busy = map.isPending || apply.isPending || run.isPending;
+    const error = upload.error ?? map.error ?? apply.error ?? run.error ?? save.error ?? undo.error;
+    const shownErrors = (result?.errors ?? []).filter((e) => errorColumn === 'all' ||
+        (errorColumn === 'row' ? e.column === null : String(e.column) === errorColumn));
+    const footer = step === 'file' ? (_jsxs(Button, { variant: "primary", busy: upload.isPending, disabled: file === null, onClick: () => file !== null && upload.mutate(file), children: [_jsx(Upload, { "aria-hidden": true }), t('upload')] })) : step === 'columns' ? (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "ghost", disabled: busy || running, onClick: reset, children: t('back') }), _jsx(Button, { disabled: busy || running || missing.length > 0 || needsKey, busy: run.isPending && run.variables === true, onClick: () => run.mutate(true), children: t('check') }), _jsx(Button, { variant: "primary", disabled: busy || running || missing.length > 0 || needsKey, busy: run.isPending && run.variables === false, onClick: () => run.mutate(false), children: t('run') })] })) : (_jsxs(_Fragment, { children: [session?.state === 'draft' ? (_jsx(Button, { variant: "ghost", onClick: () => setStep('columns'), children: t('back') })) : null, _jsx(Button, { onClick: reset, children: t('another') }), _jsx(Button, { variant: "primary", onClick: () => {
+                    onOpenChange(false);
+                    reset();
+                }, children: t('done') })] }));
+    return (_jsx(Dialog, { open: open, onOpenChange: (next) => {
+            onOpenChange(next);
+            if (!next && !running)
+                reset();
+        }, title: t('title'), description: t('intro'), wide: true, footer: footer, children: _jsxs("div", { className: "space-y-4", children: [_jsx("ol", { className: "flex gap-4 text-sm", "aria-label": t('title'), children: ['file', 'columns', 'result'].map((s, i) => (_jsxs("li", { "aria-current": step === s ? 'step' : undefined, className: step === s ? 'font-semibold text-foreground' : 'text-muted-foreground', children: [i + 1, ". ", t(`step${s[0]?.toUpperCase()}${s.slice(1)}`)] }, s))) }), error === null ? null : _jsx(Alert, { children: message(error) }), step === 'file' ? (_jsxs("div", { className: "space-y-3", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-file`, children: t('chooseFile') }), _jsx("input", { id: `${id}-file`, type: "file", accept: ACCEPT, className: "block w-full text-sm", onChange: (e) => setFile(e.target.files?.[0] ?? null) })] }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsxs(Button, { size: "sm", variant: "ghost", busy: download.isPending, onClick: () => download.mutate(`/api/v1/import-templates/${encodeURIComponent(model)}`), children: [_jsx(Download, { "aria-hidden": true }), t('template')] }), (mappings.data?.mappings ?? [])
+                                    .filter((m) => m.template)
+                                    .map((m) => (_jsxs(Button, { size: "sm", variant: "ghost", onClick: () => download.mutate(`/api/v1/import-templates/${encodeURIComponent(model)}?mapping=${encodeURIComponent(m.id)}`), children: [_jsx(Download, { "aria-hidden": true }), t('templateOf', { name: m.name })] }, m.id)))] })] })) : null, step === 'columns' && session !== null ? (_jsxs("div", { className: "space-y-4", children: [_jsxs("p", { className: "text-sm text-muted-foreground", children: [session.fileName, " \u00B7 ", t('rows', { count: session.rowCount })] }), session.applied ? (_jsx(Alert, { tone: "info", children: t('applied', { name: session.applied.name }) })) : null, session.background ? _jsx(Alert, { tone: "info", children: t('background') }) : null, running ? (_jsx(Alert, { tone: "info", children: session.progress === null || session.progress.done === 0
+                                ? t('queued')
+                                : t('running', session.progress) })) : null, _jsx("div", { className: "overflow-x-auto", children: _jsxs("table", { className: "w-full text-sm", children: [_jsx("thead", { children: _jsxs("tr", { className: "border-b text-start text-muted-foreground", children: [_jsx("th", { className: "py-1.5 pe-3 text-start font-medium", children: t('column') }), _jsx("th", { className: "py-1.5 pe-3 text-start font-medium", children: t('sample') }), _jsx("th", { className: "py-1.5 text-start font-medium", children: t('field') })] }) }), _jsx("tbody", { children: session.columns.map((c) => (_jsxs("tr", { className: "border-b last:border-0", children: [_jsx("td", { className: "py-1.5 pe-3 font-medium", children: session.headers[c.index] ?? '' }), _jsx("td", { className: "max-w-48 truncate py-1.5 pe-3 text-muted-foreground", children: session.sample
+                                                        .slice(0, 2)
+                                                        .map((r) => cell(r[c.index]))
+                                                        .filter((v) => v !== '')
+                                                        .join(' · ') }), _jsx("td", { className: "py-1.5", children: _jsx(Select, { label: `${t('field')}: ${session.headers[c.index] ?? ''}`, value: c.field ?? SKIP, options: fieldOptions, disabled: busy || running, onChange: (value) => map.mutate({
+                                                            columns: session.columns.map((other) => other.index === c.index
+                                                                ? { ...other, field: value === SKIP ? null : value }
+                                                                : value !== SKIP && other.field === value
+                                                                    ? { ...other, field: null }
+                                                                    : other),
+                                                        }) }) })] }, c.index))) })] }) }), missing.length > 0 ? (_jsx(Alert, { tone: "warning", children: t('missing', { fields: missing.map((f) => f.label).join(', ') }) })) : null, _jsxs("div", { className: "grid gap-3 sm:grid-cols-2", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-mode`, children: t('mode') }), _jsx(Select, { id: `${id}-mode`, value: mode, disabled: busy || running, options: [
+                                                { value: 'create', label: t('modeCreate') },
+                                                { value: 'update', label: t('modeUpdate') },
+                                                { value: 'upsert', label: t('modeUpsert') },
+                                            ], onChange: (value) => setOption({ mode: value }) })] }), mode === 'create' && options.key !== 'externalId' ? null : (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-key`, children: t('key') }), _jsx(Select, { id: `${id}-key`, value: options.key ?? null, placeholder: t('noKey'), disabled: busy || running, options: keyChoices.map((f) => ({ value: f.key, label: f.label })), onChange: (value) => setOption({ key: value }) })] })), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-errors`, children: t('onError') }), _jsx(Select, { id: `${id}-errors`, value: options.onError ?? 'stop', disabled: busy || running, options: [
+                                                { value: 'stop', label: t('stop') },
+                                                { value: 'skip', label: t('skipErrors') },
+                                            ], onChange: (value) => setOption({ onError: value }) })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-dates`, children: t('dateOrder') }), _jsx(Select, { id: `${id}-dates`, value: options.dateOrder ?? 'dmy', disabled: busy || running, options: [
+                                                { value: 'dmy', label: '31/12/2026' },
+                                                { value: 'mdy', label: '12/31/2026' },
+                                                { value: 'ymd', label: '2026/12/31' },
+                                            ], onChange: (value) => setOption({ dateOrder: value }) })] }), _jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-decimal`, children: t('decimal') }), _jsx(Select, { id: `${id}-decimal`, value: options.decimal ?? '.', disabled: busy || running, options: [
+                                                { value: '.', label: t('decimalDot') },
+                                                { value: ',', label: t('decimalComma') },
+                                            ], onChange: (value) => setOption({ decimal: value }) })] }), (mappings.data?.mappings ?? []).length === 0 ? null : (_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { htmlFor: `${id}-apply`, children: t('savedMappings') }), _jsx(Select, { id: `${id}-apply`, value: null, placeholder: t('applyMapping'), disabled: busy || running, options: (mappings.data?.mappings ?? []).map((m) => ({
+                                                value: m.id,
+                                                label: m.name,
+                                            })), onChange: (value) => apply.mutate(value) })] }))] }), _jsxs("div", { className: "flex flex-wrap items-end gap-3 border-t pt-3", children: [_jsxs("div", { className: "min-w-48 flex-1 space-y-1", children: [_jsx(Label, { htmlFor: `${id}-name`, children: t('mappingName') }), _jsx(Input, { id: `${id}-name`, value: mappingName, maxLength: 100, onChange: (e) => setMappingName(e.target.value) })] }), _jsxs("div", { className: "flex items-center gap-2 pb-2", children: [_jsx(Checkbox, { id: `${id}-share`, checked: share, onCheckedChange: (v) => setShare(v === true) }), _jsx(Label, { htmlFor: `${id}-share`, children: t('shareMapping') })] }), _jsxs(Button, { size: "sm", busy: save.isPending, disabled: mappingName.trim() === '' || mapped.size === 0, onClick: () => save.mutate(), children: [_jsx(Save, { "aria-hidden": true }), t('saveMapping')] }), savedName === null ? null : (_jsx("p", { role: "status", className: "w-full text-sm text-muted-foreground", children: t('saved') }))] })] })) : null, step === 'result' && session !== null ? (_jsxs("div", { className: "space-y-3", "aria-live": "polite", children: [session.failure === null ? null : (_jsx(Alert, { children: t('failure', { reason: session.failure }) })), result === null ? null : session.resultDry ? (_jsx(Alert, { tone: "info", children: t('checked', { create: result.wouldCreate, update: result.wouldUpdate }) })) : session.state === 'done' || session.state === 'undone' ? (_jsxs(Alert, { tone: "info", children: [t('imported', { created: result.created.length, updated: result.updated.length }), ' ', result.skipped > 0 ? t('skippedRows', { count: result.skipped }) : null] })) : null, undone === null ? null : (_jsxs(Alert, { tone: "info", children: [t('undone', { deleted: undone.deleted, restored: undone.restored }), ' ', undone.changed.length > 0
+                                    ? t('changedSince', { count: undone.changed.length })
+                                    : null] })), _jsxs("div", { className: "flex flex-wrap gap-2", children: [session.rejected > 0 ? (_jsxs(Button, { size: "sm", busy: download.isPending, onClick: () => download.mutate(`/api/v1/imports/${session.id}/rejected`), children: [_jsx(Download, { "aria-hidden": true }), t('rejected')] })) : null, session.undoUntil === null ? null : (_jsxs(Button, { size: "sm", variant: "danger", busy: undo.isPending, onClick: () => undo.mutate(), children: [_jsx(Undo2, { "aria-hidden": true }), t('undo')] }))] }), result === null ? null : result.errors.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: t('noErrors') })) : (_jsxs("div", { className: "space-y-2", children: [_jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [_jsx("h3", { className: "text-sm font-semibold", children: t('errors', { count: result.errors.length }) }), _jsx(Select, { label: t('errorColumn'), className: "w-56", value: errorColumn, onChange: setErrorColumn, options: [
+                                                { value: 'all', label: t('allColumns') },
+                                                { value: 'row', label: t('wholeRow') },
+                                                ...[
+                                                    ...new Set(result.errors.flatMap((e) => (e.column === null ? [] : [e.column]))),
+                                                ]
+                                                    .sort((a, b) => a - b)
+                                                    .map((c) => ({ value: String(c), label: session.headers[c] ?? String(c) })),
+                                            ] })] }), _jsx("div", { className: "max-h-72 overflow-y-auto", children: _jsxs("table", { className: "w-full text-sm", children: [_jsx("thead", { className: "sticky top-0 bg-surface", children: _jsxs("tr", { className: "border-b text-muted-foreground", children: [_jsx("th", { className: "py-1.5 pe-3 text-start font-medium", children: t('errorRow') }), _jsx("th", { className: "py-1.5 pe-3 text-start font-medium", children: t('errorColumn') }), _jsx("th", { className: "py-1.5 text-start font-medium", children: t('errorMessage') })] }) }), _jsx("tbody", { children: shownErrors.map((e, i) => (_jsxs("tr", { className: "border-b last:border-0", children: [_jsx("td", { className: "py-1.5 pe-3 tabular-nums", children: e.row }), _jsx("td", { className: "py-1.5 pe-3", children: e.column === null ? t('wholeRow') : (session.headers[e.column] ?? '') }), _jsx("td", { className: "py-1.5", children: e.message })] }, i))) })] }) })] }))] })) : null] }) }));
+}

package/dist/import/web/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/import` (RFC 0014): "Import" next to every list's "New" (`import.Import`), the
+ * import screen, and their messages.
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { ImportButton } from './ImportButton.js';
+export { type ImportSession, ImportWizard } from './ImportWizard.js';
+/** Registers "Import" (and the messages in `i18n`, when given). */
+export declare function registerImportWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as importMessages };

package/dist/import/web/index.js

@@ -0,0 +1,18 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/import` (RFC 0014): "Import" next to every list's "New" (`import.Import`), the
+ * import screen, and their messages.
+ */
+import { addMessages } from '../../ui/index.js';
+import { ImportButton } from './ImportButton.js';
+import { messages } from './messages.js';
+export { ImportButton } from './ImportButton.js';
+export { ImportWizard } from './ImportWizard.js';
+/** Registers "Import" (and the messages in `i18n`, when given). */
+export function registerImportWeb(registry, i18n) {
+    registry.registerCreateAssist('import.Import', ImportButton);
+    if (i18n !== undefined)
+        addMessages(i18n, 'import', messages);
+    return registry;
+}
+export { messages as importMessages };

package/dist/import/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the import screen (namespace `import`). */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/import/web/messages.js

@@ -0,0 +1,139 @@
+/** Messages of the import screen (namespace `import`). */
+export const messages = {
+    en: {
+        import: 'Import',
+        title: 'Import records',
+        intro: 'Upload a CSV or Excel file. Nothing is saved until you import, and an import can be undone for 7 days.',
+        stepFile: 'File',
+        stepColumns: 'Columns',
+        stepResult: 'Result',
+        chooseFile: 'CSV or Excel file',
+        upload: 'Read the file',
+        template: 'Download a sample file',
+        templateOf: 'Sample: {{name}}',
+        applied: 'The saved mapping “{{name}}” was applied.',
+        rows_one: '{{count}} row',
+        rows_other: '{{count}} rows',
+        background: 'Large file: it is checked and imported in the background. You can close this window.',
+        column: 'Column in the file',
+        sample: 'First values',
+        field: 'Field',
+        skip: 'Skip this column',
+        keyColumns: 'Keys',
+        lineFields: 'Lines',
+        required: 'required',
+        missing: 'Required fields without a column: {{fields}}',
+        mode: 'What to do',
+        modeCreate: 'Create new records',
+        modeUpdate: 'Update existing records',
+        modeUpsert: 'Update existing records, create the others',
+        key: 'Find records by',
+        noKey: 'Choose the column that finds the records',
+        onError: 'Rows with errors',
+        stop: 'Import nothing if any row has an error',
+        skipErrors: 'Import the other rows; give me the rejected ones',
+        dateOrder: 'Dates written as',
+        decimal: 'Decimal separator',
+        decimalDot: 'Point (1,250.50)',
+        decimalComma: 'Comma (1.250,50)',
+        savedMappings: 'Saved mappings',
+        applyMapping: 'Apply a saved mapping',
+        saveMapping: 'Save this mapping',
+        mappingName: 'Name of the mapping',
+        shareMapping: 'Share with every import user of the company',
+        saved: 'Mapping saved.',
+        check: 'Check',
+        run: 'Import',
+        running: 'Working… {{done}} of {{total}} records',
+        queued: 'Waiting to start…',
+        checked: 'Check finished: {{create}} to create, {{update}} to update.',
+        imported: 'Imported: {{created}} created, {{updated}} updated.',
+        skippedRows_one: '{{count}} record left out.',
+        skippedRows_other: '{{count}} records left out.',
+        noErrors: 'No errors.',
+        errors_one: '{{count}} error',
+        errors_other: '{{count}} errors',
+        errorRow: 'Row',
+        errorColumn: 'Column',
+        errorMessage: 'Problem',
+        allColumns: 'All columns',
+        wholeRow: 'Whole row',
+        rejected: 'Download the rejected rows',
+        undo: 'Undo this import',
+        undone: 'Undone: {{deleted}} deleted, {{restored}} restored.',
+        changedSince_one: '{{count}} record changed since the import was left as it is.',
+        changedSince_other: '{{count}} records changed since the import were left as they are.',
+        failure: 'The import could not finish: {{reason}}',
+        back: 'Back',
+        another: 'Import another file',
+        done: 'Done',
+    },
+    bn: {
+        import: 'ইমপোর্ট',
+        title: 'রেকর্ড ইমপোর্ট',
+        intro: 'একটি CSV বা Excel ফাইল আপলোড করুন। ইমপোর্ট না করা পর্যন্ত কিছুই সংরক্ষিত হয় না, এবং ৭ দিন পর্যন্ত ইমপোর্ট ফিরিয়ে নেওয়া যায়।',
+        stepFile: 'ফাইল',
+        stepColumns: 'কলাম',
+        stepResult: 'ফলাফল',
+        chooseFile: 'CSV বা Excel ফাইল',
+        upload: 'ফাইল পড়ুন',
+        template: 'নমুনা ফাইল ডাউনলোড করুন',
+        templateOf: 'নমুনা: {{name}}',
+        applied: 'সংরক্ষিত ম্যাপিং “{{name}}” প্রয়োগ করা হয়েছে।',
+        rows_one: '{{count}}টি সারি',
+        rows_other: '{{count}}টি সারি',
+        background: 'বড় ফাইল: এটি পটভূমিতে যাচাই ও ইমপোর্ট হবে। আপনি এই উইন্ডো বন্ধ করতে পারেন।',
+        column: 'ফাইলের কলাম',
+        sample: 'প্রথম মানগুলো',
+        field: 'ফিল্ড',
+        skip: 'এই কলাম বাদ দিন',
+        keyColumns: 'কী',
+        lineFields: 'লাইন',
+        required: 'আবশ্যক',
+        missing: 'কলাম ছাড়া আবশ্যক ফিল্ড: {{fields}}',
+        mode: 'কী করবেন',
+        modeCreate: 'নতুন রেকর্ড তৈরি করুন',
+        modeUpdate: 'বিদ্যমান রেকর্ড হালনাগাদ করুন',
+        modeUpsert: 'বিদ্যমান রেকর্ড হালনাগাদ করুন, বাকিগুলো তৈরি করুন',
+        key: 'রেকর্ড খুঁজুন',
+        noKey: 'যে কলাম দিয়ে রেকর্ড খুঁজবেন তা বেছে নিন',
+        onError: 'ত্রুটিপূর্ণ সারি',
+        stop: 'কোনো সারিতে ত্রুটি থাকলে কিছুই ইমপোর্ট করবেন না',
+        skipErrors: 'বাকি সারিগুলো ইমপোর্ট করুন; বাদ পড়াগুলো আমাকে দিন',
+        dateOrder: 'তারিখ লেখা আছে',
+        decimal: 'দশমিক চিহ্ন',
+        decimalDot: 'বিন্দু (1,250.50)',
+        decimalComma: 'কমা (1.250,50)',
+        savedMappings: 'সংরক্ষিত ম্যাপিং',
+        applyMapping: 'সংরক্ষিত ম্যাপিং প্রয়োগ করুন',
+        saveMapping: 'এই ম্যাপিং সংরক্ষণ করুন',
+        mappingName: 'ম্যাপিংয়ের নাম',
+        shareMapping: 'কোম্পানির সব ইমপোর্ট ব্যবহারকারীর সাথে শেয়ার করুন',
+        saved: 'ম্যাপিং সংরক্ষিত হয়েছে।',
+        check: 'যাচাই করুন',
+        run: 'ইমপোর্ট করুন',
+        running: 'কাজ চলছে… {{total}}টির মধ্যে {{done}}টি রেকর্ড',
+        queued: 'শুরু হওয়ার অপেক্ষায়…',
+        checked: 'যাচাই শেষ: {{create}}টি তৈরি হবে, {{update}}টি হালনাগাদ হবে।',
+        imported: 'ইমপোর্ট হয়েছে: {{created}}টি তৈরি, {{updated}}টি হালনাগাদ।',
+        skippedRows_one: '{{count}}টি রেকর্ড বাদ পড়েছে।',
+        skippedRows_other: '{{count}}টি রেকর্ড বাদ পড়েছে।',
+        noErrors: 'কোনো ত্রুটি নেই।',
+        errors_one: '{{count}}টি ত্রুটি',
+        errors_other: '{{count}}টি ত্রুটি',
+        errorRow: 'সারি',
+        errorColumn: 'কলাম',
+        errorMessage: 'সমস্যা',
+        allColumns: 'সব কলাম',
+        wholeRow: 'পুরো সারি',
+        rejected: 'বাদ পড়া সারিগুলো ডাউনলোড করুন',
+        undo: 'এই ইমপোর্ট ফিরিয়ে নিন',
+        undone: 'ফিরিয়ে নেওয়া হয়েছে: {{deleted}}টি মুছে ফেলা, {{restored}}টি পুনরুদ্ধার।',
+        changedSince_one: 'ইমপোর্টের পরে বদলানো {{count}}টি রেকর্ড যেমন ছিল তেমনই রাখা হয়েছে।',
+        changedSince_other: 'ইমপোর্টের পরে বদলানো {{count}}টি রেকর্ড যেমন ছিল তেমনই রাখা হয়েছে।',
+        failure: 'ইমপোর্ট শেষ করা যায়নি: {{reason}}',
+        back: 'পেছনে',
+        another: 'আরেকটি ফাইল ইমপোর্ট করুন',
+        done: 'সম্পন্ন',
+    },
+};

package/dist/import/worker.d.ts

@@ -0,0 +1,3 @@
+import type { Worker } from '../server/orm.js';
+import { type ImportContext, type ImportService } from './service.js';
+export declare function importWorker(context: ImportContext, service?: ImportService): Worker;

package/dist/import/worker.js

@@ -0,0 +1,52 @@
+/**
+ * Background imports (RFC 0014 §5.3): a file of more than `INLINE_ROWS` rows runs as a Shutro job, as the user who
+ * started it, in the job's one transaction (all-or-nothing stays all-or-nothing). Progress is written in short
+ * transactions of its own so the screen sees it; the end emits `import.finished`, which the notification inbox
+ * turns into a notification for the user. A fault is retried by Shutro; on the last attempt, or for a refusal (the
+ * user lost a permission), the session goes back to draft with the reason.
+ */
+import { problemOf } from '../server/index.js';
+import { createImportService, FINISHED_TOPIC, RUN_JOB, ref, } from './service.js';
+export function importWorker(context, service = createImportService(context)) {
+    return context.shutro.work({
+        [RUN_JOB]: async (payload, env, job) => {
+            const { session: id, dryRun } = payload;
+            let session;
+            try {
+                session = await service.sessionOf(env, id);
+            }
+            catch (error) {
+                if (problemOf(error).status === 404)
+                    return; // deleted since
+                throw error;
+            }
+            if (session.state !== 'running')
+                return;
+            try {
+                const result = await service.execute(env, session, dryRun, (done, total) => service.reportProgress(env.companyId, id, done, total));
+                await service.record(env, session, result, dryRun);
+                await env.emit(FINISHED_TOPIC, {
+                    model: 'import.session',
+                    id,
+                    dry: dryRun,
+                    file: session.fileName,
+                    created: dryRun ? result.wouldCreate : result.created.length,
+                    updated: dryRun ? result.wouldUpdate : result.updated.length,
+                    errors: result.errors.length,
+                });
+            }
+            catch (error) {
+                const problem = problemOf(error);
+                if (problem.status >= 500 && job.attempt < job.maxAttempts)
+                    throw error; // retried
+                const failure = (problem.status >= 500
+                    ? 'The import failed; try again.'
+                    : (problem.detail ?? problem.title)).slice(0, 500);
+                await context.shutro.bootstrap({ reason: 'import failed', company: env.companyId }, async (su) => {
+                    const found = await ref(su, 'import.session').search({ where: { id }, limit: 1 });
+                    await found.write({ state: 'draft', failure });
+                });
+            }
+        },
+    }, { pollMs: 5000 });
+}

package/dist/import/xlsx.d.ts

@@ -0,0 +1,20 @@
+export type XlsxCell = string | number | boolean | Date | null;
+export interface XlsxSheet {
+    readonly name: string;
+    readonly rows: XlsxCell[][];
+}
+export declare class XlsxError extends Error {
+    readonly name = "XlsxError";
+}
+/** The entries of a zip archive by name (stored or deflated; no ZIP64, no encryption). */
+export declare function unzip(bytes: Uint8Array): Map<string, Uint8Array>;
+/** XML text with its entities resolved. */
+export declare function unescapeXml(text: string): string;
+/** Whether a custom number format code shows a date or time (letters outside quotes and brackets). */
+export declare function isDateFormat(code: string): boolean;
+/** An Excel serial date (days since 1899-12-30) as a UTC date, to the second. */
+export declare function fromSerial(serial: number): Date;
+/** The sheet names of a workbook, in order. */
+export declare function xlsxSheetNames(bytes: Uint8Array): string[];
+/** Reads one sheet of a workbook: by name, else the first. @throws {XlsxError} */
+export declare function readXlsx(bytes: Uint8Array, sheet?: string): XlsxSheet;