nucleus-core-ts 0.9.816 → 0.9.818

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

@@ -1,2 +1,2 @@
 import type { IntegrationsPageProps } from '../types';
-export declare function IntegrationsPage({ title, subtitle, className, actions, labels: labelsOverride, focusTargetEntity, onSubscribeProgress, }: IntegrationsPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function IntegrationsPage({ title, subtitle, className, actions, labels: labelsOverride, focusTargetEntity, focusStep, onSubscribeProgress, }: IntegrationsPageProps): import("react/jsx-runtime").JSX.Element;

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

@@ -25,7 +25,7 @@ import { RunsTab } from './RunsTab';
  * page from the server rather than being handed a list to slice.
  */ gsap.registerPlugin(useGSAP);
 const theme = integrationsPageTheme;
-export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect an external service, describe the data you want and import it on your terms.', className, actions, labels: labelsOverride, focusTargetEntity, onSubscribeProgress }) {
+export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect an external service, describe the data you want and import it on your terms.', className, actions, labels: labelsOverride, focusTargetEntity, focusStep, onSubscribeProgress }) {
     const store = useIntegrationsStore();
     // Resolved here rather than read from the context, because this component is
     // the one that PROVIDES it — and passed down so a control four levels deep
@@ -92,12 +92,13 @@ export function IntegrationsPage({ title = 'Integrations', subtitle = 'Connect a
    * is chosen for them. With several, the choice is real and stays theirs.
    */ const takeFocus = useEffectEvent(()=>{
         if (!focusTargetEntity) return;
-        store.setFocusTargetEntity(focusTargetEntity);
+        store.setFocusTargetEntity(focusTargetEntity, focusStep ?? 'mapping');
     });
     useEffect(()=>{
         takeFocus();
     }, [
-        focusTargetEntity
+        focusTargetEntity,
+        focusStep
     ]);
     const followFocus = useEffectEvent(()=>{
         if (!store.focusTargetEntity) return;

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

@@ -26,5 +26,19 @@ export type MappingEditorProps = {
     onSave: (draft: MappingDraft) => void;
     onDelete: (id: string) => void;
     onCancel: () => void;
+    /**
+     * Go and import with this mapping.
+     *
+     * The import lives on its own step, and it should: it is the destructive one,
+     * and it wants the whole width for a preview. But somebody who has just
+     * finished describing a mapping wants to RUN it, and leaving them to find the
+     * step themselves is the panel forgetting what they were doing. Absent for an
+     * unsaved mapping, because there is nothing to run yet.
+     *
+     * The DRAFT is handed over, not the id: what is on screen is what the operator
+     * means to run, so edits they have not saved yet are saved on the way rather
+     * than quietly ignored by an import of the older version.
+     */
+    onRunImport?: (draft: MappingDraft) => void;
 };
-export declare function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel, }: MappingEditorProps): import("react/jsx-runtime").JSX.Element;
+export declare function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel, onRunImport, }: MappingEditorProps): import("react/jsx-runtime").JSX.Element;

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

@@ -21,7 +21,7 @@ import { CardSkeleton } from './Skeletons';
  * Mount it with a `key` of the mapping id so switching rows starts a fresh
  * draft instead of pouring one mapping's edits into another.
  */ const theme = integrationsPageTheme;
-export function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel }) {
+export function MappingEditor({ mapping, targets, targetsLoading, endpoints, freshSample, saving, deleting, onSave, onDelete, onCancel, onRunImport }) {
     const labels = useLabels();
     const uid = useId();
     const [draft, setDraft] = useState(mapping);
@@ -236,6 +236,13 @@ export function MappingEditor({ mapping, targets, targetsLoading, endpoints, fre
                         type: "button",
                         children: "Cancel"
                     }),
+                    draft.id && onRunImport ? /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: busy,
+                        onClick: ()=>onRunImport(draft),
+                        type: "button",
+                        children: "Preview and import"
+                    }) : null,
                     /*#__PURE__*/ _jsx("button", {
                         className: theme.button.primary,
                         disabled: busy || issues.length > 0,

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

@@ -95,6 +95,7 @@ export function MappingsTab({ actions }) {
    */ const followFocus = useEffectEvent(()=>{
         const entity = store.focusTargetEntity;
         if (!entity || sourceId === '') return;
+        const step = store.focusStep;
         store.setFocusTargetEntity(null);
         actions.listMappings(sourceId, {
             page: 1,
@@ -110,6 +111,9 @@ export function MappingsTab({ actions }) {
             const found = result.items[0];
             if (found) {
                 openMapping(found);
+                // "Fill this table now" is a different errand from "describe how it is
+                // filled", and both are offered from the table itself.
+                if (step === 'import') store.setTab('runs');
                 return;
             }
             setSelected(null);
@@ -132,7 +136,7 @@ export function MappingsTab({ actions }) {
         setSelected(null);
         store.selectMapping(null);
     };
-    const save = (draft)=>{
+    const save = (draft, then)=>{
         setSaving(true);
         store.setError(null);
         actions.saveMapping(draft).then((saved)=>{
@@ -142,11 +146,31 @@ export function MappingsTab({ actions }) {
             setSelected(saved);
             store.selectMapping(saved.id);
             setReloadToken((token)=>token + 1);
+            then?.(saved);
         }).catch((error)=>{
             setSaving(false);
             store.setError(messageOf(error));
         });
     };
+    /**
+   * Take this mapping to the import step.
+   *
+   * Saved first when it differs from what is stored: the operator is looking at
+   * the version they mean to run, and importing the older one instead — with no
+   * sign that it happened — is the worst kind of quiet.
+   */ const runImport = (draft)=>{
+        const stored = selected ? toMappingDraft(selected) : null;
+        const dirty = !stored || JSON.stringify(stored) !== JSON.stringify(draft);
+        const go = (id)=>{
+            store.selectMapping(id);
+            store.setTab('runs');
+        };
+        if (!dirty && draft.id) {
+            go(draft.id);
+            return;
+        }
+        save(draft, (saved)=>go(saved.id));
+    };
     const remove = (id)=>{
         if (id === '') return;
         setDeleting(true);
@@ -213,6 +237,7 @@ export function MappingsTab({ actions }) {
                             mapping: draft,
                             onCancel: closeEditor,
                             onDelete: remove,
+                            onRunImport: runImport,
                             onSave: save,
                             saving: saving,
                             targets: targets,

package/dist/fe/components/IntegrationsPage/store/index.js

@@ -41,8 +41,9 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                 store.plan = null;
                 store.error = null;
             }),
-    setFocusTargetEntity: (store)=>(entity)=>{
+    setFocusTargetEntity: (store)=>(entity, step)=>{
             store.focusTargetEntity = entity;
+            if (step) store.focusStep = step;
         },
     setTab: (store)=>(tab)=>{
             store.tab = tab;

package/dist/fe/components/IntegrationsPage/store/state.d.ts

@@ -29,6 +29,8 @@ export type State = {
      * later click on another mapping is not dragged back.
      */
     focusTargetEntity: string | null;
+    /** Whether that caller wanted to DESCRIBE the import or RUN it. */
+    focusStep: 'mapping' | 'import';
     endpoints: IntegrationEndpoint[];
     endpointsTotal: number;
     endpointsPage: number;
@@ -65,7 +67,7 @@ export type Actions = {
     setSourcesLoading: (loading: boolean) => void;
     selectSource: (id: string | null) => void;
     setTab: (tab: ConnectionTab) => void;
-    setFocusTargetEntity: (entity: string | null) => void;
+    setFocusTargetEntity: (entity: string | null, step?: 'mapping' | 'import') => void;
     setEndpoints: (items: IntegrationEndpoint[], total: number) => void;
     /**
      * Just the count, without the rows.

package/dist/fe/components/IntegrationsPage/store/state.js

@@ -7,6 +7,7 @@ export const initial = {
     selectedSourceId: null,
     tab: 'connection',
     focusTargetEntity: null,
+    focusStep: 'mapping',
     endpoints: [],
     endpointsTotal: 0,
     endpointsPage: 1,

package/dist/fe/components/IntegrationsPage/types/actions.d.ts

@@ -106,6 +106,14 @@ export type IntegrationsPageProps = {
      * it — instead of on a chooser the caller has already answered.
      */
     focusTargetEntity?: string;
+    /**
+     * What they came to do with it.
+     *
+     * "Describe how this table is filled" and "fill it now" are two different
+     * errands, and a management screen offers both. Landing on the wrong one
+     * means finding the right step by hand — which is what the button was for.
+     */
+    focusStep?: 'mapping' | 'import';
     /**
      * The panel's own words, in the app's language.
      *