nucleus-core-ts 0.9.821 → 0.9.823

package/dist/fe/components/IntegrationsPage/components/ConnectionList.js

@@ -5,6 +5,7 @@ import { cn } from '../../../utils/cn';
 import { useIntegrationsStore } from '../store';
 import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
+import { ConnectionTransfer } from './ConnectionTransfer';
 import { Badge, Field, Notice } from './Primitives';
 import { ListSkeleton } from './Skeletons';
 import { useInfiniteList } from './useInfiniteList';
@@ -105,6 +106,10 @@ export function ConnectionList({ actions, onNewConnection, reloadToken = 0 }) {
                     })
                 ]
             }),
+            /*#__PURE__*/ _jsx(ConnectionTransfer, {
+                actions: actions,
+                onImported: list.reload
+            }),
             /*#__PURE__*/ _jsx(Field, {
                 htmlFor: "connection-search",
                 label: labels.connections.searchLabel,

package/dist/fe/components/IntegrationsPage/components/ConnectionTransfer.d.ts

@@ -0,0 +1,7 @@
+import type { IntegrationsActions } from '../types';
+export type ConnectionTransferProps = {
+    actions: IntegrationsActions;
+    /** Bumped by the caller so the rail refetches after a file is brought in. */
+    onImported?: () => void;
+};
+export declare function ConnectionTransfer({ actions, onImported }: ConnectionTransferProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/ConnectionTransfer.js

@@ -0,0 +1,157 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme } from '../theme';
+import { Notice } from './Primitives';
+/**
+ * Taking a whole integration somewhere else, and bringing one back.
+ *
+ * A connection is the connection, the calls it makes, the parameters those calls
+ * take from each other, and the mappings that turn the answers into rows.
+ * Rebuilding that by hand in a second environment is hours of work and a fresh
+ * chance to get one field wrong in a way nobody notices until an import writes
+ * it. So it travels as one file.
+ *
+ * The file carries NO credentials — deliberately, and it says so on both sides,
+ * because a connection that arrives looking configured and cannot authenticate
+ * is a confusing half hour otherwise.
+ */ const theme = integrationsPageTheme;
+const messageOf = (error)=>error instanceof Error ? error.message : 'The request failed.';
+/** A filename somebody can still recognise a week later. */ const fileNameFor = (slug)=>`integration-${slug || 'connection'}.json`;
+export function ConnectionTransfer({ actions, onImported }) {
+    const store = useIntegrationsStore();
+    const fileRef = useRef(null);
+    const [busy, setBusy] = useState(false);
+    const [problems, setProblems] = useState([]);
+    const [note, setNote] = useState(null);
+    const selected = store.sources.find((source)=>source.id === store.selectedSourceId);
+    const exportOne = ()=>{
+        if (!selected) return;
+        setBusy(true);
+        setProblems([]);
+        setNote(null);
+        actions.exportConnection(selected.id).then((document)=>{
+            setBusy(false);
+            if (!document) {
+                store.setError('The connection could not be exported.');
+                return;
+            }
+            // Written from the browser rather than served as a download, so the file
+            // never travels back through a URL somebody could share by accident.
+            const blob = new Blob([
+                JSON.stringify(document, null, 2)
+            ], {
+                type: 'application/json'
+            });
+            const url = URL.createObjectURL(blob);
+            const link = window.document.createElement('a');
+            link.href = url;
+            link.download = fileNameFor(selected.slug);
+            link.click();
+            URL.revokeObjectURL(url);
+            setNote('Exported. Credentials are not in the file — enter them wherever it lands.');
+        }).catch((error)=>{
+            setBusy(false);
+            store.setError(messageOf(error));
+        });
+    };
+    const importFile = (file)=>{
+        setBusy(true);
+        setProblems([]);
+        setNote(null);
+        file.text().then((text)=>{
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            } catch  {
+                setBusy(false);
+                setProblems([
+                    {
+                        path: file.name,
+                        message: 'This file is not readable as JSON.'
+                    }
+                ]);
+                return;
+            }
+            return actions.importConnection(parsed).then((result)=>{
+                setBusy(false);
+                if (!result.ok) {
+                    setProblems(result.problems ?? [
+                        {
+                            path: '',
+                            message: result.message
+                        }
+                    ]);
+                    return;
+                }
+                setNote(result.message);
+                onImported?.();
+            });
+        }).catch((error)=>{
+            setBusy(false);
+            store.setError(messageOf(error));
+        });
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-2",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: busy || !selected,
+                        onClick: exportOne,
+                        title: selected ? `Export ${selected.name} — its calls and mappings, without any credential` : 'Choose a connection to export',
+                        type: "button",
+                        children: busy ? 'Working…' : 'Export'
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: busy,
+                        onClick: ()=>fileRef.current?.click(),
+                        type: "button",
+                        children: "Import"
+                    }),
+                    /*#__PURE__*/ _jsx("input", {
+                        accept: "application/json,.json",
+                        className: "hidden",
+                        onChange: (event)=>{
+                            const file = event.target.files?.[0];
+                            // Cleared so choosing the same file twice fires again — the second
+                            // attempt is usually the one after fixing something.
+                            event.target.value = '';
+                            if (file) importFile(file);
+                        },
+                        ref: fileRef,
+                        type: "file"
+                    })
+                ]
+            }),
+            note ? /*#__PURE__*/ _jsx("p", {
+                className: theme.field.hint,
+                children: note
+            }) : null,
+            problems.length > 0 ? /*#__PURE__*/ _jsx(Notice, {
+                title: "This file cannot be imported as it stands",
+                tone: "danger",
+                children: /*#__PURE__*/ _jsx("ul", {
+                    className: "flex flex-col gap-1",
+                    children: problems.map((problem)=>/*#__PURE__*/ _jsxs("li", {
+                            className: theme.field.hint,
+                            children: [
+                                problem.path ? /*#__PURE__*/ _jsxs("strong", {
+                                    children: [
+                                        problem.path,
+                                        ": "
+                                    ]
+                                }) : null,
+                                problem.message
+                            ]
+                        }, `${problem.path}-${problem.message}`))
+                })
+            }) : null
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/MappingAccountFields.d.ts

