@mediansh/widget 0.1.0

package/dist/highlighted-body-OFNGDK62-UN447WAU.js

@@ -0,0 +1,28 @@
+"use client";
+"use client";
+import {
+  At,
+  Li,
+  R
+} from "./chunk-6E3NBXLE.js";
+
+// ../../node_modules/.bun/streamdown@2.5.0+005eabf3d8b6ef06/node_modules/streamdown/dist/highlighted-body-OFNGDK62.js
+import { useContext, useState, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+var R2 = ({ code: s, language: e, raw: t, className: h, startLine: d, lineNumbers: m, ...p }) => {
+  let { shikiTheme: l } = useContext(R), o = Li(), [a, i] = useState(t);
+  return useEffect(() => {
+    if (!o) {
+      i(t);
+      return;
+    }
+    let r = o.highlight({ code: s, language: e, themes: l }, (c) => {
+      i(c);
+    });
+    r && i(r);
+  }, [s, e, l, o, t]), jsx(At, { className: h, language: e, lineNumbers: m, result: a, startLine: d, ...p });
+};
+export {
+  R2 as HighlightedCodeBlockBody
+};
+//# sourceMappingURL=highlighted-body-OFNGDK62-UN447WAU.js.map

package/dist/highlighted-body-OFNGDK62-UN447WAU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../node_modules/.bun/streamdown@2.5.0+005eabf3d8b6ef06/node_modules/streamdown/dist/highlighted-body-OFNGDK62.js"],"sourcesContent":["\"use client\";\nimport {A,f,c}from'./chunk-BO2N2NFS.js';import {useContext,useState,useEffect}from'react';import {jsx}from'react/jsx-runtime';var R=({code:s,language:e,raw:t,className:h,startLine:d,lineNumbers:m,...p})=>{let{shikiTheme:l}=useContext(A),o=f(),[a,i]=useState(t);return useEffect(()=>{if(!o){i(t);return}let r=o.highlight({code:s,language:e,themes:l},c=>{i(c);});r&&i(r);},[s,e,l,o,t]),jsx(c,{className:h,language:e,lineNumbers:m,result:a,startLine:d,...p})};export{R as HighlightedCodeBlockBody};"],"mappings":";;;;;;;;;AACwC,SAAQ,YAAW,UAAS,iBAAc;AAAQ,SAAQ,WAAQ;AAAoB,IAAIA,KAAE,CAAC,EAAC,MAAK,GAAE,UAAS,GAAE,KAAI,GAAE,WAAU,GAAE,WAAU,GAAE,aAAY,GAAE,GAAG,EAAC,MAAI;AAAC,MAAG,EAAC,YAAW,EAAC,IAAE,WAAW,CAAC,GAAE,IAAE,GAAE,GAAE,CAAC,GAAE,CAAC,IAAE,SAAS,CAAC;AAAE,SAAO,UAAU,MAAI;AAAC,QAAG,CAAC,GAAE;AAAC,QAAE,CAAC;AAAE;AAAA,IAAM;AAAC,QAAI,IAAE,EAAE,UAAU,EAAC,MAAK,GAAE,UAAS,GAAE,QAAO,EAAC,GAAE,OAAG;AAAC,QAAE,CAAC;AAAA,IAAE,CAAC;AAAE,SAAG,EAAE,CAAC;AAAA,EAAE,GAAE,CAAC,GAAE,GAAE,GAAE,GAAE,CAAC,CAAC,GAAE,IAAI,IAAE,EAAC,WAAU,GAAE,UAAS,GAAE,aAAY,GAAE,QAAO,GAAE,WAAU,GAAE,GAAG,EAAC,CAAC;AAAC;","names":["R"]}

package/dist/index.d.ts

