nucleus-core-ts 0.9.782 → 0.9.783

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

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { useIntegrationsStore } from '../store';
+import { Notice } from './Primitives';
+import { RunHistory } from './RunHistory';
+import { RunPanel } from './RunPanel';
+export function RunsTab({ actions, onSubscribeProgress }) {
+    const store = useIntegrationsStore();
+    // A lookup by id, not a list operation: the selected mapping is on the page the
+    // server already returned, and nothing here filters, sorts or pages it.
+    const selectedId = store.selectedMappingId;
+    const mapping = selectedId ? store.mappings.find((item)=>item.id === selectedId) : undefined;
+    const [refreshKey, setRefreshKey] = useState(0);
+    const refresh = ()=>{
+        setRefreshKey((key)=>key + 1);
+    };
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-4",
+        children: [
+            mapping ? /*#__PURE__*/ _jsx(RunPanel, {
+                actions: actions,
+                mapping: mapping,
+                onRunSettled: refresh,
+                onSubscribeProgress: onSubscribeProgress
+            }) : /*#__PURE__*/ _jsx(Notice, {
+                tone: "info",
+                title: "Choose a mapping to preview or run an import",
+                children: "A mapping is what says which endpoint feeds which target entity, and how missing rows are treated. Pick one on the Mappings tab; the history below still lists every run of this connection."
+            }),
+            /*#__PURE__*/ _jsx(RunHistory, {
+                actions: actions,
+                mappingId: mapping ? mapping.id : null,
+                onRefresh: refresh,
+                refreshKey: refreshKey
+            })
+        ]
+    });
+}

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

@@ -0,0 +1,9 @@
+export type ListSkeletonProps = {
+    rows: number;
+};
+/** Stands in for a list of rows while the first page is on its way. */
+export declare function ListSkeleton({ rows }: ListSkeletonProps): import("react/jsx-runtime").JSX.Element;
+/** Stands in for a card: the same header bar, the same padded body. */
+export declare function CardSkeleton(): import("react/jsx-runtime").JSX.Element;
+/** Stands in for the counts strip — six cells, the grid the real one uses. */
+export declare function StatGridSkeleton(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,139 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../../../utils/cn';
+import { integrationsPageTheme } from '../theme';
+/**
+ * The loading shapes.
+ *
+ * Each one wears the SAME layout classes as the thing it stands in for, and the
+ * grey bars sit inside boxes the height of the text they replace. That is the
+ * whole point: the list must not grow taller the moment the rows arrive, or the
+ * button the operator was reaching for moves out from under the finger.
+ */ const theme = integrationsPageTheme;
+/** Cycled so the placeholder reads as a list of different names, not a barcode. */ const TITLE_WIDTHS = [
+    'w-2/5',
+    'w-3/5',
+    'w-1/2',
+    'w-2/3'
+];
+const META_WIDTHS = [
+    'w-3/4',
+    'w-1/2',
+    'w-2/3',
+    'w-3/5'
+];
+function widthAt(widths, index) {
+    return widths[index % widths.length] ?? 'w-1/2';
+}
+/** Stands in for a list of rows while the first page is on its way. */ export function ListSkeleton({ rows }) {
+    return /*#__PURE__*/ _jsx("output", {
+        "aria-busy": "true",
+        "aria-label": "Loading list",
+        className: theme.list.wrapper,
+        children: Array.from({
+            length: Math.max(rows, 1)
+        }, (_, index)=>/*#__PURE__*/ _jsxs("div", {
+                "aria-hidden": "true",
+                className: cn(theme.list.item, 'pointer-events-none'),
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, widthAt(TITLE_WIDTHS, index))
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-4 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'h-2', widthAt(META_WIDTHS, index))
+                        })
+                    })
+                ]
+            }, `list-skeleton-${index}`))
+    });
+}
+// ── CardSkeleton ────────────────────────────────────────────────────────────
+/** Stands in for a card: the same header bar, the same padded body. */ export function CardSkeleton() {
+    return(// `output` carries role=status on its own, but it is inline by default and
+    // the card wrapper only ever styled a block, so the display is restored.
+    /*#__PURE__*/ _jsxs("output", {
+        "aria-busy": "true",
+        "aria-label": "Loading panel",
+        className: cn(theme.card.wrapper, 'block'),
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                "aria-hidden": "true",
+                className: theme.card.header,
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'w-32')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'w-16')
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                "aria-hidden": "true",
+                className: theme.card.body,
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'w-full')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'w-4/5')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: cn(theme.skeleton.block, 'h-20 w-full')
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'w-2/3')
+                        })
+                    })
+                ]
+            })
+        ]
+    }));
+}
+// ── StatGridSkeleton ────────────────────────────────────────────────────────
+/** Stands in for the counts strip — six cells, the grid the real one uses. */ export function StatGridSkeleton() {
+    return /*#__PURE__*/ _jsx("output", {
+        "aria-busy": "true",
+        "aria-label": "Loading totals",
+        className: theme.stat.grid,
+        children: Array.from({
+            length: 6
+        }, (_, index)=>/*#__PURE__*/ _jsxs("div", {
+                "aria-hidden": "true",
+                className: theme.stat.cell,
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-7 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'h-4 w-10')
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: "flex h-3.5 items-center",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: cn(theme.skeleton.line, 'h-2 w-12')
+                        })
+                    })
+                ]
+            }, `stat-skeleton-${index}`))
+    });
+}

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

