nucleus-core-ts 0.9.781 → 0.9.783

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

@@ -0,0 +1,40 @@
+import type { IntegrationMapping } from '../types';
+/**
+ * The mapping while it is being edited.
+ *
+ * It is deliberately NOT `IntegrationMapping`: a mapping being written has no id
+ * yet, and the fields the server owns — when it last ran, what it wrote — are not
+ * the operator's to edit and must not be posted back as if they were.
+ */
+/** One entity an import is allowed to write into, as the app reported it. */
+export type MappingTarget = {
+    entity: string;
+    label: string;
+    fields: string[];
+};
+export type MappingDraft = {
+    /** Absent until the mapping has been saved once. */
+    id?: string;
+    endpointId: string;
+    name: string;
+    targetEntity: string;
+    fieldMappings: IntegrationMapping['fieldMappings'];
+    dedupSourceField?: string | null;
+    dedupTargetField?: string | null;
+    writeMode: IntegrationMapping['writeMode'];
+    missingRecordPolicy: IntegrationMapping['missingRecordPolicy'];
+    missingRecordColumn?: string | null;
+    missingRecordValue?: string | null;
+    enabled?: boolean;
+};
+/** Upsert and ignore: the two choices that cannot lose a row by themselves. */
+export declare function blankMappingDraft(endpointId: string): MappingDraft;
+/** Copies field by field so a column the server added cannot ride along unseen. */
+export declare function toMappingDraft(mapping: IntegrationMapping): MappingDraft;
+/**
+ * Everything standing between this draft and a run that does what it says.
+ *
+ * Reported as a list rather than a boolean because "Save is greyed out" with no
+ * reason is the single most common way a form wastes somebody's afternoon.
+ */
+export declare function mappingDraftIssues(draft: MappingDraft): string[];

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

