@businessdash/sdk 0.9.60 → 0.9.70

package/dist/react.js

@@ -1,13 +1,46 @@
+"use client";
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Every export in this file is browser-only. The components hold state and
+ * subscribe to stores; the four programmatic helpers (`signIn`, `signUp`,
+ * `signOut`, `requestPasswordReset`) each bail out on
+ * `typeof window === "undefined"` because they navigate. Nothing here is meant
+ * to execute during a server render.
+ *
+ * WHY THE DIRECTIVE IS HERE
+ *
+ * Without it, a React Server Components framework treats this module as server
+ * code by default, and importing `<BiabForm>` into a page throws "you're
+ * importing a component that needs useState". The only way out is for every
+ * consumer to hand-write a `"use client"` wrapper per component — which is
+ * exactly what the Next App Router starter had to do, sixteen times, for
+ * components the SDK could have marked itself.
+ *
+ * `react-analytics.tsx` already carried this. `react.tsx` — the entry point
+ * that actually holds the components — did not.
+ *
+ * Bundlers that don't implement the directive treat it as a no-op string
+ * expression, so this is inert everywhere except RSC.
+ */
 import { createContext, Fragment, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
+import { createFollowersController, createUserController, } from "./account-core/index.js";
+import { buildAuthHref, clearLocalFollow, DEFAULT_AUTH_BASE_PATH, followerStoreKey, readLocalFollow, writeLocalFollow, } from "./auth-links.js";
+import { createBlogController } from "./blog-core/index.js";
+import { createChatController } from "./chat-core/index.js";
+import { createCheckoutController } from "./checkout-core/index.js";
 import { BiabDevClient } from "./client.js";
+import { DEFAULT_EMBED_SANDBOX, DEFAULT_REFRESH_LEAD_MS, refreshDelayMs, subscribeToEmbedMessages, } from "./embed-protocol.js";
 import { buildAcceptAttr, concurrentRevealCount, createFormController, evalCondition, fetchIconNames, filterIconNames, flattenValueFields, formatCalcValue, iconUrl, isPendingFileValue, resolveFieldAutocomplete, shouldSearchOptions, validateFile, } from "./forms-core/index.js";
 import { baseUnitFor, convertToBase, formatMeasurement, isMeasurementCategory, unitsForCategory, } from "./forms-core/units.js";
 import { US_STATES } from "./forms-core/us-states.js";
+import { createMarketingController } from "./marketing-core/index.js";
+import { createPortalController } from "./portal-core/index.js";
 import { createBiabClient } from "./sdk.js";
-import { resolveSocialProfiles } from "./socials.js";
+import { resolveSocialLinks, SOCIAL_FALLBACK_GLYPH, SOCIAL_LIST_STYLE, } from "./social-core/index.js";
+import { createStoreController } from "./store-core/index.js";
+import { createVerifyController, } from "./verify-core/index.js";
 function useEmbedSession(loader, options) {
-    const { apiKey, baseUrl, refreshLeadMs = 30_000 } = options;
+    const { apiKey, baseUrl, refreshLeadMs = DEFAULT_REFRESH_LEAD_MS } = options;
     const client = useMemo(() => new BiabDevClient({ apiKey, baseUrl }), [apiKey, baseUrl]);
     const [state, setState] = useState({ status: "idle" });
     // `loader` is recreated per surface; depending on it would refetch on every
@@ -32,10 +65,12 @@ function useEmbedSession(loader, options) {
     useEffect(() => {
         if (state.status !== "ready")
             return;
-        const expiresAt = Date.parse(state.session.expiresAt);
-        if (Number.isNaN(expiresAt))
+        // The schedule itself lives in `embed-protocol.ts` so both bindings
+        // re-mint at the same moment — an embed that expires in Solid but not in
+        // React would be a bug nobody thinks to look for.
+        const delay = refreshDelayMs(state.session.expiresAt, refreshLeadMs, Date.now());
+        if (delay === null)
             return;
-        const delay = Math.max(1_000, expiresAt - Date.now() - refreshLeadMs);
         const timer = setTimeout(() => {
             void refresh();
         }, delay);
@@ -44,23 +79,9 @@ function useEmbedSession(loader, options) {
     return { client, state, refresh };
 }
 function useEmbedMessages(iframeRef, handler) {
-    useEffect(() => {
-        const onMessage = (e) => {
-            if (!e.data || typeof e.data !== "object")
-                return;
-            if (e.data.kind !== "biab")
-                return;
-            if (iframeRef.current &&
-                e.source !== null &&
-                e.source !== iframeRef.current.contentWindow)
-                return;
-            const { kind, ...rest } = e.data;
-            void kind;
-            handler(rest);
-        };
-        window.addEventListener("message", onMessage);
-        return () => window.removeEventListener("message", onMessage);
-    }, [handler, iframeRef]);
+    // The listener, and the origin check inside it, live in
+    // `embed-protocol.ts` so the Solid binding enforces exactly the same rule.
+    useEffect(() => subscribeToEmbedMessages(() => iframeRef.current, handler), [handler, iframeRef]);
 }
 // Asserted-compat with the underlying DashboardSessionResponse so the public
 // `useDashboardSession` shape doesn't churn for existing callers.
@@ -102,7 +123,7 @@ export function Dashboard({ className, style, title = "Business In A Box Dashboa
     if (state.status !== "ready") {
         return (_jsx(_Fragment, { children: loadingFallback ?? (_jsx("div", { className: className, style: { padding: 16, ...style }, children: "Loading dashboard\u2026" })) }));
     }
-    return (_jsx("iframe", { className: className, sandbox: "allow-scripts allow-forms allow-same-origin allow-popups", src: state.session.url, style: { ...defaultIframeStyle, ...style }, title: title }));
+    return (_jsx("iframe", { className: className, sandbox: DEFAULT_EMBED_SANDBOX, src: state.session.url, style: { ...defaultIframeStyle, ...style }, title: title }));
 }
 function EmbedIframe({ state, refresh, title, className, style, loadingFallback, errorFallback, onEvent, extraSandbox, }) {
     const iframeRef = useRef(null);
@@ -121,7 +142,9 @@ function EmbedIframe({ state, refresh, title, className, style, loadingFallback,
     if (state.status !== "ready") {
         return (_jsx(_Fragment, { children: loadingFallback ?? (_jsx("div", { className: className, style: { padding: 16, ...style }, children: "Loading\u2026" })) }));
     }
-    const sandbox = `allow-scripts allow-forms allow-same-origin allow-popups${extraSandbox ? ` ${extraSandbox}` : ""}`;
+    const sandbox = extraSandbox
+        ? `${DEFAULT_EMBED_SANDBOX} ${extraSandbox}`
+        : DEFAULT_EMBED_SANDBOX;
     return (_jsx("iframe", { className: className, ref: iframeRef, sandbox: sandbox, src: state.session.url, style: { ...defaultIframeStyle, ...style }, title: title }));
 }
 export function Storefront({ apiKey, baseUrl, productId, className, style, title = "Storefront", loadingFallback, errorFallback, onEvent, onCartChange, refreshLeadMs, }) {
@@ -272,103 +295,72 @@ export function Chatbot({ apiKey, baseUrl, className, style, title = "Assistant"
  */
 export function useChatbot(options) {
     const { apiKey, baseUrl } = options;
-    const client = useMemo(() => new BiabDevClient({ apiKey, baseUrl }), [apiKey, baseUrl]);
-    const [messages, setMessages] = useState([]);
-    const [isPending, setIsPending] = useState(false);
-    const [error, setError] = useState(null);
-    const [latestUiActions, setLatestUiActions] = useState([]);
-    const [availability, setAvailability] = useState(null);
-    const send = useCallback(async (content) => {
-        const trimmed = content.trim();
-        if (!trimmed)
-            return null;
-        setError(null);
-        setIsPending(true);
-        const next = [
-            ...messages,
-            { role: "user", content: trimmed },
-        ];
-        setMessages(next);
-        try {
-            const input = { messages: next };
-            const reply = await client.chatbot.chat(input);
-            setMessages((prev) => [
-                ...prev,
-                { role: "assistant", content: reply.text },
-            ]);
-            setLatestUiActions(reply.uiActions ?? []);
-            if (reply.availability)
-                setAvailability(reply.availability);
-            return reply;
-        }
-        catch (err) {
-            const e = err instanceof Error ? err : new Error("Chat failed");
-            setError(e);
-            return null;
-        }
-        finally {
-            setIsPending(false);
-        }
-    }, [client, messages]);
-    const reset = useCallback(() => {
-        setMessages([]);
-        setError(null);
-        setLatestUiActions([]);
-    }, []);
-    const getConfig = useCallback(async () => client.chatbot.getConfig(), [client]);
-    const refreshAvailability = useCallback(async () => {
-        try {
-            const next = await client.chatbot.getAvailability();
-            setAvailability(next);
-            return next;
-        }
-        catch {
-            return null;
-        }
-    }, [client]);
-    const getForm = useCallback(async (slug) => {
-        try {
-            // Chat `show_form` flow → the chatbot path (Live + chatbotAccess).
-            return await client.chatbot.getChatForm(slug);
-        }
-        catch {
-            return null;
-        }
-    }, [client]);
-    const submitForm = useCallback(async (slug, input) => {
-        try {
-            const priorChat = messages.map((m, i) => ({
-                role: m.role,
-                content: m.content,
-                createdAt: i,
-            }));
-            // Chatbot submit carries the transcript → chatbot path.
-            return await client.chatbot.submitChatForm(slug, {
-                ...input,
-                priorChat: input.priorChat ?? priorChat,
-            });
-        }
-        catch (err) {
-            setError(err instanceof Error ? err : new Error("Submit failed"));
-            return null;
-        }
-    }, [client, messages]);
-    const uploadFile = useCallback((args) => client.chatbot.uploadFile(args), [client]);
+    const controller = useMemo(() => createChatController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+    }), [apiKey, baseUrl]);
+    useEffect(() => () => controller.destroy(), [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const uploadFile = useCallback((args) => new BiabDevClient({ apiKey, baseUrl }).chatbot.uploadFile(args), [apiKey, baseUrl]);
+    // The returned shape is unchanged from before this hook was moved onto
+    // `chat-core`, so existing consumers keep working — only the implementation
+    // moved, and it now backs every other framework's chat binding too.
     return {
-        messages,
-        send,
-        reset,
-        isPending,
-        error,
-        getConfig,
-        latestUiActions,
-        availability,
-        refreshAvailability,
-        getForm,
-        submitForm,
+        messages: snap.messages,
+        send: controller.send,
+        reset: controller.reset,
+        isPending: snap.isPending,
+        error: snap.error,
+        getConfig: controller.loadConfig,
+        latestUiActions: snap.uiActions,
+        availability: snap.availability,
+        refreshAvailability: controller.refreshAvailability,
+        getForm: controller.getForm,
+        submitForm: controller.submitForm,
+        requestHuman: controller.requestHuman,
         uploadFile,
     };
 }
+/**
+ * Headless storefront + cart for React — the native alternative to
+ * `<Storefront>`, which is a hosted page in an iframe. Everything lives in
+ * `createStoreController`; this only bridges it into React.
+ *
+ * ```tsx
+ * const store = useStorefront({ apiKey, baseUrl });
+ * return store.products.map((p) => <MyCard key={p.id} product={p} />);
+ * ```
+ */
+export function useStorefront(options) {
+    const { apiKey, baseUrl, pageSize, categoryId } = options;
+    const controller = useMemo(() => createStoreController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+        ...(pageSize ? { pageSize } : {}),
+        ...(categoryId ? { categoryId } : {}),
+    }), [apiKey, baseUrl, pageSize, categoryId]);
+    useEffect(() => {
+        void controller.load();
+        return () => controller.destroy();
+    }, [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        ...snap,
+        loadMore: controller.loadMore,
+        filterByCategory: controller.filterByCategory,
+        openProduct: controller.openProduct,
+        closeProduct: controller.closeProduct,
+        addToCart: controller.addToCart,
+        updateQuantity: controller.updateQuantity,
+        removeItem: controller.removeItem,
+        applyCoupon: controller.applyCoupon,
+        removeCoupon: controller.removeCoupon,
+        clearCart: controller.clearCart,
+        refreshCart: controller.refreshCart,
+    };
+}
 const STATIC_FIELD_TYPES = new Set([
     "title",
     "subtitle",
@@ -646,7 +638,10 @@ export function ChatbotInline({ apiKey, baseUrl, welcomeMessage, title = "Assist
         let cancelled = false;
         void getConfig()
             .then((cfg) => {
-            if (cancelled)
+            // `null` means the config couldn't be read — the core reports that
+            // rather than throwing, because a chat that can't fetch its upload
+            // settings should still let the visitor talk. Keep the defaults.
+            if (cancelled || !cfg)
                 return;
             setFileUploadsEnabled(cfg.fileUploadsEnabled);
             setEmailCaptureMode(cfg.emailCaptureMode);
@@ -925,17 +920,8 @@ export function Blog({ apiKey, baseUrl, postSlug, className, style, title = "Blo
     const { state, refresh } = useEmbedSession((client) => client.blog.createSession(input), { apiKey, baseUrl, refreshLeadMs });
     return (_jsx(EmbedIframe, { className: className, errorFallback: errorFallback, loadingFallback: loadingFallback, onEvent: onEvent, refresh: refresh, state: state, style: style, title: title }));
 }
-const DEFAULT_AUTH_BASE_PATH = "/api/biab-auth";
-function buildAuthHref(subroute, props) {
-    const base = (props.basePath ?? DEFAULT_AUTH_BASE_PATH).replace(/\/$/, "");
-    const params = new URLSearchParams();
-    if (props.returnTo)
-        params.set("returnTo", props.returnTo);
-    if (props.loginHint)
-        params.set("loginHint", props.loginHint);
-    const qs = params.toString();
-    return `${base}/${subroute}${qs ? `?${qs}` : ""}`;
-}
+// `buildAuthHref` and `DEFAULT_AUTH_BASE_PATH` come from `./auth-links.js` so
+// every binding builds the same handler URLs from the same query contract.
 export function SignIn({ children, ...rest }) {
     return (_jsx("a", { className: rest.className, href: buildAuthHref("sign-in", rest), style: rest.style, children: children ?? "Sign in" }));
 }
@@ -1021,73 +1007,21 @@ export async function requestPasswordReset(input) {
  * the cookie + handler path are the source of truth.
  */
 export function useUser(options) {
-    const basePath = (options?.basePath ?? DEFAULT_AUTH_BASE_PATH).replace(/\/$/, "");
-    const [state, setState] = useState({
-        status: "loading",
-        user: null,
-    });
+    const basePath = options?.basePath;
+    const controller = useMemo(() => createUserController(basePath ? { basePath } : {}), [basePath]);
     useEffect(() => {
-        let cancelled = false;
-        fetch(`${basePath}/me`, { credentials: "include" })
-            .then((r) => (r.ok ? r.json() : null))
-            .then((body) => {
-            if (cancelled)
-                return;
-            if (body) {
-                setState({ status: "signed-in", user: body });
-            }
-            else {
-                setState({ status: "signed-out", user: null });
-            }
-        })
-            .catch(() => {
-            if (cancelled)
-                return;
-            setState({ status: "signed-out", user: null });
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [basePath]);
-    return state;
-}
-const FOLLOWER_STORE_PREFIX = "biab.followers.";
-function readLocalFollow(key) {
-    if (typeof window === "undefined")
-        return null;
-    try {
-        const raw = window.localStorage.getItem(key);
-        if (!raw)
-            return null;
-        const parsed = JSON.parse(raw);
-        return typeof parsed?.email === "string"
-            ? { email: parsed.email, at: Number(parsed.at) || 0 }
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-function writeLocalFollow(key, value) {
-    if (typeof window === "undefined")
-        return;
-    try {
-        window.localStorage.setItem(key, JSON.stringify(value));
-    }
-    catch {
-        // storage disabled / quota — the local hint is best-effort.
-    }
-}
-function clearLocalFollow(key) {
-    if (typeof window === "undefined")
-        return;
-    try {
-        window.localStorage.removeItem(key);
-    }
-    catch {
-        // ignore
-    }
+        controller.start();
+        return () => controller.destroy();
+    }, [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    // The shape is unchanged for callers; the fetch moved to `account-core` so
+    // every framework reads the session the same way.
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
+// `LocalFollow`, `followerStoreKey`, `readLocalFollow`, `writeLocalFollow` and
+// `clearLocalFollow` come from `./auth-links.js` — one storage format, so a
+// visitor who subscribed through one binding is recognised by another.
 /**
  * Visitor-facing followers/subscribe client, bound to a publishable token so it
  * works browser-side with no backend.
@@ -1112,43 +1046,50 @@ function clearLocalFollow(key) {
  */
 export function useFollowers(options) {
     const { token, siteId, baseUrl } = options;
-    const client = useMemo(() => createBiabClient({
-        apiKey: token,
+    const controller = useMemo(() => createFollowersController({
+        client: createBiabClient({
+            apiKey: token,
+            siteId,
+            baseUrl: baseUrl ?? DEFAULT_PACKAGE_BASE_URL,
+        }),
         siteId,
-        baseUrl: baseUrl ?? DEFAULT_PACKAGE_BASE_URL,
     }), [token, siteId, baseUrl]);
-    const storeKey = `${FOLLOWER_STORE_PREFIX}${siteId}`;
-    const [local, setLocal] = useState(() => readLocalFollow(storeKey));
-    useEffect(() => {
-        setLocal(readLocalFollow(storeKey));
-    }, [storeKey]);
-    const join = useCallback(async (input) => {
-        const res = await client.followers.join(input);
-        const entry = { email: input.email, at: Date.now() };
-        writeLocalFollow(storeKey, entry);
-        setLocal(entry);
-        return res;
-    }, [client, storeKey]);
-    const leave = useCallback(async (email) => {
-        const res = await client.followers.leave({ email });
-        clearLocalFollow(storeKey);
-        setLocal(null);
-        return res;
-    }, [client, storeKey]);
-    const me = useCallback((email) => client.followers.me({ email }), [client]);
-    const edit = useCallback((email, patch) => client.followers.edit({ email, patch }), [client]);
-    return useMemo(() => ({
-        join,
-        leave,
-        me,
-        edit,
-        /** This browser already subscribed (instant, no network). Use to hide a
-         *  newsletter form for anonymous visitors. */
-        subscribedLocally: local !== null,
-        /** Email this browser subscribed with — pass to `me()` for an
-         *  authoritative re-check, or `null` if this browser hasn't subscribed. */
-        localEmail: local?.email ?? null,
-    }), [join, leave, me, edit, local]);
+    useEffect(() => () => controller.destroy(), [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    // Same shape as before the move onto `account-core`, including the
+    // local-storage hint, so existing consumers are untouched.
+    return {
+        join: controller.join,
+        leave: controller.leave,
+        me: controller.me,
+        edit: controller.edit,
+        subscribedLocally: snap.subscribedLocally,
+        localEmail: snap.localEmail,
+    };
+}
+/**
+ * Headless checkout for React. `start()` mints a Stripe session and `redirect()`
+ * navigates — split apart so a native app or an SSR render can use the first
+ * without the second.
+ */
+export function useCheckout(options) {
+    const { apiKey, baseUrl } = options;
+    const controller = useMemo(() => createCheckoutController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+    }), [apiKey, baseUrl]);
+    useEffect(() => () => controller.destroy(), [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        ...snap,
+        start: controller.start,
+        redirect: controller.redirect,
+        resolve: controller.resolve,
+        reset: controller.reset,
+    };
 }
 /**
  * Lazy-fetch a single marketing page by `pageKey`. The hook reads from the
@@ -2384,16 +2325,13 @@ export function BiabForm(props) {
                             return (_jsxs("div", { className: "biab-coupon-notice", children: [_jsx("p", { className: "biab-coupon-notice__text", children: text }), a.coupon?.finePrint && (_jsx("p", { className: "biab-coupon-notice__fine", children: a.coupon.finePrint }))] }, `coupon-${i}`));
                         }), consecutive ? (_jsxs("div", { className: "biab-nav", children: [_jsx("button", { className: "biab-btn biab-btn--back biab-btn--ghost", disabled: snap.isFirstStep, onClick: () => controller.back(), type: "button", children: "Back" }), !snap.isLastStep ? (_jsx("button", { className: "biab-btn biab-btn--next", disabled: !snap.canAdvance, onClick: () => controller.next(), type: "button", children: "Next" })) : (_jsx("button", { className: "biab-btn biab-btn--submit", disabled: snap.submitting || snap.uploading, onClick: () => void handleSubmit(), type: "button", children: snap.submitting ? "Sending…" : submitLabel }))] })) : (_jsx("div", { className: "biab-nav", children: _jsx("button", { className: "biab-btn biab-btn--submit", disabled: snap.submitting || snap.uploading, onClick: () => void handleSubmit(), type: "button", children: snap.submitting ? "Sending…" : submitLabel }) })), snap.result && !snap.result.ok && snap.errorList.length === 0 && (_jsx("div", { className: "biab-form__error", role: "alert", children: snap.result.message }))] }) }) }));
 }
-function SocialGlyph({ iconSlug, color, size, className, label, }) {
-    if (iconSlug) {
-        const src = color
-            ? `https://cdn.simpleicons.org/${iconSlug}/${encodeURIComponent(color)}`
-            : `https://cdn.simpleicons.org/${iconSlug}`;
+function SocialGlyph({ iconUrl, size, className, label, }) {
+    if (iconUrl) {
         return (
         // biome-ignore lint: remote brand icon from the simple-icons CDN
-        _jsx("img", { alt: label, className: className, height: size, loading: "lazy", src: src, width: size }));
+        _jsx("img", { alt: label, className: className, height: size, loading: "lazy", src: iconUrl, width: size }));
     }
-    return (_jsxs("svg", { "aria-hidden": true, className: className, fill: "none", height: size, stroke: "currentColor", strokeWidth: 1.8, viewBox: "0 0 24 24", width: size, children: [_jsx("title", { children: label }), _jsx("circle", { cx: "12", cy: "12", r: "9" }), _jsx("path", { d: "M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18" })] }));
+    return (_jsxs("svg", { "aria-hidden": true, className: className, fill: "none", height: size, stroke: "currentColor", strokeWidth: SOCIAL_FALLBACK_GLYPH.strokeWidth, viewBox: SOCIAL_FALLBACK_GLYPH.viewBox, width: size, children: [_jsx("title", { children: label }), _jsx("circle", { ...SOCIAL_FALLBACK_GLYPH.circle }), _jsx("path", { d: SOCIAL_FALLBACK_GLYPH.path })] }));
 }
 /**
  * Render every social profile on the company as an icon + link, in canonical
@@ -2402,17 +2340,135 @@ function SocialGlyph({ iconSlug, color, size, className, label, }) {
  * globe. Returns `null` when no socials are set.
  */
 export function SocialLinks({ socials, color, size = 20, className, linkClassName, iconClassName, }) {
-    const rows = resolveSocialProfiles(socials);
+    // Rows, URLs and icon URLs come from `social-core`, shared with every other
+    // binding — only the markup below is React's.
+    const rows = resolveSocialLinks(socials, { color });
     if (rows.length === 0)
         return null;
-    return (_jsx("ul", { className: className, style: {
-            display: "flex",
-            flexWrap: "wrap",
-            alignItems: "center",
-            gap: "0.75rem",
-            listStyle: "none",
-            margin: 0,
-            padding: 0,
-        }, children: rows.map((row) => (_jsx("li", { children: _jsx("a", { "aria-label": row.label, className: linkClassName, href: row.url, rel: "noopener noreferrer", target: "_blank", title: row.label, children: _jsx(SocialGlyph, { className: iconClassName, color: color, iconSlug: row.iconSlug, label: row.label, size: size }) }) }, row.key))) }));
+    return (_jsx("ul", { className: className, style: SOCIAL_LIST_STYLE, children: rows.map((row) => (_jsx("li", { children: _jsx("a", { "aria-label": row.label, className: linkClassName, href: row.url, rel: "noopener noreferrer", target: "_blank", title: row.label, children: _jsx(SocialGlyph, { className: iconClassName, iconUrl: row.iconUrl, label: row.label, size: size }) }) }, row.key))) }));
+}
+/**
+ * Headless blog for React — the native alternative to `<Blog>`, which is a
+ * hosted page in an iframe. Posts, taxonomy, a single post, comments and likes
+ * as data; the layout and the URLs are yours.
+ *
+ * ```tsx
+ * const blog = useBlog({ apiKey, baseUrl });
+ * return blog.posts.map((p) => <MyCard key={p.slug} post={p} />);
+ * ```
+ */
+export function useBlog(options) {
+    const { apiKey, baseUrl, pageSize, categoryId } = options;
+    const controller = useMemo(() => createBlogController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+        ...(pageSize ? { pageSize } : {}),
+        ...(categoryId ? { categoryId } : {}),
+    }), [apiKey, baseUrl, pageSize, categoryId]);
+    useEffect(() => {
+        void controller.load();
+        return () => controller.destroy();
+    }, [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        ...snap,
+        loadMore: controller.loadMore,
+        filterByCategory: controller.filterByCategory,
+        openPost: controller.openPost,
+        closePost: controller.closePost,
+        loadComments: controller.loadComments,
+        loadMoreComments: controller.loadMoreComments,
+        postComment: controller.postComment,
+        toggleLike: controller.toggleLike,
+    };
+}
+/**
+ * Headless email / phone verification for React.
+ *
+ * Read `flow` before rendering: `otp` wants a code field, `link` wants a
+ * "check your email" message and no field at all.
+ */
+export function useVerify(options) {
+    const { apiKey, baseUrl, kind, resendCooldownSeconds } = options;
+    const controller = useMemo(() => createVerifyController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+        kind,
+        ...(resendCooldownSeconds ? { resendCooldownSeconds } : {}),
+    }), [apiKey, baseUrl, kind, resendCooldownSeconds]);
+    useEffect(() => () => controller.destroy(), [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        ...snap,
+        start: controller.start,
+        resend: controller.resend,
+        confirm: controller.confirm,
+        canResend: controller.canResend,
+        reset: controller.reset,
+    };
+}
+/**
+ * The signed-in customer's portal for React — work, quotes, contracts,
+ * invoices, orders, downloads, shipping, reviews, referrals, profile and
+ * notification settings. The native alternative to `<Dashboard>`, which is a
+ * hosted page in an iframe.
+ *
+ * `sessionToken` is required: every portal route is scoped to the signed-in
+ * customer, and without one the portal renders empty rather than signed-out.
+ *
+ * Two things the API imposes and this hook does not hide. There are no list
+ * endpoints for invoices, quotes, contracts or shipments — `work` carries the
+ * counts and you open each by id. And a submitted review is queued for staff
+ * approval, so it will NOT appear in `reviews`; watch `reviewAwaitingModeration`
+ * to tell the customer it is pending rather than live.
+ */
+export function usePortal(options) {
+    const { apiKey, baseUrl, sessionToken } = options;
+    const controller = useMemo(() => createPortalController({
+        client: new BiabDevClient({ apiKey, baseUrl }),
+        sessionToken,
+    }), [apiKey, baseUrl, sessionToken]);
+    useEffect(() => {
+        void controller.load();
+        return () => controller.destroy();
+    }, [controller]);
+    const subscribe = useCallback((onStoreChange) => controller.subscribe(() => onStoreChange()), [controller]);
+    const getSnapshot = useCallback(() => controller.snapshot(), [controller]);
+    const snap = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return {
+        ...snap,
+        loadOrders: controller.loadOrders,
+        loadInvoices: controller.loadInvoices,
+        loadQuotes: controller.loadQuotes,
+        loadContracts: controller.loadContracts,
+        loadShipments: controller.loadShipments,
+        loadMessages: controller.loadMessages,
+        postMessage: controller.postMessage,
+        markMessagesRead: controller.markMessagesRead,
+        loadPayments: controller.loadPayments,
+        loadReviews: controller.loadReviews,
+        loadReferrals: controller.loadReferrals,
+        loadNotificationPreferences: controller.loadNotificationPreferences,
+        loadOtherOrgs: controller.loadOtherOrgs,
+        openJob: controller.openJob,
+        openOrder: controller.openOrder,
+        openInvoice: controller.openInvoice,
+        openQuote: controller.openQuote,
+        openContract: controller.openContract,
+        trackShipment: controller.trackShipment,
+        closeDetail: controller.closeDetail,
+        postJobComment: controller.postJobComment,
+        acceptQuote: controller.acceptQuote,
+        rejectQuote: controller.rejectQuote,
+        signContract: controller.signContract,
+        payInvoice: controller.payInvoice,
+        updateProfile: controller.updateProfile,
+        updateNotificationPreferences: controller.updateNotificationPreferences,
+        submitReview: controller.submitReview,
+        submitReturnRequest: controller.submitReturnRequest,
+        contactCompany: controller.contactCompany,
+    };
 }
 //# sourceMappingURL=react.js.map