@@ -0,0 +1,29 @@
+import type { IntegrationAuthType } from '../types';
+/**
+ * The three closed choices in the auth section, and the only way a `<select>`
+ * value gets back into one of them.
+ *
+ * A select hands back a plain string. Narrowing it against the list that
+ * produced the options is what keeps the draft honest without a cast — an
+ * unrecognised value is simply not applied.
+ */
+export type AuthTypeOption = {
+    value: IntegrationAuthType;
+    label: string;
+    hint: string;
+};
+export declare const AUTH_TYPE_OPTIONS: AuthTypeOption[];
+export type GrantTypeValue = 'password' | 'client_credentials';
+export type ClientAuthValue = 'basic' | 'body';
+export declare const GRANT_TYPE_OPTIONS: {
+    value: GrantTypeValue;
+    label: string;
+}[];
+export declare const CLIENT_AUTH_OPTIONS: {
+    value: ClientAuthValue;
+    label: string;
+}[];
+export declare function toAuthType(value: string): IntegrationAuthType | null;
+export declare function toGrantType(value: string): GrantTypeValue | null;
+export declare function toClientAuth(value: string): ClientAuthValue | null;
+export declare function authTypeHint(authType: IntegrationAuthType): string;

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

@@ -0,0 +1,71 @@
+export const AUTH_TYPE_OPTIONS = [
+    {
+        value: 'none',
+        label: 'None',
+        hint: 'The service is called with no credential of any kind.'
+    },
+    {
+        value: 'bearer',
+        label: 'Bearer token',
+        hint: 'A token is sent on every request, by default as Authorization: Bearer …'
+    },
+    {
+        value: 'api_key',
+        label: 'API key',
+        hint: 'A key is sent in a header or as a query parameter. Say which below.'
+    },
+    {
+        value: 'basic',
+        label: 'Basic',
+        hint: 'A user name and password pair, sent as HTTP basic authentication.'
+    },
+    {
+        value: 'oauth2',
+        label: 'OAuth 2',
+        hint: 'A token is fetched from the token endpoint before each batch of calls and refreshed when it expires.'
+    }
+];
+export const GRANT_TYPE_OPTIONS = [
+    {
+        value: 'client_credentials',
+        label: 'Client credentials'
+    },
+    {
+        value: 'password',
+        label: 'Password'
+    }
+];
+export const CLIENT_AUTH_OPTIONS = [
+    {
+        value: 'basic',
+        label: 'Authorization header (basic)'
+    },
+    {
+        value: 'body',
+        label: 'Request body'
+    }
+];
+export function toAuthType(value) {
+    for (const option of AUTH_TYPE_OPTIONS){
+        if (option.value === value) return option.value;
+    }
+    return null;
+}
+export function toGrantType(value) {
+    for (const option of GRANT_TYPE_OPTIONS){
+        if (option.value === value) return option.value;
+    }
+    return null;
+}
+export function toClientAuth(value) {
+    for (const option of CLIENT_AUTH_OPTIONS){
+        if (option.value === value) return option.value;
+    }
+    return null;
+}
+export function authTypeHint(authType) {
+    for (const option of AUTH_TYPE_OPTIONS){
+        if (option.value === authType) return option.hint;
+    }
+    return '';
+}

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