@@ -0,0 +1,44 @@
+import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
+/** Upsert and ignore: the two choices that cannot lose a row by themselves. */ export function blankMappingDraft(endpointId) {
+    return {
+        endpointId,
+        name: '',
+        targetEntity: '',
+        fieldMappings: [],
+        writeMode: 'upsert',
+        missingRecordPolicy: 'ignore'
+    };
+}
+/** Copies field by field so a column the server added cannot ride along unseen. */ export function toMappingDraft(mapping) {
+    return {
+        id: mapping.id,
+        endpointId: mapping.endpointId,
+        name: mapping.name,
+        targetEntity: mapping.targetEntity,
+        fieldMappings: mapping.fieldMappings,
+        dedupSourceField: mapping.dedupSourceField,
+        dedupTargetField: mapping.dedupTargetField,
+        writeMode: mapping.writeMode,
+        missingRecordPolicy: mapping.missingRecordPolicy,
+        missingRecordColumn: mapping.missingRecordColumn,
+        missingRecordValue: mapping.missingRecordValue,
+        enabled: mapping.enabled
+    };
+}
+/**
+ * Everything standing between this draft and a run that does what it says.
+ *
+ * Reported as a list rather than a boolean because "Save is greyed out" with no
+ * reason is the single most common way a form wastes somebody's afternoon.
+ */ export function mappingDraftIssues(draft) {
+    const issues = [];
+    if (draft.name.trim() === '') issues.push('Give the mapping a name.');
+    if (draft.targetEntity.trim() === '') issues.push('Choose a target entity.');
+    if (draft.endpointId.trim() === '') issues.push('Select the endpoint this mapping reads from.');
+    const usable = draft.fieldMappings.some((row)=>row.target.trim() !== '' && (row.source.trim() !== '' || (row.constant ?? '').trim() !== ''));
+    if (!usable) issues.push('Map at least one field to a target column.');
+    if (missingRecordFieldsIncomplete(draft.missingRecordPolicy, draft.missingRecordColumn ?? '', draft.missingRecordValue ?? '')) {
+        issues.push('Deactivate needs both a column and the value to write into it.');
+    }
+    return issues;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Reading the parameter names out of an endpoint path.
+ *
+ * Shared by the sample screen, which asks for a value by hand, and the binding
+ * editor, which asks where the value should come from on a real run. One reader
+ * so the two screens can never disagree about what a path needs.
+ */
+/** `{brace}` and `:colon` are both accepted, so both are read back. */
+export declare function pathParamNames(path: string): string[];

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

@@ -0,0 +1,15 @@
+/**
+ * Reading the parameter names out of an endpoint path.
+ *
+ * Shared by the sample screen, which asks for a value by hand, and the binding
+ * editor, which asks where the value should come from on a real run. One reader
+ * so the two screens can never disagree about what a path needs.
+ */ const PARAM_PATTERN = /\{([^{}]+)\}|:([A-Za-z_][A-Za-z0-9_]*)/g;
+/** `{brace}` and `:colon` are both accepted, so both are read back. */ export function pathParamNames(path) {
+    const names = [];
+    for (const match of path.matchAll(PARAM_PATTERN)){
+        const name = match[1] ?? match[2];
+        if (name && !names.includes(name)) names.push(name);
+    }
+    return names;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * The small conversions the run screens share.
+ *
+ * Nothing here touches the server or React — it turns a record into the words an
+ * operator reads, and it does so the SAME way in every place, so a duration on a
+ * history row cannot disagree with the one on the panel above it.
+ */
+import type { IntegrationMapping, IntegrationRun, RunPlanValue, RunStatusValue } from '../types';
+import type { BadgeTone } from './Primitives';
+/** A run's outcome, coloured. Reverted is deliberately calm: nothing is wrong with it. */
+export declare const RUN_STATUS_TONE: Record<RunStatusValue, BadgeTone>;
+export declare function errorText(error: unknown, fallback: string): string;
+/**
+ * A moment, in UTC.
+ *
+ * Deliberately not locale-formatted: `toLocaleString` reads the server's zone on
+ * the server and the browser's on the client, so the two renders differ and the
+ * row tears on hydration. UTC is the same number everywhere, and it is labelled.
+ */
+export declare function formatMoment(value?: string | null): string;
+export declare function formatDuration(startedAt?: string | null, finishedAt?: string | null): string;
+/** Milliseconds of an instant, or null when the field is absent or unparseable. */
+export declare function toEpochMs(value?: string | null): number | null;
+/** The counts of a finished run, in one line. Zeros of the rare kinds stay hidden. */
+export declare function countersLine(run: IntegrationRun): string;
+/**
+ * What a destructive run takes away, counted wherever there is a plan to count from.
+ *
+ * The mapping alone can say WHAT will happen; only the plan can say to how many
+ * rows. Both wordings exist because an operator is allowed to skip the preview,
+ * and a confirmation that says "some rows" is not a confirmation.
+ */
+export declare function describeLosses(mapping: IntegrationMapping, plan: RunPlanValue | null): string[];

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

@@ -0,0 +1,85 @@
+/**
+ * The small conversions the run screens share.
+ *
+ * Nothing here touches the server or React — it turns a record into the words an
+ * operator reads, and it does so the SAME way in every place, so a duration on a
+ * history row cannot disagree with the one on the panel above it.
+ */ /** A run's outcome, coloured. Reverted is deliberately calm: nothing is wrong with it. */ export const RUN_STATUS_TONE = {
+    queued: 'neutral',
+    running: 'info',
+    succeeded: 'success',
+    failed: 'danger',
+    cancelled: 'warning',
+    reverted: 'neutral'
+};
+export function errorText(error, fallback) {
+    return error instanceof Error && error.message ? error.message : fallback;
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+/**
+ * A moment, in UTC.
+ *
+ * Deliberately not locale-formatted: `toLocaleString` reads the server's zone on
+ * the server and the browser's on the client, so the two renders differ and the
+ * row tears on hydration. UTC is the same number everywhere, and it is labelled.
+ */ export function formatMoment(value) {
+    if (!value) return '—';
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return '—';
+    const day = `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())}`;
+    return `${day} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())} UTC`;
+}
+export function formatDuration(startedAt, finishedAt) {
+    if (!startedAt || !finishedAt) return '—';
+    const start = new Date(startedAt).getTime();
+    const end = new Date(finishedAt).getTime();
+    if (Number.isNaN(start) || Number.isNaN(end) || end < start) return '—';
+    const seconds = Math.round((end - start) / 1000);
+    if (seconds < 60) return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+/** Milliseconds of an instant, or null when the field is absent or unparseable. */ export function toEpochMs(value) {
+    if (!value) return null;
+    const ms = new Date(value).getTime();
+    return Number.isNaN(ms) ? null : ms;
+}
+/** The counts of a finished run, in one line. Zeros of the rare kinds stay hidden. */ export function countersLine(run) {
+    const parts = [
+        `${run.createdCount} created`,
+        `${run.updatedCount} updated`,
+        `${run.skippedCount} skipped`
+    ];
+    if (run.deletedCount > 0) parts.push(`${run.deletedCount} deleted`);
+    if (run.deactivatedCount > 0) parts.push(`${run.deactivatedCount} deactivated`);
+    if (run.errorCount > 0) parts.push(`${run.errorCount} failed`);
+    return parts.join(' · ');
+}
+/**
+ * What a destructive run takes away, counted wherever there is a plan to count from.
+ *
+ * The mapping alone can say WHAT will happen; only the plan can say to how many
+ * rows. Both wordings exist because an operator is allowed to skip the preview,
+ * and a confirmation that says "some rows" is not a confirmation.
+ */ export function describeLosses(mapping, plan) {
+    const lines = [];
+    const target = mapping.targetEntity;
+    if (mapping.writeMode === 'replace') {
+        lines.push(plan ? `Write mode is "replace": the ${plan.existingCount} row(s) already in ${target} are removed before this import writes.` : `Write mode is "replace": every row already in ${target} is removed before this import writes.`);
+    }
+    if (mapping.missingRecordPolicy === 'delete') {
+        lines.push(plan ? `${plan.missing} row(s) in ${target} are no longer returned by the source and will be DELETED.` : `Rows in ${target} the source no longer returns will be DELETED.`);
+    }
+    if (mapping.missingRecordPolicy === 'deactivate') {
+        const column = mapping.missingRecordColumn ?? 'the configured column';
+        const value = mapping.missingRecordValue ?? 'the configured value';
+        lines.push(plan ? `${plan.missing} row(s) missing from the source will have ${column} set to ${value}.` : `Rows missing from the source will have ${column} set to ${value}.`);
+    }
+    if (lines.length === 0) {
+        lines.push(`This run writes into ${target}. Rows it overwrites can be restored only while this run's pre-images are kept.`);
+    }
+    return lines;
+}

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

@@ -0,0 +1,40 @@
+import { type RefObject } from 'react';
+/**
+ * A list the SERVER pages.
+ *
+ * The hook never filters, sorts or searches what it holds — it asks for page 1,
+ * then page 2, and keeps exactly what came back. Anything the operator types
+ * belongs in `deps`, and a change there throws the old rows away before the new
+ * ones arrive, because a stale list under a new search term is not "still
+ * loading", it is wrong.
+ */
+export type InfiniteListPage<T> = {
+    items: T[];
+    total: number;
+};
+export type UseInfiniteListOptions<T> = {
+    /** Fetches one page. Page numbers start at 1. */
+    load: (page: number) => Promise<InfiniteListPage<T>>;
+    /** Search terms, filters, the selected parent id — anything that redefines the list. */
+    deps: unknown[];
+    pageSize?: number;
+};
+export type UseInfiniteListResult<T> = {
+    items: T[];
+    total: number;
+    loading: boolean;
+    /**
+     * What went wrong, when it did.
+     *
+     * Without this a failed request left an empty list, and every caller rendered
+     * its "nothing here yet" state — telling an operator the connection has no
+     * endpoints when the truth was that the request was refused. That exact
+     * confusion is one of the defects this panel was written to remove, so the
+     * hook reports the failure and the caller must show it.
+     */
+    error: string | null;
+    /** Put this on an element after the last row; seeing it asks for the next page. */
+    sentinelRef: RefObject<HTMLDivElement | null>;
+    reload: () => void;
+};
+export declare function useInfiniteList<T>(options: UseInfiniteListOptions<T>): UseInfiniteListResult<T>;

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

@@ -0,0 +1,110 @@
+'use client';
+import { useEffect, useEffectEvent, useRef, useState } from 'react';
+const DEFAULT_PAGE_SIZE = 20;
+export function useInfiniteList(options) {
+    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    /**
+   * The caller's deps as ONE value.
+   *
+   * Spreading them into the dependency array made its LENGTH depend on the
+   * caller, and React requires that length to be constant across renders — an
+   * array that grows or shrinks silently stops the effect re-running when it
+   * should. Collapsing to a string keeps one slot no matter how many things the
+   * caller watches.
+   */ const depsKey = JSON.stringify(options.deps);
+    const [items, setItems] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [reloadToken, setReloadToken] = useState(0);
+    const sentinelRef = useRef(null);
+    const nextPageRef = useRef(1);
+    const loadedCountRef = useRef(0);
+    const inFlightRef = useRef(false);
+    const exhaustedRef = useRef(false);
+    /** Bumped on every reset; a reply from an older generation is dropped. */ const generationRef = useRef(0);
+    const fetchPage = useEffectEvent((page)=>{
+        if (inFlightRef.current || exhaustedRef.current) return;
+        const generation = generationRef.current;
+        inFlightRef.current = true;
+        setLoading(true);
+        options.load(page).then((result)=>{
+            if (generation !== generationRef.current) return;
+            inFlightRef.current = false;
+            setLoading(false);
+            setTotal(result.total);
+            setItems((previous)=>page === 1 ? result.items : [
+                    ...previous,
+                    ...result.items
+                ]);
+            const loaded = (page === 1 ? 0 : loadedCountRef.current) + result.items.length;
+            loadedCountRef.current = loaded;
+            nextPageRef.current = page + 1;
+            // A short page means the end. The count check is the belt to that
+            // braces: a server that always fills a page still stops at its total.
+            exhaustedRef.current = result.items.length < pageSize || result.total > 0 && loaded >= result.total;
+        }).catch((reason)=>{
+            if (generation !== generationRef.current) return;
+            inFlightRef.current = false;
+            setLoading(false);
+            setError(reason instanceof Error ? reason.message : String(reason));
+            // Stop asking. The sentinel stays on screen, so retrying on failure
+            // would hammer a broken endpoint for as long as the panel is open;
+            // `reload()` is how the operator tries again.
+            exhaustedRef.current = true;
+        });
+    });
+    const requestNextPage = useEffectEvent(()=>{
+        fetchPage(nextPageRef.current);
+    });
+    // Reset. The cleanup retires the generation, so a page still in flight when
+    // the search term changes — or when the panel unmounts — writes nothing.
+    useEffect(()=>{
+        inFlightRef.current = false;
+        exhaustedRef.current = false;
+        nextPageRef.current = 1;
+        loadedCountRef.current = 0;
+        setItems([]);
+        setTotal(0);
+        setLoading(true);
+        setError(null);
+        fetchPage(1);
+        return ()=>{
+            generationRef.current += 1;
+        };
+    // biome-ignore lint/correctness/useExhaustiveDependencies: the caller deps are
+    // collapsed into depsKey on purpose; see the comment on it.
+    }, [
+        depsKey,
+        reloadToken
+    ]);
+    // Rebinding as the list grows is deliberate: when a page is shorter than the
+    // viewport the sentinel never LEAVES the screen, so the observer would have
+    // no crossing left to report and the list would stall one page in.
+    useEffect(()=>{
+        const node = sentinelRef.current;
+        if (!node) return;
+        const observer = new IntersectionObserver((entries)=>{
+            if (entries[0]?.isIntersecting) requestNextPage();
+        }, {
+            rootMargin: '96px'
+        });
+        observer.observe(node);
+        return ()=>{
+            observer.disconnect();
+        };
+    }, [
+        items.length
+    ]);
+    const reload = ()=>{
+        setReloadToken((token)=>token + 1);
+    };
+    return {
+        items,
+        total,
+        loading,
+        error,
+        sentinelRef,
+        reload
+    };
+}

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

@@ -0,0 +1,18 @@
+export { ConnectionList } from './components/ConnectionList';
+export type { ConnectionTabsProps } from './components/ConnectionTabs';
+export { ConnectionTabs, connectionTabId, connectionTabPanelId } from './components/ConnectionTabs';
+export { EndpointsTab } from './components/EndpointsTab';
+export { IntegrationsPage } from './components/IntegrationsPage';
+export { MappingsTab } from './components/MappingsTab';
+export type { BadgeProps, BadgeTone, CodeBlockProps, FieldProps, NoticeProps, NoticeTone, StatProps, } from './components/Primitives';
+export { Badge, CodeBlock, Field, Notice, Stat } from './components/Primitives';
+export { RunsTab } from './components/RunsTab';
+export type { ListSkeletonProps } from './components/Skeletons';
+export { CardSkeleton, ListSkeleton, StatGridSkeleton } from './components/Skeletons';
+export type { InfiniteListPage, UseInfiniteListOptions, UseInfiniteListResult, } from './components/useInfiniteList';
+export { useInfiniteList } from './components/useInfiniteList';
+export { useIntegrationsStore } from './store';
+export type { ConnectionTab } from './store/state';
+export type { IntegrationsPageTheme } from './theme';
+export { extendIntegrationsTheme, integrationsPageTheme } from './theme';
+export type * from './types';

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

@@ -0,0 +1,11 @@
+export { ConnectionList } from './components/ConnectionList';
+export { ConnectionTabs, connectionTabId, connectionTabPanelId } from './components/ConnectionTabs';
+export { EndpointsTab } from './components/EndpointsTab';
+export { IntegrationsPage } from './components/IntegrationsPage';
+export { MappingsTab } from './components/MappingsTab';
+export { Badge, CodeBlock, Field, Notice, Stat } from './components/Primitives';
+export { RunsTab } from './components/RunsTab';
+export { CardSkeleton, ListSkeleton, StatGridSkeleton } from './components/Skeletons';
+export { useInfiniteList } from './components/useInfiniteList';
+export { useIntegrationsStore } from './store';
+export { extendIntegrationsTheme, integrationsPageTheme } from './theme';

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

@@ -0,0 +1,2 @@
+import { type Actions, type State } from './state';
+export declare const useIntegrationsStore: () => import("h-state").StoreType<State, Actions>;

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

@@ -0,0 +1,124 @@
+'use client';
+import { batch, createStore } from 'h-state';
+import { initial } from './state';
+export const { useStore: useIntegrationsStore } = createStore(initial, {
+    setSources: (store)=>(items, total)=>batch(()=>{
+                store.sources = items;
+                store.sourcesTotal = total;
+                store.sourcesLoading = false;
+            }),
+    setSourcesPage: (store)=>(page)=>{
+            store.sourcesPage = page;
+        },
+    setSourcesSearch: (store)=>(search)=>batch(()=>{
+                store.sourcesSearch = search;
+                // A new search is a new result set; staying on page 4 would show an empty
+                // list and read as "no matches".
+                store.sourcesPage = 1;
+            }),
+    setSourcesLoading: (store)=>(loading)=>{
+            store.sourcesLoading = loading;
+        },
+    selectSource: (store)=>(id)=>batch(()=>{
+                store.selectedSourceId = id;
+                // Everything below a connection belongs to THAT connection. Leaving the
+                // previous one's endpoints on screen under a new name is worse than empty.
+                store.tab = 'connection';
+                store.endpoints = [];
+                store.endpointsTotal = 0;
+                store.endpointsPage = 1;
+                store.endpointsSearch = '';
+                store.selectedEndpointId = null;
+                store.mappings = [];
+                store.mappingsTotal = 0;
+                store.mappingsPage = 1;
+                store.mappingsSearch = '';
+                store.selectedMappingId = null;
+                store.runs = [];
+                store.runsTotal = 0;
+                store.runsPage = 1;
+                store.sample = null;
+                store.plan = null;
+                store.error = null;
+            }),
+    setTab: (store)=>(tab)=>{
+            store.tab = tab;
+        },
+    setEndpoints: (store)=>(items, total)=>batch(()=>{
+                store.endpoints = items;
+                store.endpointsTotal = total;
+                store.endpointsLoading = false;
+            }),
+    setEndpointsPage: (store)=>(page)=>{
+            store.endpointsPage = page;
+        },
+    setEndpointsSearch: (store)=>(search)=>batch(()=>{
+                store.endpointsSearch = search;
+                store.endpointsPage = 1;
+            }),
+    setEndpointsLoading: (store)=>(loading)=>{
+            store.endpointsLoading = loading;
+        },
+    selectEndpoint: (store)=>(id)=>batch(()=>{
+                store.selectedEndpointId = id;
+                // The sample describes ONE endpoint; carrying it over would offer the
+                // wrong field list to the next mapping.
+                store.sample = null;
+            }),
+    setMappings: (store)=>(items, total)=>batch(()=>{
+                store.mappings = items;
+                store.mappingsTotal = total;
+                store.mappingsLoading = false;
+            }),
+    setMappingsPage: (store)=>(page)=>{
+            store.mappingsPage = page;
+        },
+    setMappingsSearch: (store)=>(search)=>batch(()=>{
+                store.mappingsSearch = search;
+                store.mappingsPage = 1;
+            }),
+    setMappingsLoading: (store)=>(loading)=>{
+            store.mappingsLoading = loading;
+        },
+    selectMapping: (store)=>(id)=>batch(()=>{
+                store.selectedMappingId = id;
+                // A plan belongs to the mapping it was computed for. Showing it against a
+                // different one would have an operator approve counts from another import.
+                store.plan = null;
+            }),
+    setRuns: (store)=>(items, total)=>batch(()=>{
+                store.runs = items;
+                store.runsTotal = total;
+                store.runsLoading = false;
+            }),
+    setRunsPage: (store)=>(page)=>{
+            store.runsPage = page;
+        },
+    setRunsLoading: (store)=>(loading)=>{
+            store.runsLoading = loading;
+        },
+    setSample: (store)=>(sample)=>batch(()=>{
+                store.sample = sample;
+                store.sampling = false;
+            }),
+    setSampling: (store)=>(sampling)=>{
+            store.sampling = sampling;
+        },
+    setPlan: (store)=>(plan)=>batch(()=>{
+                store.plan = plan;
+                store.planning = false;
+            }),
+    setPlanning: (store)=>(planning)=>{
+            store.planning = planning;
+        },
+    setProgress: (store)=>(progress)=>{
+            store.progress = progress;
+        },
+    setActiveRun: (store)=>(runId)=>batch(()=>{
+                store.activeRunId = runId;
+                store.progress = null;
+            }),
+    setError: (store)=>(error)=>{
+            store.error = error;
+        }
+});

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

@@ -0,0 +1,80 @@
+import type { EndpointSampleValue, IntegrationEndpoint, IntegrationMapping, IntegrationRun, IntegrationSource, RunPlanValue, RunProgressValue } from '../types';
+/**
+ * Panel state.
+ *
+ * Lists live here as the CURRENT PAGE only, never the whole table — the server
+ * pages, filters, searches and sorts, so holding more would mean the client had
+ * fetched more than it shows, which is the thing this design refuses to do.
+ *
+ * The selection is the spine: choosing a connection is what gives the endpoint,
+ * mapping and run lists something to be about. Clearing it clears them, so no
+ * screen can show one connection's endpoints under another's name.
+ */
+export type ConnectionTab = 'connection' | 'endpoints' | 'mappings' | 'runs';
+export type State = {
+    [key: string]: unknown;
+    sources: IntegrationSource[];
+    sourcesTotal: number;
+    sourcesPage: number;
+    sourcesSearch: string;
+    sourcesLoading: boolean;
+    selectedSourceId: string | null;
+    tab: ConnectionTab;
+    endpoints: IntegrationEndpoint[];
+    endpointsTotal: number;
+    endpointsPage: number;
+    endpointsSearch: string;
+    endpointsLoading: boolean;
+    selectedEndpointId: string | null;
+    mappings: IntegrationMapping[];
+    mappingsTotal: number;
+    mappingsPage: number;
+    mappingsSearch: string;
+    mappingsLoading: boolean;
+    selectedMappingId: string | null;
+    runs: IntegrationRun[];
+    runsTotal: number;
+    runsPage: number;
+    runsLoading: boolean;
+    /** The real shape of the selected endpoint's response, once sampled. */
+    sample: EndpointSampleValue | null;
+    sampling: boolean;
+    /** What a run would do. Cleared whenever the mapping changes underneath it. */
+    plan: RunPlanValue | null;
+    planning: boolean;
+    /** Live progress of the run this panel started. */
+    progress: RunProgressValue | null;
+    activeRunId: string | null;
+    /** Whatever went wrong last, in words an operator can act on. */
+    error: string | null;
+};
+export type Actions = {
+    [key: string]: unknown;
+    setSources: (items: IntegrationSource[], total: number) => void;
+    setSourcesPage: (page: number) => void;
+    setSourcesSearch: (search: string) => void;
+    setSourcesLoading: (loading: boolean) => void;
+    selectSource: (id: string | null) => void;
+    setTab: (tab: ConnectionTab) => void;
+    setEndpoints: (items: IntegrationEndpoint[], total: number) => void;
+    setEndpointsPage: (page: number) => void;
+    setEndpointsSearch: (search: string) => void;
+    setEndpointsLoading: (loading: boolean) => void;
+    selectEndpoint: (id: string | null) => void;
+    setMappings: (items: IntegrationMapping[], total: number) => void;
+    setMappingsPage: (page: number) => void;
+    setMappingsSearch: (search: string) => void;
+    setMappingsLoading: (loading: boolean) => void;
+    selectMapping: (id: string | null) => void;
+    setRuns: (items: IntegrationRun[], total: number) => void;
+    setRunsPage: (page: number) => void;
+    setRunsLoading: (loading: boolean) => void;
+    setSample: (sample: EndpointSampleValue | null) => void;
+    setSampling: (sampling: boolean) => void;
+    setPlan: (plan: RunPlanValue | null) => void;
+    setPlanning: (planning: boolean) => void;
+    setProgress: (progress: RunProgressValue | null) => void;
+    setActiveRun: (runId: string | null) => void;
+    setError: (error: string | null) => void;
+};
+export declare const initial: State;

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

@@ -0,0 +1,32 @@
+export const initial = {
+    sources: [],
+    sourcesTotal: 0,
+    sourcesPage: 1,
+    sourcesSearch: '',
+    sourcesLoading: false,
+    selectedSourceId: null,
+    tab: 'connection',
+    endpoints: [],
+    endpointsTotal: 0,
+    endpointsPage: 1,
+    endpointsSearch: '',
+    endpointsLoading: false,
+    selectedEndpointId: null,
+    mappings: [],
+    mappingsTotal: 0,
+    mappingsPage: 1,
+    mappingsSearch: '',
+    mappingsLoading: false,
+    selectedMappingId: null,
+    runs: [],
+    runsTotal: 0,
+    runsPage: 1,
+    runsLoading: false,
+    sample: null,
+    sampling: false,
+    plan: null,
+    planning: false,
+    progress: null,
+    activeRunId: null,
+    error: null
+};