@@ -0,0 +1,12 @@
+import type { AccountRuleValue } from '../types';
+import type { MappingTarget } from './mappingDraft';
+export type MappingAccountFieldsProps = {
+    value: AccountRuleValue | null;
+    /** Columns of the entity being written into. */
+    targetFields: string[];
+    /** Every entity, so the account table and its columns can be chosen. */
+    targets: MappingTarget[];
+    disabled?: boolean;
+    onChange: (value: AccountRuleValue | null) => void;
+};
+export declare function MappingAccountFields({ value, targetFields, targets, disabled, onChange, }: MappingAccountFieldsProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/MappingAccountFields.js

@@ -0,0 +1,214 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useId } from 'react';
+import { integrationsPageTheme } from '../theme';
+import { Field, Notice } from './Primitives';
+/**
+ * A login for every person this import brings in.
+ *
+ * A directory carries people, not accounts. Importing eight hundred employees
+ * and then creating eight hundred logins by hand — matching them up by e-mail,
+ * one at a time — is the job nobody gets to, so the import that was supposed to
+ * save the afternoon leaves a table of people who cannot sign in.
+ *
+ * Turned on here, it happens in the SAME import and the same transaction: the
+ * person and their login both exist, or neither does. A record whose address is
+ * already an account is linked to it rather than given a second one, so running
+ * the import again is safe.
+ *
+ * The password is not on this screen. It belongs to the run — typed once, used
+ * for every account that run creates, stored nowhere.
+ */ const theme = integrationsPageTheme;
+/** Columns that plausibly hold a password, so the guess is a good one. */ const PASSWORD_LIKE = /password|passwd|sifre|şifre|parola/i;
+/** Columns that plausibly point at the account row. */ const LINK_LIKE = /^(user_?id|account_?id|login_?id)$/i;
+export function MappingAccountFields({ value, targetFields, targets, disabled, onChange }) {
+    const uid = useId();
+    const accountEntity = targets.find((target)=>target.entity === value?.entity);
+    const accountFields = accountEntity?.fields ?? [];
+    const patch = (next)=>{
+        if (!value) return;
+        onChange({
+            ...value,
+            ...next
+        });
+    };
+    const turnOn = ()=>{
+        // Guessed from the names the tables already use, because the operator has
+        // just told us which table this writes into and the answer is usually there.
+        const idColumn = targetFields.find((field)=>LINK_LIKE.test(field)) ?? '';
+        const emailish = targetFields.find((field)=>/mail/i.test(field)) ?? '';
+        onChange({
+            entity: '',
+            idColumn,
+            matchColumn: 'email',
+            matchFrom: emailish,
+            passwordColumn: ''
+        });
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-3",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center justify-between gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("h3", {
+                        className: theme.card.title,
+                        children: "Also create a login for each new record"
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: disabled || targetFields.length === 0,
+                        onClick: ()=>value ? onChange(null) : turnOn(),
+                        type: "button",
+                        children: value ? 'Turn off' : 'Turn on'
+                    })
+                ]
+            }),
+            value ? /*#__PURE__*/ _jsxs(_Fragment, {
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "grid grid-cols-1 gap-3 sm:grid-cols-2 lg:grid-cols-3",
+                        children: [
+                            /*#__PURE__*/ _jsx(Field, {
+                                htmlFor: `${uid}-entity`,
+                                label: "Accounts live in",
+                                children: /*#__PURE__*/ _jsxs("select", {
+                                    className: theme.field.input,
+                                    disabled: disabled,
+                                    id: `${uid}-entity`,
+                                    onChange: (event)=>patch({
+                                            entity: event.target.value,
+                                            passwordColumn: '',
+                                            matchColumn: 'email'
+                                        }),
+                                    value: value.entity,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("option", {
+                                            value: "",
+                                            children: "Not set"
+                                        }),
+                                        targets.map((target)=>/*#__PURE__*/ _jsx("option", {
+                                                value: target.entity,
+                                                children: target.label
+                                            }, target.entity))
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Field, {
+                                hint: "The column on the account that identifies it.",
+                                htmlFor: `${uid}-match-column`,
+                                label: "Identified by",
+                                children: /*#__PURE__*/ _jsxs("select", {
+                                    className: theme.field.input,
+                                    disabled: disabled || accountFields.length === 0,
+                                    id: `${uid}-match-column`,
+                                    onChange: (event)=>patch({
+                                            matchColumn: event.target.value
+                                        }),
+                                    value: value.matchColumn,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("option", {
+                                            value: "",
+                                            children: "Not set"
+                                        }),
+                                        accountFields.map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                value: field,
+                                                children: field
+                                            }, field))
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Field, {
+                                hint: "Where the run's shared password is written.",
+                                htmlFor: `${uid}-password`,
+                                label: "Password goes into",
+                                children: /*#__PURE__*/ _jsxs("select", {
+                                    className: theme.field.input,
+                                    disabled: disabled || accountFields.length === 0,
+                                    id: `${uid}-password`,
+                                    onChange: (event)=>patch({
+                                            passwordColumn: event.target.value
+                                        }),
+                                    value: value.passwordColumn,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("option", {
+                                            value: "",
+                                            children: "Not set"
+                                        }),
+                                        accountFields.filter((field)=>PASSWORD_LIKE.test(field)).map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                value: field,
+                                                children: field
+                                            }, field)),
+                                        accountFields.filter((field)=>!PASSWORD_LIKE.test(field)).length > 0 ? /*#__PURE__*/ _jsx("optgroup", {
+                                            label: "Other columns",
+                                            children: accountFields.filter((field)=>!PASSWORD_LIKE.test(field)).map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                    value: field,
+                                                    children: field
+                                                }, field))
+                                        }) : null
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Field, {
+                                hint: "The imported record's column carrying that same value.",
+                                htmlFor: `${uid}-match-from`,
+                                label: "Matched from",
+                                children: /*#__PURE__*/ _jsxs("select", {
+                                    className: theme.field.input,
+                                    disabled: disabled,
+                                    id: `${uid}-match-from`,
+                                    onChange: (event)=>patch({
+                                            matchFrom: event.target.value
+                                        }),
+                                    value: value.matchFrom,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("option", {
+                                            value: "",
+                                            children: "Not set"
+                                        }),
+                                        targetFields.map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                value: field,
+                                                children: field
+                                            }, field))
+                                    ]
+                                })
+                            }),
+                            /*#__PURE__*/ _jsx(Field, {
+                                hint: "Filled with the new account's id, so the record and its login know each other.",
+                                htmlFor: `${uid}-id-column`,
+                                label: "Account id goes into",
+                                children: /*#__PURE__*/ _jsxs("select", {
+                                    className: theme.field.input,
+                                    disabled: disabled,
+                                    id: `${uid}-id-column`,
+                                    onChange: (event)=>patch({
+                                            idColumn: event.target.value
+                                        }),
+                                    value: value.idColumn,
+                                    children: [
+                                        /*#__PURE__*/ _jsx("option", {
+                                            value: "",
+                                            children: "Not set"
+                                        }),
+                                        targetFields.map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                value: field,
+                                                children: field
+                                            }, field))
+                                    ]
+                                })
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(Notice, {
+                        title: "One password, typed on the import screen",
+                        tone: "info",
+                        children: "Every account this run creates is given the same opening password — asked for once, when the import is started, and stored nowhere. People change it themselves afterwards. A record whose value already has an account is linked to that one instead, so running this import again does not create a second."
+                    })
+                ]
+            }) : /*#__PURE__*/ _jsx("p", {
+                className: theme.list.empty,
+                children: "Off. Records are imported without a login — useful for a directory, not for people who have to sign in."
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/MappingEditor.js

@@ -5,6 +5,7 @@ import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { FieldMappingRows } from './FieldMappingRows';
 import { endpointLabel, fieldsOfStoredSample } from './formSupport';
+import { MappingAccountFields } from './MappingAccountFields';
 import { MappingPasswordField } from './MappingPasswordField';
 import { MappingWriteModeFields } from './MappingWriteModeFields';
 import { mappingDraftIssues } from './mappingDraft';
@@ -203,6 +204,15 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         targetFields: targetFields,
                         targets: targets
                     }),