@@ -0,0 +1,64 @@
+import type { IntegrationAuthType, IntegrationSource } from '../types';
+/**
+ * The form's own copy of a connection.
+ *
+ * Every box is a string or a boolean because that is what an `<input>` gives
+ * back; the record is rebuilt on save. Keeping a half-typed timeout as `12` the
+ * NUMBER would mean the field could never hold an empty string, and "clear it
+ * and think again" is a thing an operator does constantly.
+ */
+export type ConnectionDraft = {
+    name: string;
+    slug: string;
+    baseUrl: string;
+    description: string;
+    enabled: boolean;
+    authType: IntegrationAuthType;
+    authHeaderName: string;
+    authQueryParam: string;
+    tokenUrl: string;
+    oauthGrantType: 'password' | 'client_credentials';
+    oauthClientId: string;
+    oauthUsername: string;
+    oauthScope: string;
+    oauthClientAuth: 'basic' | 'body';
+    tlsVerify: boolean;
+    timeoutMs: string;
+};
+export type ConnectionDraftErrors = {
+    name?: string;
+    slug?: string;
+    baseUrl?: string;
+    tokenUrl?: string;
+    timeoutMs?: string;
+};
+/** What each group of fields is handed. The groups are display only. */
+export type ConnectionFieldsProps = {
+    draft: ConnectionDraft;
+    errors: ConnectionDraftErrors;
+    disabled: boolean;
+    onChange: (patch: Partial<ConnectionDraft>) => void;
+};
+export declare const emptyConnectionDraft: ConnectionDraft;
+export declare function draftFromSource(source: IntegrationSource): ConnectionDraft;
+export declare function usesHeaderName(authType: IntegrationAuthType): boolean;
+export declare function usesQueryParam(authType: IntegrationAuthType): boolean;
+export declare function usesOauth(authType: IntegrationAuthType): boolean;
+/**
+ * Rebuilds the record.
+ *
+ * Fields the chosen auth type does not use are sent as null rather than left
+ * alone. Switching a connection from OAuth to a bearer token and leaving the old
+ * token URL behind is how a source ends up carrying settings nobody can see in
+ * the form but the server still reads.
+ */
+export declare function draftToSource(draft: ConnectionDraft, id?: string): Partial<IntegrationSource>;
+/**
+ * What must be filled in before a save is worth attempting.
+ *
+ * The base URL is checked for a scheme and nothing else. It is deliberately not
+ * checked for https, for a public host or for a resolvable name: an in-cluster
+ * service on plain http is a normal target, and a form that rejected it would be
+ * rejecting a working setup.
+ */
+export declare function validateConnectionDraft(draft: ConnectionDraft): ConnectionDraftErrors;

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