@@ -0,0 +1,525 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+
+/**
+ * The customer facing side of Median. These types are the shape the SDK will
+ * hand the widget, so they stay free of anything Convex or Clerk specific: a
+ * host app should be able to build one of these from its own data.
+ */
+
+/**
+ * What is on the page while the panel is closed.
+ *
+ * `bubble` is the button in the corner, and is what a widget is. `hidden`
+ * leaves the page alone entirely, for a host who opens support from their own
+ * nav, their own button, or their own keyboard shortcut. Either way the panel
+ * is one call away, and comes up out of the same corner.
+ */
+type SupportLauncherKind = "bubble" | "hidden";
+
+/**
+ * What has been going wrong on the page, kept ready in case somebody asks
+ * for help about it.
+ *
+ * A support agent's first three questions are always the same: what were you
+ * doing, what did it say, and what does the console show. The customer can
+ * answer the first one. This answers the other two, so a bug report arrives
+ * with the error already attached rather than after four messages of asking.
+ *
+ * Off unless a host switches it on. Everything here reads their program's
+ * error stream, which is theirs to offer rather than ours to take.
+ *
+ * A bounded ring buffer and nothing else. Nothing is sent on its own, nothing
+ * is stored, and nothing is polled: the newest snapshot rides the next message
+ * the customer sends, and only when there is something new in it.
+ */
+/** What a host can switch on. `true` is the passive half. */
+type MedianDiagnostics = boolean | {
+    /** Uncaught errors and rejected promises. On whenever diagnostics are. */
+    errors?: boolean;
+    /** Requests that failed or came back unhappy. Wraps window.fetch. */
+    network?: boolean;
+    /** console.error calls. Wraps console.error. */
+    console?: boolean;
+};
+
+/** What a host can tell us about who is in the widget. All of it optional. */
+type MedianUser = {
+    /**
+     * Your own id for this person, and that id signed from MEDIAN_KEY.
+     *
+     * The pair is what makes a conversation follow somebody rather than a
+     * browser: sign in on a phone and the thread from the laptop is already
+     * there. Both or neither, and the signing belongs on your server, because
+     * whoever holds the key can claim to be any of your customers.
+     *
+     * Without them the widget still works. It is just this browser's thread,
+     * which is what it has always been.
+     */
+    id?: string;
+    hash?: string;
+    name?: string;
+    email?: string;
+    /**
+     * Their profile picture, so the team sees who they are talking to rather
+     * than a letter. Has to be an https URL; anything else is ignored.
+     */
+    avatarUrl?: string;
+    /** Anything else worth showing the team: plan, company, whatever. */
+    metadata?: Record<string, string>;
+};
+
+type MedianSupportProps = {
+    apiKey: string;
+    /** Who is signed in on the host's site, if anyone. Shown to the team. */
+    user?: MedianUser;
+    /**
+     * Whether a message carries what the browser already knows: time zone,
+     * language, browser, OS, device, screen, and the page it was sent from.
+     * On by default, because a team that has to ask for all six spends its
+     * first reply asking. Pass `false` and none of it is read at all.
+     */
+    telemetry?: boolean;
+    /**
+     * Take questions from signed in people only.
+     *
+     * Until `user` says somebody is there, the panel asks them to sign in
+     * instead of offering a composer, and no conversation is opened or read.
+     * Pass `user` the moment you have it and the thread takes over.
+     *
+     * A rule about your own page, kept on your own page: it decides what this
+     * widget offers, not what the API accepts. `user.id` with a signed `hash`
+     * is the part nobody can talk their way around.
+     */
+    requireSignIn?: boolean;
+    /**
+     * Where your sign in lives, for the button on that panel.
+     *
+     *   <MedianSupport
+     *     apiKey="median_pk_..."
+     *     requireSignIn
+     *     onSignIn={() => router.push("/login")}
+     *   />
+     *
+     * Without it the panel says the same thing and offers no button, which is
+     * right for a site whose sign in is already the first thing on the page.
+     */
+    onSignIn?: () => void;
+    /**
+     * Ask for an email before a visitor's first message. On by default: an
+     * anonymous thread cannot be followed up, and half of support is getting
+     * back to somebody. Pass `false` and the composer opens straight away.
+     *
+     * The composer asks once per browser; the answer rides their first message
+     * and lands with their details on your side. A visitor your `user` already
+     * names an email for is never asked, and `medianSupport.reset()` asks the
+     * next person instead.
+     *
+     * Your team can turn the question off from the dashboard without a
+     * redeploy, and either side saying no is enough to keep it away.
+     */
+    requireEmail?: boolean;
+    /**
+     * Watch what goes wrong on the page, so a bug report arrives with the
+     * error already attached instead of after four messages of asking.
+     *
+     *   <MedianSupport apiKey="median_pk_..." diagnostics />
+     *
+     * `true` listens for uncaught errors and rejected promises, which changes
+     * nothing about how your page runs. The object form adds the two that wrap
+     * something of yours:
+     *
+     *   diagnostics={{ network: true, console: true }}
+     *
+     * `network` wraps window.fetch to note requests that failed, `console`
+     * wraps console.error. Both call through to what they replaced, and both
+     * are put back when the widget leaves the page.
+     *
+     * Off by default: this reads your program's error stream, which is yours
+     * to offer rather than ours to take. Nothing is sent on its own. The
+     * newest snapshot rides the next message the customer sends, and only when
+     * something new is in it.
+     */
+    diagnostics?: MedianDiagnostics;
+    /**
+     * Anything about your own app worth having next to a bug report: a build,
+     * a route, a flag. Read when a message is sent, so it can change as they
+     * move around.
+     *
+     *   <MedianSupport
+     *     apiKey="median_pk_..."
+     *     diagnostics
+     *     appState={{ version: BUILD_SHA, plan: user.plan }}
+     *   />
+     *
+     * Twenty entries at most, and each one a line rather than a document.
+     */
+    appState?: Record<string, string | number | boolean>;
+    /** Our button in the corner while it is closed, or nothing at all. */
+    launcher?: SupportLauncherKind;
+    /** Pass it, with `onOpenChange`, to hold the open state yourself. */
+    open?: boolean;
+    /** Every open and close, whoever asked for it. */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Take the visitor to a page, when one of your own tools asks for it.
+     *
+     *   <MedianSupport apiKey="median_pk_..." onNavigate={router.push} />
+     *
+     * Called with a path on your own site, already checked against this page's
+     * origin. Your router decides what happens: pass `router.push` and the
+     * conversation stays open across the move.
+     *
+     * Without it a tool that asks to navigate cannot, and says so in the
+     * console while you are building. Nothing else needs it.
+     */
+    onNavigate?: (path: string) => void;
+};
+/**
+ * The whole SDK, as one component. Drop it on a page with your publishable API
+ * key and the launcher, the thread, the AI and the inbox on the other side are
+ * all wired up:
+ *
+ *   <MedianSupport apiKey="median_pk_..." />
+ *
+ * Optionally say who is signed in, and the team sees a person rather than
+ * another anonymous visitor:
+ *
+ *   <MedianSupport
+ *     apiKey="median_pk_..."
+ *     user={{ name: "Ada", email: "ada@example.com" }}
+ *   />
+ *
+ * There are three states rather than two: open, closed as a button in the
+ * corner, and not on the page at all. Take the corner back and open it from
+ * your own nav, from anywhere in your app, with no state to thread through:
+ *
+ *   <MedianSupport apiKey="median_pk_..." launcher="hidden" />
+ *
+ *   const support = useMedianSupport();
+ *   <button onClick={support.open}>Contact us</button>
+ *
+ * On a site nobody uses signed out, say so and the panel asks them to sign in
+ * rather than opening a conversation with a stranger:
+ *
+ *   <MedianSupport
+ *     apiKey="median_pk_..."
+ *     user={session?.user}
+ *     requireSignIn
+ *     onSignIn={() => router.push("/login")}
+ *   />
+ *
+ * When somebody signs out, `medianSupport.reset()` forgets the conversation
+ * along with them, so the next person at the keyboard starts fresh.
+ *
+ * That is the surface, on purpose. Everything else a support widget could be
+ * asked to do is either our decision or a setting on the dashboard, so it can
+ * change without every host having to redeploy.
+ *
+ * It brings its own connection, so it works on pages (and sites) that have
+ * never heard of Convex.
+ */
+declare function MedianSupport(props: MedianSupportProps): react.JSX.Element;
+
+/**
+ * What a mounted widget hands back: the two things a host without React has
+ * no re-render to do for them. Everything else goes through `medianSupport`,
+ * same as anywhere.
+ */
+type MedianSupportInstance = {
+    /**
+     * Change any option after mount. Only the keys passed change, so
+     * `update({ user })` when somebody signs in leaves the rest alone.
+     */
+    update: (options: Partial<MedianSupportProps>) => void;
+    /** Take the widget off the page: panel, launcher, connection, all of it. */
+    unmount: () => void;
+};
+/**
+ * The same widget, for a page that has never heard of React: Vue, Svelte,
+ * Rails, a script on plain HTML. One call puts the launcher in the corner,
+ * wired to the same panel, thread and inbox as the component:
+ *
+ *   const support = mountMedianSupport({ apiKey: "median_pk_..." });
+ *
+ * It takes the component's props, as one options object, and the rest of the
+ * SDK does not know the difference: `medianSupport.open()` opens this widget
+ * exactly as it opens the component.
+ *
+ * What would have been new props on a re-render is `update`:
+ *
+ *   support.update({ user: { name: "Ada", email: "ada@example.com" } });
+ *
+ * It renders into a container of its own, appended to `<body>`, with the
+ * package's copy of React. The host's page needs none and never sees it.
+ */
+declare function mountMedianSupport(options: MedianSupportProps): MedianSupportInstance;
+
+/**
+ * Filing the crash the visitor is looking at.
+ *
+ * Every other send in the SDK starts with somebody typing. This one starts
+ * with a page that has stopped working, which is the report nobody writes:
+ * whoever was using it can see that it broke and has nothing to add about
+ * why. So the error describes itself, the browser hands over what it was
+ * doing, and one press files it.
+ *
+ * It brings its own connection and reads its key from the last widget that
+ * mounted, because by the time this runs the tree that widget lived in has
+ * usually been replaced by the error screen calling it. Nothing here needs a
+ * component, a provider, or a panel on the page.
+ *
+ * It never throws. A crash screen that crashes reporting a crash is a poor
+ * apology, so everything that can go wrong comes back as a reason instead.
+ */
+type MedianErrorReportOptions = {
+    /**
+     * The key, when no widget has mounted on this page to remember it. Both
+     * panels write theirs down as they mount, so an app with either one
+     * installed can leave this alone.
+     */
+    apiKey?: string;
+    /** Who is in the chair. Defaults to whoever the mounted widget was given. */
+    user?: MedianUser;
+    /**
+     * Where it happened, when your router names the page better than its URL
+     * does: "/orders/[id]" rather than "/orders/8912". It leads the title, so
+     * the same crash on the same route is one row on the list however many
+     * people hit it. Defaults to the path in the address bar.
+     */
+    route?: string;
+    /** React's component stack, when your boundary was handed one. */
+    componentStack?: string;
+    /** Facts to put on the report, the same shape as `appState`. */
+    state?: Record<string, string | number | boolean>;
+    /** Blocks to attach, the same shape and limits as `attach`. */
+    attach?: Record<string, unknown>;
+    /** Whether the report carries what the browser knows. On by default. */
+    telemetry?: boolean;
+};
+/** Where the report went, or why it did not go. */
+type MedianErrorReportOutcome = {
+    reported: true;
+    /** True when somebody had already reported this one. */
+    joined: boolean;
+} | {
+    reported: false;
+    reason: string;
+};
+declare function reportError(error: unknown, options?: MedianErrorReportOptions): Promise<MedianErrorReportOutcome>;
+/**
+ * Whether a report has anywhere to go: a widget has mounted on this page and
+ * left its key, and this build knows which Median to send to.
+ *
+ * For a "Report error" button, which should not be on the screen at all if
+ * pressing it could only ever fail. It follows the install rather than
+ * reading it once, since an error screen can render before the widget does.
+ */
+declare function useCanReportError(): boolean;
+
+/**
+ * The widget from anywhere, React or not: the same shape the hook hands
+ * back, for a plain `onclick` or a shortcut listener that never sees a
+ * component. `isOpen` reads live but does not re-render anything; the hook
+ * is for that.
+ */
+declare const medianSupport: {
+    /** What the panel is doing right now. */
+    readonly isOpen: boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    /**
+     * Put your own data on the next bug report: a crash trace from your error
+     * handler, a request id, the state of a store. Objects are written out as
+     * JSON. Entries ride the visitor's next message and land on the report,
+     * whether or not diagnostics are on.
+     */
+    attach(label: string, value: unknown): void;
+    /**
+     * File the crash your error screen is showing, with everything the browser
+     * was doing when it happened. One press from a "Report error" button:
+     *
+     *   const outcome = await medianSupport.reportError(error);
+     *
+     * It answers rather than throws, so the screen can say whether it landed.
+     * It works from a boundary with no widget left under it, which is most of
+     * them.
+     */
+    reportError(error: unknown, options?: MedianErrorReportOptions): Promise<MedianErrorReportOutcome>;
+    /**
+     * Forget this browser's conversation, so the next one starts fresh and
+     * anonymous. Call it when your user signs out: whoever sits down next
+     * should not find somebody else's thread waiting.
+     */
+    reset(): void;
+};
+/** The shape of {@link medianSupport}, and of what the hook returns. */
+type MedianSupportControl = {
+    /** Whether the panel is open. */
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    /** Put your own data on the next bug report: a crash trace, an id. */
+    attach: (label: string, value: unknown) => void;
+    /** File the crash your error screen is showing. For a report button. */
+    reportError: (error: unknown, options?: MedianErrorReportOptions) => Promise<MedianErrorReportOutcome>;
+    /** Forget this browser's conversation. For sign out. */
+    reset: () => void;
+};
+/**
+ * The widget, from anywhere else on the page:
+ *
+ *   const support = useMedianSupport();
+ *
+ *   <button onClick={support.open}>Contact us</button>
+ *
+ * `isOpen` follows the panel however it was opened, so a trigger can render
+ * itself as pressed, or step out of the way while the panel is up.
+ */
+declare function useMedianSupport(): MedianSupportControl;
+
+type MedianFeedbackProps = {
+    apiKey: string;
+    /**
+     * Your own trigger. Whatever you pass is rendered where you put it and the
+     * panel hangs off it, the way a dropdown hangs off the thing that opens
+     * it:
+     *
+     *   <MedianFeedback apiKey="median_pk_...">
+     *     <button>Share feedback</button>
+     *   </MedianFeedback>
+     *
+     * It is wrapped in an inline span that takes the click, so your button
+     * keeps its own styles and needs to know nothing about any of this.
+     *
+     * Without children the panel sits in the bottom right corner instead, for
+     * a host opening it from somewhere else entirely with
+     * `useMedianFeedback()`.
+     */
+    children?: ReactNode;
+    /**
+     * Something already on your page for the panel to hang off, as a CSS
+     * selector. For the case children cannot cover: a row inside a dropdown,
+     * which closes itself opening this and takes the trigger with it.
+     *
+     *   <MedianFeedback apiKey="median_pk_..." anchor="#account-button" />
+     *
+     * Looked up each time the panel is placed, so it works for anything that
+     * comes and goes. Unlike a trigger it is only a position: pressing it does
+     * not open or close the panel, and a press on it dismisses the panel like
+     * a press anywhere else. Ignored when `children` are passed.
+     */
+    anchor?: string;
+    /** Who is signed in on your site, if anyone. Shown to your team. */
+    user?: MedianUser;
+    /**
+     * Whether a note carries what the browser already knows: time zone,
+     * language, browser, OS, device, screen, and the page it was written on.
+     * On by default, because the page is most of what makes a note actionable,
+     * which is what the panel says out loud. Pass `false` and none of it is
+     * read at all.
+     */
+    telemetry?: boolean;
+    /**
+     * Watch what goes wrong on the page, so a bug filed from a note arrives
+     * with the error already attached. The same switch `<MedianSupport>`
+     * takes, and the same buffer behind it: mount either one with it on.
+     */
+    diagnostics?: MedianDiagnostics;
+    /**
+     * Anything about your own app worth having next to a bug report: a build,
+     * a route, a flag. Read when a note is sent.
+     */
+    appState?: Record<string, string | number | boolean>;
+    /** Pass it, with `onOpenChange`, to hold the open state yourself. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Any CSS length. The panel never grows past the viewport whatever this says. */
+    width?: string;
+    /** The heading, for a host whose product calls this something else. */
+    title?: string;
+    /** The line under it. */
+    description?: string;
+    placeholder?: string;
+};
+/**
+ * A feedback panel, hung off a trigger of your own.
+ *
+ * One box and one button. Whoever is on the page types a sentence, and a
+ * fast model reads it: a bug goes on the bug list, an idea goes on the
+ * suggestions list, and an advert goes nowhere. Nobody has to pick a
+ * category, rank anything, or write a title, which is the point, because a
+ * form that asks for those is a form nobody fills in.
+ *
+ *   <MedianFeedback apiKey="median_pk_...">
+ *     <MenuItem>Share feedback</MenuItem>
+ *   </MedianFeedback>
+ *
+ * The page they were on rides along on its own, which the line under the
+ * title says plainly.
+ *
+ * It brings its own connection, so it works on pages that have never heard
+ * of Convex, and it is independent of `<MedianSupport>`: mount either, both,
+ * or neither. Mounted together they share a visitor, so the same person
+ * writing in and leaving a note is one customer with both to their name.
+ */
+declare function MedianFeedback(props: MedianFeedbackProps): react.JSX.Element;
+
+/**
+ * What a mounted panel hands back: the two things a host without React has
+ * no re-render to do for them. Opening and closing go through
+ * `medianFeedback`, same as anywhere.
+ */
+type MedianFeedbackInstance = {
+    /**
+     * Change any option after mount. Only the keys passed change, so
+     * `update({ user })` when somebody signs in leaves the rest alone.
+     */
+    update: (options: Partial<MedianFeedbackProps>) => void;
+    /** Take the panel off the page. */
+    unmount: () => void;
+};
+/**
+ * The same panel, for a page that has never heard of React: Vue, Svelte,
+ * Rails, a script on plain HTML.
+ *
+ *   const feedback = mountMedianFeedback({ apiKey: "median_pk_..." });
+ *
+ *   document.querySelector("#feedback").onclick = () => medianFeedback.open();
+ *
+ * There is no trigger to wrap out here, so the panel opens in the bottom
+ * right corner and your own button says when. Everything else is the
+ * component's, unchanged.
+ */
+declare function mountMedianFeedback(options: Omit<MedianFeedbackProps, "children">): MedianFeedbackInstance;
+
+declare const medianFeedback: {
+    /** What the panel is doing right now. */
+    readonly isOpen: boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+};
+/** The shape of {@link medianFeedback}, and of what the hook returns. */
+type MedianFeedbackControl = {
+    /** Whether the panel is open. */
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+};
+/**
+ * The feedback panel, from anywhere else on the page:
+ *
+ *   const feedback = useMedianFeedback();
+ *
+ *   <button onClick={feedback.open}>Share feedback</button>
+ *
+ * `isOpen` follows the panel however it was opened, so a menu row can render
+ * itself as pressed while it is up.
+ */
+declare function useMedianFeedback(): MedianFeedbackControl;
+
+export { type MedianDiagnostics, type MedianErrorReportOptions, type MedianErrorReportOutcome, MedianFeedback, type MedianFeedbackControl, type MedianFeedbackInstance, type MedianFeedbackProps, MedianSupport, type MedianSupportControl, type MedianSupportInstance, type MedianSupportProps, type MedianUser, type MedianDiagnostics as PortalDiagnostics, type MedianErrorReportOptions as PortalErrorReportOptions, type MedianErrorReportOutcome as PortalErrorReportOutcome, MedianFeedback as PortalFeedback, type MedianFeedbackControl as PortalFeedbackControl, type MedianFeedbackInstance as PortalFeedbackInstance, type MedianFeedbackProps as PortalFeedbackProps, MedianSupport as PortalSupport, type MedianSupportControl as PortalSupportControl, type MedianSupportInstance as PortalSupportInstance, type MedianSupportProps as PortalSupportProps, type MedianUser as PortalUser, type SupportLauncherKind, medianFeedback, medianSupport, mountMedianFeedback, mountMedianSupport, mountMedianFeedback as mountPortalFeedback, mountMedianSupport as mountPortalSupport, medianFeedback as portalFeedback, medianSupport as portalSupport, reportError, useCanReportError, useMedianFeedback, useMedianSupport, useMedianFeedback as usePortalFeedback, useMedianSupport as usePortalSupport };