+                    /*#__PURE__*/ _jsx(MappingAccountFields, {
+                        disabled: busy,
+                        onChange: (accountRule)=>patch({
+                                accountRule
+                            }),
+                        targetFields: targetFields,
+                        targets: targets,
+                        value: draft.accountRule ?? null
+                    }),
                     /*#__PURE__*/ _jsx(MappingPasswordField, {
                         disabled: busy,
                         onChange: (value)=>patch({

package/dist/fe/components/IntegrationsPage/components/RunPanel.js

@@ -8,6 +8,7 @@ import { Notice } from './Primitives';
 import { RunConfirmStep } from './RunConfirmStep';
 import { MIN_SHARED_PASSWORD, RunPasswordField } from './RunPasswordField';
 import { RunPlanReferences } from './RunPlanReferences';
+import { RunPlanSuggestions } from './RunPlanSuggestions';
 import { RunPlanSummary } from './RunPlanSummary';
 import { RunProgressBar } from './RunProgressBar';
 import { describeLosses, errorText } from './runFormat';
@@ -29,8 +30,13 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
     // Held only while this panel is open. Never put in the store, never saved:
     // the point of asking per run is that it does not live anywhere afterwards.
     const [sharedPassword, setSharedPassword] = useState('');
+    // Two ways an import can need a password: it writes one into the record's own
+    // table, or it creates a login alongside each record. Either way it is typed
+    // here, once, and goes no further than this run.
+    const accountRule = mapping.accountRule ?? null;
     const passwordColumn = mapping.passwordTargetColumn ?? '';
-    const passwordReady = passwordColumn === '' || sharedPassword.length >= MIN_SHARED_PASSWORD;
+    const needsPassword = passwordColumn !== '' || accountRule !== null;
+    const passwordReady = !needsPassword || sharedPassword.length >= MIN_SHARED_PASSWORD;
     const activeRunId = store.activeRunId;
     const plan = store.plan;
     const preview = ()=>{
@@ -182,8 +188,8 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
             /*#__PURE__*/ _jsxs("div", {
                 className: theme.card.body,
                 children: [
-                    passwordColumn && !activeRunId ? /*#__PURE__*/ _jsx(RunPasswordField, {
-                        column: passwordColumn,
+                    needsPassword && !activeRunId ? /*#__PURE__*/ _jsx(RunPasswordField, {
+                        column: accountRule ? `${accountRule.entity}.${accountRule.passwordColumn}` : passwordColumn,
                         disabled: starting,
                         onChange: setSharedPassword,
                         value: sharedPassword
@@ -207,6 +213,11 @@ export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }
                             /*#__PURE__*/ _jsx(RunPlanSummary, {
                                 plan: plan
                             }),
+                            /*#__PURE__*/ _jsx(RunPlanSuggestions, {
+                                mapping: mapping,
+                                onEditMapping: ()=>store.setTab('mappings'),
+                                plan: plan
+                            }),
                             /*#__PURE__*/ _jsx(RunPlanReferences, {
                                 busy: starting || activeRunId !== null || !passwordReady,
                                 onCreateAndRun: ()=>start(false, 'create'),

package/dist/fe/components/IntegrationsPage/components/RunPlanSuggestions.d.ts

@@ -0,0 +1,15 @@
+import type { IntegrationMapping, RunPlanValue } from '../types';
+/** `{name}.{surname}@example.com`, built from what this source really sends. */
+export declare function suggestEmailTemplate(mapping: IntegrationMapping): string | null;
+/** How many records each required field kept out, largest first. */
+export declare function missingRequiredCounts(plan: RunPlanValue): {
+    field: string;
+    records: number;
+}[];
+export type RunPlanSuggestionsProps = {
+    plan: RunPlanValue;
+    mapping: IntegrationMapping;
+    /** Takes the operator to the mapping, where the fix is made. */
+    onEditMapping?: () => void;
+};
+export declare function RunPlanSuggestions({ plan, mapping, onEditMapping }: RunPlanSuggestionsProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/fe/components/IntegrationsPage/components/RunPlanSuggestions.js

@@ -0,0 +1,120 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+import { Notice } from './Primitives';
+/**
+ * What to DO about the records this import would leave out.
+ *
+ * A preview that says "561 records are missing e-mail" has told the truth and
+ * stopped one step short of being useful: the answer is nearly always to build
+ * the value from the fields that ARE there, and the panel knows which those are.
+ * Leaving the operator to work that out — and to guess that Fallback takes
+ * `{braces}` at all — is how a capability that exists goes unused.
+ *
+ * So the suggestion is written out, with the record's own field names in it,
+ * ready to be copied into the mapping.
+ */ const theme = integrationsPageTheme;
+/** Column names that plausibly hold an address, so the advice can be specific. */ const EMAIL_LIKE = /mail/i;
+/** Source fields that plausibly name a person, in the order they read best. */ const GIVEN_NAME = /^(name|first|firstname|given|ad)$/i;
+const FAMILY_NAME = /^(surname|last|lastname|family|soyad)$/i;
+/** Fields the source actually sends, from what the mapping already reads. */ function sourceFieldsOf(mapping) {
+    return (Array.isArray(mapping.fieldMappings) ? mapping.fieldMappings : []).map((row)=>row.source).filter((source)=>source.trim() !== '' && !source.includes('{'));
+}
+/** `{name}.{surname}@example.com`, built from what this source really sends. */ export function suggestEmailTemplate(mapping) {
+    const fields = sourceFieldsOf(mapping);
+    const given = fields.find((field)=>GIVEN_NAME.test(field));
+    const family = fields.find((field)=>FAMILY_NAME.test(field));
+    if (!given && !family) return null;
+    const parts = [
+        given,
+        family
+    ].filter(Boolean).join('}.{');
+    return `{${parts}}@example.com`;
+}
+/** How many records each required field kept out, largest first. */ export function missingRequiredCounts(plan) {
+    const counts = new Map();
+    for (const issue of plan.issues){
+        if (issue.kind !== 'missing_required') continue;
+        // The field names are in the message the planner wrote; it is the only
+        // place they exist, and re-deriving them from the row would be a guess.
+        const named = issue.message.replace(/^Required field\(s\) empty:\s*/, '');
+        for (const field of named.split(',').map((part)=>part.trim())){
+            if (field) counts.set(field, (counts.get(field) ?? 0) + 1);
+        }
+    }
+    return [
+        ...counts.entries()
+    ].map(([field, records])=>({
+            field,
+            records
+        })).sort((a, b)=>b.records - a.records);
+}
+export function RunPlanSuggestions({ plan, mapping, onEditMapping }) {
+    const missing = missingRequiredCounts(plan);
+    if (missing.length === 0) return null;
+    const template = suggestEmailTemplate(mapping);
+    return /*#__PURE__*/ _jsx("section", {
+        className: "flex flex-col gap-3",
+        children: missing.map((entry)=>{
+            const isEmail = EMAIL_LIKE.test(entry.field);
+            return /*#__PURE__*/ _jsxs(Notice, {
+                title: `${entry.records} record(s) have no ${entry.field}, so they are left out`,
+                tone: "warning",
+                children: [
+                    isEmail && template ? /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsxs("p", {
+                                children: [
+                                    "An address can be built from the fields the source DOES send. On the mapping, set",
+                                    ' ',
+                                    /*#__PURE__*/ _jsx("strong", {
+                                        children: "Fallback"
+                                    }),
+                                    " on the ",
+                                    /*#__PURE__*/ _jsx("strong", {
+                                        children: entry.field
+                                    }),
+                                    " row to something like:"
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx("p", {
+                                className: "mt-1",
+                                children: /*#__PURE__*/ _jsx("code", {
+                                    className: theme.code,
+                                    children: template
+                                })
+                            }),
+                            /*#__PURE__*/ _jsxs("p", {
+                                className: "mt-1",
+                                children: [
+                                    "Pair it with the ",
+                                    /*#__PURE__*/ _jsx("strong", {
+                                        children: "E-mail safe"
+                                    }),
+                                    " transform and ",
+                                    /*#__PURE__*/ _jsx("em", {
+                                        children: "Ayşe Yılmaz"
+                                    }),
+                                    ' ',
+                                    "becomes ",
+                                    /*#__PURE__*/ _jsx("em", {
+                                        children: "ayse.yilmaz@example.com"
+                                    }),
+                                    ". Records that already carry an address keep the one they have — the fallback is only used when the source is empty."
+                                ]
+                            })
+                        ]
+                    }) : /*#__PURE__*/ _jsx("p", {
+                        children: `Nothing in this import fills ${entry.field}, and the table will not accept a row without it. Either map a source field to it, or give that row a Fallback — a fixed value, or one built from other fields with {braces}.`
+                    }),
+                    onEditMapping ? /*#__PURE__*/ _jsx("button", {
+                        className: `${theme.button.secondary} mt-3`,
+                        onClick: onEditMapping,
+                        type: "button",
+                        children: "Open the mapping"
+                    }) : null
+                ]
+            }, entry.field);
+        })
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunPlanSuggestions.test.d.ts

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