@@ -0,0 +1,112 @@
+export const emptyConnectionDraft = {
+    name: '',
+    slug: '',
+    baseUrl: '',
+    description: '',
+    enabled: true,
+    authType: 'none',
+    authHeaderName: '',
+    authQueryParam: '',
+    tokenUrl: '',
+    oauthGrantType: 'client_credentials',
+    oauthClientId: '',
+    oauthUsername: '',
+    oauthScope: '',
+    oauthClientAuth: 'basic',
+    // Verification on and no timeout override: the safe end of both, so a
+    // connection is only ever loosened by someone who went and loosened it.
+    tlsVerify: true,
+    timeoutMs: ''
+};
+function text(value) {
+    return value ?? '';
+}
+function orNull(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function draftFromSource(source) {
+    return {
+        name: source.name,
+        slug: source.slug,
+        baseUrl: source.baseUrl,
+        description: text(source.description),
+        enabled: source.enabled !== false,
+        authType: source.authType,
+        authHeaderName: text(source.authHeaderName),
+        authQueryParam: text(source.authQueryParam),
+        tokenUrl: text(source.tokenUrl),
+        oauthGrantType: source.oauthGrantType ?? 'client_credentials',
+        oauthClientId: text(source.oauthClientId),
+        oauthUsername: text(source.oauthUsername),
+        oauthScope: text(source.oauthScope),
+        oauthClientAuth: source.oauthClientAuth ?? 'basic',
+        tlsVerify: source.tlsVerify !== false,
+        timeoutMs: source.timeoutMs == null ? '' : String(source.timeoutMs)
+    };
+}
+// ── which extras an auth type actually uses ─────────────────────────────────
+export function usesHeaderName(authType) {
+    return authType === 'bearer' || authType === 'api_key';
+}
+export function usesQueryParam(authType) {
+    return authType === 'api_key';
+}
+export function usesOauth(authType) {
+    return authType === 'oauth2';
+}
+/**
+ * Rebuilds the record.
+ *
+ * Fields the chosen auth type does not use are sent as null rather than left
+ * alone. Switching a connection from OAuth to a bearer token and leaving the old
+ * token URL behind is how a source ends up carrying settings nobody can see in
+ * the form but the server still reads.
+ */ export function draftToSource(draft, id) {
+    const oauth = usesOauth(draft.authType);
+    const timeout = Number.parseInt(draft.timeoutMs.trim(), 10);
+    return {
+        ...id ? {
+            id
+        } : {},
+        name: draft.name.trim(),
+        slug: draft.slug.trim(),
+        baseUrl: draft.baseUrl.trim(),
+        description: orNull(draft.description),
+        enabled: draft.enabled,
+        authType: draft.authType,
+        authHeaderName: usesHeaderName(draft.authType) ? orNull(draft.authHeaderName) : null,
+        authQueryParam: usesQueryParam(draft.authType) ? orNull(draft.authQueryParam) : null,
+        tokenUrl: oauth ? orNull(draft.tokenUrl) : null,
+        oauthGrantType: oauth ? draft.oauthGrantType : null,
+        oauthClientId: oauth ? orNull(draft.oauthClientId) : null,
+        oauthUsername: oauth && draft.oauthGrantType === 'password' ? orNull(draft.oauthUsername) : null,
+        oauthScope: oauth ? orNull(draft.oauthScope) : null,
+        oauthClientAuth: oauth ? draft.oauthClientAuth : null,
+        tlsVerify: draft.tlsVerify,
+        timeoutMs: Number.isFinite(timeout) && timeout > 0 ? timeout : null
+    };
+}
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+const DIGITS_PATTERN = /^\d+$/;
+/**
+ * What must be filled in before a save is worth attempting.
+ *
+ * The base URL is checked for a scheme and nothing else. It is deliberately not
+ * checked for https, for a public host or for a resolvable name: an in-cluster
+ * service on plain http is a normal target, and a form that rejected it would be
+ * rejecting a working setup.
+ */ export function validateConnectionDraft(draft) {
+    const errors = {};
+    if (draft.name.trim().length === 0) errors.name = 'Give the connection a name.';
+    const slug = draft.slug.trim();
+    if (slug.length === 0) errors.slug = 'Give the connection a slug.';
+    else if (!SLUG_PATTERN.test(slug)) errors.slug = 'Lower-case letters, digits, hyphen and underscore only.';
+    const baseUrl = draft.baseUrl.trim();
+    if (baseUrl.length === 0) errors.baseUrl = 'Give the base URL of the service.';
+    else if (!baseUrl.includes('://')) errors.baseUrl = 'Include the scheme, for example http://hr-service:8080.';
+    if (usesOauth(draft.authType) && draft.tokenUrl.trim().length === 0) errors.tokenUrl = 'OAuth 2 needs the token endpoint.';
+    const timeout = draft.timeoutMs.trim();
+    if (timeout.length > 0 && !DIGITS_PATTERN.test(timeout)) errors.timeoutMs = 'Whole milliseconds, for example 30000.';
+    return errors;
+}

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

@@ -0,0 +1,25 @@
+import type { IntegrationSource } from '../types';
+/**
+ * The write-only halves of a connection.
+ *
+ * Everything here is deliberately explicit rather than keyed by a variable: the
+ * action takes a fixed set of three optional keys, and building that object from
+ * a computed key would need a cast to type-check — a cast that would happily let
+ * a typo through to a call that stores secrets.
+ */
+export type CredentialSlot = 'token' | 'oauthClientSecret' | 'oauthPassword';
+export type CredentialValues = {
+    token?: string;
+    oauthClientSecret?: string;
+    oauthPassword?: string;
+};
+/** One key at a time, for the per-field Clear button. */
+export declare function patchFor(slot: CredentialSlot, value: string): CredentialValues;
+/** The masked preview already stored against the record, if there is one. */
+export declare function storedHint(source: IntegrationSource, slot: CredentialSlot): string | null;
+/** `undefined` means the reply said nothing about this slot; null means cleared. */
+export declare function hintFromResult(result: Record<string, string | null>, slot: CredentialSlot): string | null | undefined;
+/** Which secrets the chosen auth type actually reads. */
+export declare function slotsForSource(source: IntegrationSource): CredentialSlot[];
+export declare function slotLabel(slot: CredentialSlot, source: IntegrationSource): string;
+export declare function slotHint(slot: CredentialSlot, source: IntegrationSource): string;

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

@@ -0,0 +1,67 @@
+/** One key at a time, for the per-field Clear button. */ export function patchFor(slot, value) {
+    if (slot === 'token') return {
+        token: value
+    };
+    if (slot === 'oauthClientSecret') return {
+        oauthClientSecret: value
+    };
+    return {
+        oauthPassword: value
+    };
+}
+/** The masked preview already stored against the record, if there is one. */ export function storedHint(source, slot) {
+    if (slot === 'token') return source.authTokenHint ?? null;
+    if (slot === 'oauthClientSecret') return source.oauthClientSecretHint ?? null;
+    return source.oauthPasswordHint ?? null;
+}
+/**
+ * Servers name the returned previews after either the slot or its hint column.
+ * Both are accepted so a correct reply is never read as "nothing came back".
+ */ const HINT_KEYS = {
+    token: [
+        'token',
+        'authTokenHint'
+    ],
+    oauthClientSecret: [
+        'oauthClientSecret',
+        'oauthClientSecretHint'
+    ],
+    oauthPassword: [
+        'oauthPassword',
+        'oauthPasswordHint'
+    ]
+};
+/** `undefined` means the reply said nothing about this slot; null means cleared. */ export function hintFromResult(result, slot) {
+    for (const key of HINT_KEYS[slot]){
+        if (key in result) return result[key] ?? null;
+    }
+    return undefined;
+}
+/** Which secrets the chosen auth type actually reads. */ export function slotsForSource(source) {
+    if (source.authType === 'oauth2') {
+        return source.oauthGrantType === 'password' ? [
+            'oauthClientSecret',
+            'oauthPassword'
+        ] : [
+            'oauthClientSecret'
+        ];
+    }
+    if (source.authType === 'none') return [];
+    return [
+        'token'
+    ];
+}
+export function slotLabel(slot, source) {
+    if (slot === 'oauthClientSecret') return 'Client secret';
+    if (slot === 'oauthPassword') return 'Password';
+    if (source.authType === 'api_key') return 'API key';
+    if (source.authType === 'basic') return 'Basic credential';
+    return 'Bearer token';
+}
+export function slotHint(slot, source) {
+    if (slot === 'oauthClientSecret') return 'Sent to the token endpoint with the client ID.';
+    if (slot === 'oauthPassword') return 'The password of the user named above.';
+    if (source.authType === 'api_key') return 'Sent in the header or query parameter named in the auth section.';
+    if (source.authType === 'basic') return 'The user name and password pair, as the service expects.';
+    return 'Sent on every request through this connection.';
+}

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

@@ -0,0 +1,16 @@
+import type { FieldMappingValue, MappingTransformValue } from '../types';
+/**
+ * The vocabulary of a field mapping row, kept out of the components so the
+ * header, the row and the editor cannot disagree about what a column is called
+ * or how wide it is.
+ */
+/** A source that reads from the record the PARENT endpoint produced. */
+export declare const PARENT_PREFIX = "__parent.";
+/** One template for the header and every row, so the columns cannot drift apart. */
+export declare const FIELD_MAPPING_GRID = "grid grid-cols-1 gap-2 sm:grid-cols-2 lg:grid-cols-[1fr_1fr_1fr_1fr_1fr_auto]";
+export declare const FIELD_MAPPING_COLUMNS: string[];
+export declare const EMPTY_FIELD_MAPPING: FieldMappingValue;
+export declare const TRANSFORMS: MappingTransformValue[];
+export declare const TRANSFORM_LABEL: Record<MappingTransformValue, string>;
+/** Narrows what a select reported back to a transform this panel knows. */
+export declare function toTransform(value: string): MappingTransformValue;

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

@@ -0,0 +1,41 @@
+/**
+ * The vocabulary of a field mapping row, kept out of the components so the
+ * header, the row and the editor cannot disagree about what a column is called
+ * or how wide it is.
+ */ /** A source that reads from the record the PARENT endpoint produced. */ export const PARENT_PREFIX = '__parent.';
+/** One template for the header and every row, so the columns cannot drift apart. */ export const FIELD_MAPPING_GRID = 'grid grid-cols-1 gap-2 sm:grid-cols-2 lg:grid-cols-[1fr_1fr_1fr_1fr_1fr_auto]';
+export const FIELD_MAPPING_COLUMNS = [
+    'Source',
+    'Target',
+    'Transform',
+    'Constant',
+    'Fallback'
+];
+export const EMPTY_FIELD_MAPPING = {
+    source: '',
+    target: '',
+    transform: 'none'
+};
+export const TRANSFORMS = [
+    'none',
+    'trim',
+    'upper',
+    'lower',
+    'toString',
+    'toNumber',
+    'toBoolean',
+    'dateOnly'
+];
+export const TRANSFORM_LABEL = {
+    none: 'No transform',
+    trim: 'Trim spaces',
+    upper: 'Uppercase',
+    lower: 'Lowercase',
+    toString: 'To text',
+    toNumber: 'To number',
+    toBoolean: 'To boolean',
+    dateOnly: 'Date only'
+};
+/** Narrows what a select reported back to a transform this panel knows. */ export function toTransform(value) {
+    return TRANSFORMS.find((option)=>option === value) ?? 'none';
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Two things every form in this panel needs and neither of them deserves a file.
+ */
+/**
+ * The ids a control should point `aria-describedby` at.
+ *
+ * {@link Field} renders its hint as `<id>-hint` and its error as `<id>-error`,
+ * so pointing at an id that was not rendered would leave a screen reader
+ * announcing nothing — the ids are named here only when they exist.
+ */
+export declare function describedBy(id: string, hasHint: boolean, hasError: boolean): string | undefined;
+/**
+ * Whatever a rejected action carries, as a sentence.
+ *
+ * The server's own wording is kept verbatim wherever there is one: it is the
+ * only text that knows WHICH setting was wrong, and a friendlier replacement
+ * would be a friendlier way of saying nothing.
+ */
+export declare function errorText(reason: unknown, fallback: string): string;

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

@@ -0,0 +1,25 @@
+/**
+ * Two things every form in this panel needs and neither of them deserves a file.
+ */ /**
+ * The ids a control should point `aria-describedby` at.
+ *
+ * {@link Field} renders its hint as `<id>-hint` and its error as `<id>-error`,
+ * so pointing at an id that was not rendered would leave a screen reader
+ * announcing nothing — the ids are named here only when they exist.
+ */ export function describedBy(id, hasHint, hasError) {
+    if (hasHint && hasError) return `${id}-hint ${id}-error`;
+    if (hasHint) return `${id}-hint`;
+    if (hasError) return `${id}-error`;
+    return undefined;
+}
+/**
+ * Whatever a rejected action carries, as a sentence.
+ *
+ * The server's own wording is kept verbatim wherever there is one: it is the
+ * only text that knows WHICH setting was wrong, and a friendlier replacement
+ * would be a friendlier way of saying nothing.
+ */ export function errorText(reason, fallback) {
+    if (reason instanceof Error && reason.message.length > 0) return reason.message;
+    if (typeof reason === 'string' && reason.length > 0) return reason;
+    return fallback;
+}