@aglyn/plugins-marketplace 1.15.0 → 1.15.2

package/src/lib/components/site-plugin-connections-card.component.js

@@ -0,0 +1,576 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { pluginDocsHelp } from "@aglyn/aglyn/app-utils/docs-help";
+import { CardDisplay, useConfirmationContext } from "@aglyn/shared-ui-jsx";
+import { BlockedControl } from "@aglyn/shared-ui-jsx/components/blocked-control.component";
+import { PlanUpsellNotice } from "@aglyn/shared-ui-jsx/components/plan-upsell-notice.component";
+import { PrerequisiteNotice } from "@aglyn/shared-ui-jsx/components/prerequisite-notice.component";
+import { StatusChip } from "@aglyn/shared-ui-jsx/components/status-chip.component";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { useSiteKeys } from "@aglyn/tenant-feature-instance/hooks/use-site-keys";
+import { Alert, Button, CircularProgress, MenuItem, Stack, TextField, Typography } from "@mui/material";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { PluginConnectionRouteError, usePluginConnectionsApi } from "../hooks/use-plugin-connections-api.js";
+import { declaredPluginConnections, declaredSyncIntervalHours, formatConnectionTime, nextResourceToChoose, PLUGIN_CONNECTION_PHASE_CHIP, PLUGIN_CONNECTIONS_NOT_CONFIGURED_TEXT, pluginConnectionNextSyncAtMs, pluginConnectionNotSetUpText, pluginConnectionPhase, pluginConnectionResultMessage, pluginConnectionSharesText, pluginConnectionTooSoonText, readPluginConnectionReturn } from "../model/plugin-connection-card.js";
+import { PLUGIN_CONNECTIONS_PLAN_REFUSAL, PLUGIN_CONNECTIONS_SITE_PERMISSION, PLUGIN_CONNECTIONS_SITE_ROLE_PRESET, pluginConnectionsPermissionRefusal } from "../model/plugin-connections.js";
+const leavePage = (url)=>window.location.assign(url);
+const HELP = pluginDocsHelp('installYourFirstPlugin', {
+    anchor: '#plugin-connections',
+    excerpt: 'Some plugins show information from another service, such as your business listing. Connect it once and the plugin keeps it up to date on its own.'
+});
+/**
+ * THE SITE'S CONNECTIONS FOR ONE INSTALLED PLUGIN (AGL-4196).
+ *
+ * A marketplace plugin may declare connections in its manifest: an account at
+ * another service the platform signs in to, the things the owner picks there
+ * (an account, then one of its locations), and a scheduled sync. The
+ * platform runs all of it, so this card is the same for every plugin: one
+ * card per declared connection, drawn from the pinned manifest and the
+ * status route.
+ *
+ * Every prerequisite stays on screen: a plan without connections, a
+ * publisher who has not set the connection up, a deployment that cannot run
+ * them yet and a member without the site key each keep the card, with its
+ * controls off and the reason said.
+ */ export function SitePluginConnectionsCard(props) {
+    var _props_api, _props_navigate;
+    const { hostId, orgSlug, pluginRef, pin } = props;
+    const routes = usePluginConnectionsApi(hostId);
+    const api = (_props_api = props.api) != null ? _props_api : routes;
+    const navigate = (_props_navigate = props.navigate) != null ? _props_navigate : leavePage;
+    const { enqueueSnackbar } = useSnackbar();
+    const { blocked } = useSiteKeys(hostId);
+    const declared = declaredPluginConnections(pin == null ? void 0 : pin['manifest']);
+    const hasDeclared = declared.length > 0;
+    const [load, setLoad] = useState({
+        status: 'loading'
+    });
+    const returned = useRef(false);
+    const refresh = useCallback(async ()=>{
+        try {
+            setLoad({
+                status: 'ready',
+                answer: await api.status(pluginRef)
+            });
+        } catch (error) {
+            var _ref;
+            const refusal = error instanceof PluginConnectionRouteError ? error : null;
+            setLoad({
+                status: 'error',
+                message: (_ref = refusal == null ? void 0 : refusal.message) != null ? _ref : 'The connections could not be read. Try again.',
+                refused: (refusal == null ? void 0 : refusal.reason) === 'permission'
+            });
+        }
+    }, [
+        api,
+        pluginRef
+    ]);
+    useEffect(()=>{
+        if (!hasDeclared || !hostId) return;
+        if (!returned.current && typeof window !== 'undefined') {
+            returned.current = true;
+            const back = readPluginConnectionReturn(window.location.href, pluginRef);
+            if (back) {
+                var _ref;
+                var _declared_find;
+                window.history.replaceState(window.history.state, '', back.cleanUrl);
+                const label = (_ref = (_declared_find = declared.find((one)=>one.id === back.connectionId)) == null ? void 0 : _declared_find.label) != null ? _ref : 'The service';
+                const { variant, message } = pluginConnectionResultMessage(back.result, label);
+                enqueueSnackbar(message, {
+                    variant
+                });
+            }
+        }
+        void refresh();
+    // `declared` is re-derived each render from the same pin; its ids are what matter.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        hasDeclared,
+        hostId,
+        pluginRef,
+        refresh
+    ]);
+    if (!hasDeclared) return null;
+    const keyRefused = blocked(PLUGIN_CONNECTIONS_SITE_PERMISSION, PLUGIN_CONNECTIONS_SITE_ROLE_PRESET);
+    const permissionText = pluginConnectionsPermissionRefusal(PLUGIN_CONNECTIONS_SITE_PERMISSION);
+    if (keyRefused || load.status === 'error' && load.refused) {
+        return /*#__PURE__*/ _jsx(Stack, {
+            spacing: 3,
+            children: declared.map((connection)=>/*#__PURE__*/ _jsx(CardDisplay, {
+                    header: connection.label,
+                    subheader: connection.description,
+                    help: HELP,
+                    contentGutterX: true,
+                    contentGutterY: true,
+                    HeaderProps: {
+                        action: /*#__PURE__*/ _jsx(BlockedControl, {
+                            blocked: true,
+                            reason: permissionText,
+                            children: /*#__PURE__*/ _jsx(Button, {
+                                variant: "contained",
+                                children: 'Connect'
+                            })
+                        })
+                    },
+                    children: /*#__PURE__*/ _jsx(Alert, {
+                        severity: "info",
+                        children: permissionText
+                    })
+                }, connection.id))
+        });
+    }
+    if (load.status !== 'ready') {
+        return /*#__PURE__*/ _jsx(Stack, {
+            spacing: 3,
+            children: declared.map((connection)=>/*#__PURE__*/ _jsx(CardDisplay, {
+                    header: connection.label,
+                    subheader: connection.description,
+                    help: HELP,
+                    contentGutterX: true,
+                    contentGutterY: true,
+                    HeaderProps: load.status === 'error' ? {
+                        action: /*#__PURE__*/ _jsx(Button, {
+                            variant: "outlined",
+                            onClick: ()=>void refresh(),
+                            children: 'Try again'
+                        })
+                    } : undefined,
+                    children: load.status === 'error' ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "error",
+                        children: load.message
+                    }) : /*#__PURE__*/ _jsxs(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            alignItems: 'center'
+                        },
+                        role: "status",
+                        children: [
+                            /*#__PURE__*/ _jsx(CircularProgress, {
+                                size: 18
+                            }),
+                            /*#__PURE__*/ _jsx(Typography, {
+                                variant: "body2",
+                                color: "text.secondary",
+                                children: 'Checking the connection…'
+                            })
+                        ]
+                    })
+                }, connection.id))
+        });
+    }
+    const { answer } = load;
+    const replace = (entry, connection)=>setLoad({
+            status: 'ready',
+            answer: _extends({}, answer, {
+                connections: answer.connections.map((one)=>one.listingId === entry.listingId && one.connectionId === entry.connectionId ? _extends({}, one, {
+                        connection
+                    }) : one)
+            })
+        });
+    return /*#__PURE__*/ _jsx(Stack, {
+        spacing: 3,
+        children: answer.connections.map((entry)=>{
+            var _ref;
+            return /*#__PURE__*/ _jsx(SitePluginConnection, {
+                entry: entry,
+                configured: answer.configured,
+                planAllows: answer.planAllows && entry.planAllows,
+                upgradeHref: orgSlug ? `/${orgSlug}/billing#plans` : undefined,
+                pluginName: String((_ref = pin == null ? void 0 : pin['displayName']) != null ? _ref : '') || 'this plugin',
+                intervalHours: declaredSyncIntervalHours(pin == null ? void 0 : pin['manifest'], entry.connectionId),
+                api: api,
+                navigate: navigate,
+                onConnection: (connection)=>replace(entry, connection),
+                onStale: refresh
+            }, `${entry.listingId}/${entry.connectionId}`);
+        })
+    });
+}
+SitePluginConnectionsCard.displayName = 'SitePluginConnectionsCard';
+export default SitePluginConnectionsCard;
+/** One declared connection on the site: its state, what was chosen, and what can be done next. */ function SitePluginConnection(props) {
+    var _entry_resources_changing, _ref, _ref1;
+    var _view_choices_resourceId;
+    const { entry, configured, planAllows, upgradeHref, pluginName, intervalHours, api, navigate, onConnection, onStale } = props;
+    const { enqueueSnackbar } = useSnackbar();
+    const { confirm } = useConfirmationContext();
+    const [busy, setBusy] = useState(null);
+    const [error, setError] = useState(null);
+    const [wait, setWait] = useState(null);
+    const [changing, setChanging] = useState(null);
+    const [items, setItems] = useState({
+        status: 'idle'
+    });
+    const [picked, setPicked] = useState('');
+    const phase = pluginConnectionPhase(entry, configured);
+    // A pinned version that declares no sync has nothing for Sync now to run, and no sync times to show.
+    const declaresSync = intervalHours !== null;
+    const view = entry.connection;
+    const label = entry.label;
+    const ids = {
+        listingId: entry.listingId,
+        connectionId: entry.connectionId
+    };
+    const resource = changing !== null ? (_entry_resources_changing = entry.resources[changing]) != null ? _entry_resources_changing : null : phase === 'choosing' ? nextResourceToChoose(entry) : null;
+    const resourceId = (_ref = resource == null ? void 0 : resource.id) != null ? _ref : '';
+    const currentChoice = resourceId ? (_ref1 = view == null ? void 0 : (_view_choices_resourceId = view.choices[resourceId]) == null ? void 0 : _view_choices_resourceId.id) != null ? _ref1 : '' : '';
+    useEffect(()=>{
+        if (!resourceId || !planAllows) {
+            setItems({
+                status: 'idle'
+            });
+            return;
+        }
+        let live = true;
+        setItems({
+            status: 'loading'
+        });
+        setPicked(currentChoice);
+        api.resources(_extends({}, ids, {
+            resource: resourceId
+        })).then((answer)=>{
+            if (!live) return;
+            setItems({
+                status: 'ready',
+                items: answer.items
+            });
+            setPicked((was)=>was || (answer.items.length === 1 ? answer.items[0].id : ''));
+        }).catch((failure)=>{
+            if (!live) return;
+            setItems({
+                status: 'error',
+                message: failure instanceof Error ? failure.message : String(failure)
+            });
+            if (failure instanceof PluginConnectionRouteError && failure.reason === 'reconnect') void onStale();
+        });
+        return ()=>{
+            live = false;
+        };
+    // The connection's ids and the resource are the request; the rest is display.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        api,
+        entry.listingId,
+        entry.connectionId,
+        resourceId,
+        planAllows
+    ]);
+    const run = async (kind, work)=>{
+        setBusy(kind);
+        setError(null);
+        setWait(null);
+        try {
+            await work();
+        } catch (failure) {
+            if (failure instanceof PluginConnectionRouteError && failure.reason === 'too-soon') {
+                // Not a failure: the last sync is under a minute old. Say how long, and show what it brought.
+                const retryAfterMs = Number(failure.body['retryAfterMs']);
+                setWait(pluginConnectionTooSoonText(label, Number.isFinite(retryAfterMs) ? retryAfterMs : null));
+                const connection = failure.body['connection'];
+                if (connection && typeof connection === 'object') onConnection(connection);
+                return;
+            }
+            const message = failure instanceof Error ? failure.message : String(failure);
+            setError(message);
+            if (failure instanceof PluginConnectionRouteError && (failure.reason === 'reconnect' || failure.reason === 'not-connected' || failure.reason === 'choose-first')) {
+                void onStale();
+            }
+        } finally{
+            setBusy(null);
+        }
+    };
+    const connect = ()=>run('connect', async ()=>{
+            const { authorizeUrl } = await api.connectStart(_extends({}, ids, {
+                returnTo: window.location.href
+            }));
+            navigate(authorizeUrl);
+        });
+    const choose = ()=>run('choose', async ()=>{
+            if (!resource || !picked) return;
+            const { connection } = await api.choose(_extends({}, ids, {
+                resource: resource.id,
+                id: picked
+            }));
+            onConnection(connection);
+            if (changing !== null) {
+                const next = changing + 1;
+                setChanging(next < entry.resources.length ? next : null);
+            }
+            if (connection == null ? void 0 : connection.ready) enqueueSnackbar(`${label} is set up. It syncs on its own from now on.`, {
+                variant: 'success'
+            });
+        });
+    const sync = ()=>run('sync', async ()=>{
+            const { connection, synced } = await api.sync(ids);
+            onConnection(connection);
+            enqueueSnackbar(synced ? `${label} is up to date.` : `${label} did not sync. See why below.`, {
+                variant: synced ? 'success' : 'warning'
+            });
+        });
+    const disconnect = async ()=>{
+        const ok = await Promise.resolve(confirm({
+            title: `Disconnect ${label}?`,
+            description: `${pluginName} stops receiving updates from ${label} on this site, and what it last brought in is removed from the site. You can connect again at any time.`,
+            confirmationText: 'Disconnect',
+            confirmationButtonProps: {
+                color: 'warning',
+                variant: 'contained'
+            }
+        })).then(()=>true).catch(()=>false);
+        if (!ok) return;
+        await run('disconnect', async ()=>{
+            await api.disconnect(ids);
+            setChanging(null);
+            onConnection(null);
+            enqueueSnackbar(`${label} is disconnected.`, {
+                variant: 'success'
+            });
+        });
+    };
+    const planReason = PLUGIN_CONNECTIONS_PLAN_REFUSAL;
+    const blockedBy = phase === 'not-configured' ? PLUGIN_CONNECTIONS_NOT_CONFIGURED_TEXT : phase === 'not-set-up' ? pluginConnectionNotSetUpText(label) : !planAllows ? planReason : null;
+    const guarded = (reason, control)=>/*#__PURE__*/ _jsx(BlockedControl, {
+            blocked: Boolean(reason),
+            reason: reason != null ? reason : '',
+            children: control
+        });
+    const disconnectButton = /*#__PURE__*/ _jsx(Button, {
+        color: "warning",
+        disabled: busy !== null,
+        onClick: ()=>void disconnect(),
+        children: busy === 'disconnect' ? 'Disconnecting…' : 'Disconnect'
+    });
+    const actions = [];
+    if (resource) {
+        actions.push(guarded(!planAllows ? planReason : null, /*#__PURE__*/ _jsx(Button, {
+            variant: "contained",
+            disabled: busy !== null || !picked || items.status !== 'ready',
+            onClick: ()=>void choose(),
+            children: busy === 'choose' ? 'Saving…' : `Use this ${resource.label.toLowerCase()}`
+        }, "use")));
+        if (changing !== null) {
+            actions.push(/*#__PURE__*/ _jsx(Button, {
+                color: "inherit",
+                disabled: busy !== null,
+                onClick: ()=>setChanging(null),
+                children: 'Cancel'
+            }, "cancel"));
+        }
+        actions.push(disconnectButton);
+    } else if (phase === 'not-configured' || phase === 'not-set-up' || phase === 'not-connected') {
+        actions.push(guarded(blockedBy, /*#__PURE__*/ _jsx(Button, {
+            variant: "contained",
+            disabled: busy !== null,
+            onClick: ()=>void connect(),
+            children: busy === 'connect' ? 'Opening…' : 'Connect'
+        }, "connect")));
+    } else if (phase === 'reconnect') {
+        actions.push(guarded(!planAllows ? planReason : !entry.credentialsSet ? pluginConnectionNotSetUpText(label) : null, /*#__PURE__*/ _jsx(Button, {
+            variant: "contained",
+            disabled: busy !== null,
+            onClick: ()=>void connect(),
+            children: busy === 'connect' ? 'Opening…' : 'Reconnect'
+        }, "reconnect")));
+        actions.push(disconnectButton);
+    } else {
+        if (declaresSync) {
+            actions.push(guarded(!planAllows ? planReason : null, /*#__PURE__*/ _jsx(Button, {
+                variant: phase === 'error' ? 'contained' : 'outlined',
+                disabled: busy !== null,
+                onClick: ()=>void sync(),
+                children: busy === 'sync' ? 'Syncing…' : 'Sync now'
+            }, "sync")));
+        }
+        if (entry.resources.length) {
+            actions.push(guarded(!planAllows ? planReason : null, /*#__PURE__*/ _jsx(Button, {
+                variant: "outlined",
+                disabled: busy !== null,
+                onClick: ()=>setChanging(0),
+                children: 'Change'
+            }, "change")));
+        }
+        actions.push(disconnectButton);
+    }
+    const chip = PLUGIN_CONNECTION_PHASE_CHIP[phase];
+    const shares = pluginConnectionSharesText(entry.hosts);
+    const nextSync = pluginConnectionNextSyncAtMs(view, intervalHours);
+    const chosen = entry.resources.filter((one)=>view == null ? void 0 : view.choices[one.id]);
+    return /*#__PURE__*/ _jsx(CardDisplay, {
+        header: label,
+        subheader: entry.description,
+        help: HELP,
+        contentGutterX: true,
+        contentGutterY: true,
+        HeaderProps: {
+            action: /*#__PURE__*/ _jsx(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap',
+                    justifyContent: 'flex-end'
+                },
+                children: actions.map((action, index)=>/*#__PURE__*/ _jsx("span", {
+                        children: action
+                    }, index))
+            })
+        },
+        children: /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1.5,
+            children: [
+                /*#__PURE__*/ _jsx(Stack, {
+                    direction: "row",
+                    spacing: 1,
+                    children: /*#__PURE__*/ _jsx(StatusChip, {
+                        label: chip.label,
+                        tone: chip.tone,
+                        "data-testid": "plugin-connection-status"
+                    })
+                }),
+                phase === 'not-configured' ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "info",
+                    children: PLUGIN_CONNECTIONS_NOT_CONFIGURED_TEXT
+                }) : null,
+                phase === 'not-set-up' ? /*#__PURE__*/ _jsx(PrerequisiteNotice, {
+                    children: pluginConnectionNotSetUpText(label)
+                }) : null,
+                !planAllows && phase !== 'not-configured' && phase !== 'not-set-up' ? /*#__PURE__*/ _jsx(PlanUpsellNotice, {
+                    planLabel: undefined,
+                    upgradeHref: upgradeHref,
+                    children: view ? `${planReason} You can still disconnect it.` : planReason
+                }) : null,
+                phase === 'not-connected' ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "body2",
+                    color: "text.secondary",
+                    children: `Connect ${label} so ${pluginName} can use it on this site. You sign in at ${label} and choose what to share; this site never sees your password.`
+                }) : null,
+                phase === 'reconnect' ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "warning",
+                    children: `${label} no longer accepts this connection. Nothing syncs until you reconnect.`
+                }) : null,
+                phase === 'error' ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "error",
+                    children: (view == null ? void 0 : view.lastError) ? `The last sync did not work: ${view.lastError}. It tries again on schedule, or you can sync now.` : 'The last sync did not work. It tries again on schedule, or you can sync now.'
+                }) : null,
+                resource ? /*#__PURE__*/ _jsxs(Stack, {
+                    spacing: 1,
+                    children: [
+                        /*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            color: "text.secondary",
+                            children: changing === null ? `Choose the ${resource.label.toLowerCase()} ${pluginName} should use. Nothing syncs until you do.` : `Choose the ${resource.label.toLowerCase()} ${pluginName} should use.`
+                        }),
+                        items.status === 'loading' ? /*#__PURE__*/ _jsxs(Stack, {
+                            direction: "row",
+                            spacing: 1,
+                            sx: {
+                                alignItems: 'center'
+                            },
+                            role: "status",
+                            children: [
+                                /*#__PURE__*/ _jsx(CircularProgress, {
+                                    size: 18
+                                }),
+                                /*#__PURE__*/ _jsx(Typography, {
+                                    variant: "body2",
+                                    color: "text.secondary",
+                                    children: `Asking ${label}…`
+                                })
+                            ]
+                        }) : null,
+                        items.status === 'error' ? /*#__PURE__*/ _jsx(Alert, {
+                            severity: "error",
+                            children: items.message
+                        }) : null,
+                        items.status === 'ready' && !items.items.length ? /*#__PURE__*/ _jsx(Alert, {
+                            severity: "info",
+                            children: `The ${label} account you connected has nothing to choose here. Connect a different account, or add one at ${label} first.`
+                        }) : null,
+                        items.status === 'ready' && items.items.length ? /*#__PURE__*/ _jsx(TextField, {
+                            select: true,
+                            size: "small",
+                            label: resource.label,
+                            value: picked,
+                            disabled: busy !== null || !planAllows,
+                            onChange: (event)=>setPicked(event.target.value),
+                            sx: {
+                                maxWidth: 480
+                            },
+                            children: items.items.map((item)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                    value: item.id,
+                                    children: item.label
+                                }, item.id))
+                        }) : null
+                    ]
+                }) : null,
+                view && chosen.length && changing === null ? /*#__PURE__*/ _jsx(Stack, {
+                    spacing: 0.5,
+                    children: chosen.map((one)=>{
+                        var _view_choices_one_id;
+                        return /*#__PURE__*/ _jsxs(Typography, {
+                            variant: "body2",
+                            children: [
+                                /*#__PURE__*/ _jsx(Typography, {
+                                    component: "span",
+                                    variant: "body2",
+                                    color: "text.secondary",
+                                    children: `${one.label}: `
+                                }),
+                                (_view_choices_one_id = view.choices[one.id]) == null ? void 0 : _view_choices_one_id.label
+                            ]
+                        }, one.id);
+                    })
+                }) : null,
+                view && declaresSync && (phase === 'connected' || phase === 'error') ? /*#__PURE__*/ _jsxs(Stack, {
+                    spacing: 0.5,
+                    children: [
+                        /*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            color: "text.secondary",
+                            children: view.lastSyncAtMs !== null ? `Last synced ${formatConnectionTime(view.lastSyncAtMs)}` : 'Not synced yet'
+                        }),
+                        nextSync !== null ? /*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            color: "text.secondary",
+                            children: nextSync === 'soon' ? 'Next sync: within the hour' : `Next sync ${formatConnectionTime(nextSync)}`
+                        }) : null
+                    ]
+                }) : null,
+                shares ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: shares
+                }) : null,
+                wait ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "info",
+                    onClose: ()=>setWait(null),
+                    children: wait
+                }) : null,
+                error ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "error",
+                    onClose: ()=>setError(null),
+                    children: error
+                }) : null
+            ]
+        })
+    });
+}
+
+//# sourceMappingURL=site-plugin-connections-card.component.js.map