grist-widget-sdk 0.3.26 → 0.4.0

package/dist/chunk-P6VTEKWO.js

@@ -0,0 +1,618 @@
+import {
+  GristBoundary,
+  GristWidgetProvider,
+  deriveColumnMappingStatus,
+  deriveStatus,
+  isAccessInsufficientError,
+  parseGristWidgetLinkingInfo,
+  useNearestGristState
+} from "./chunk-O7NY46QY.js";
+
+// src/app/deploy-path.ts
+var VERSION_SEGMENT = /^v(\d+\.\d+\.\d+(?:-[\w.]+)?)$/;
+function parseDeployPath(pathname) {
+  const segments = pathname.replace(/\/+$/, "").split("/");
+  const last = segments[segments.length - 1] ?? "";
+  let channel = null;
+  if (last === "latest") channel = { kind: "latest" };
+  else if (last === "dev") channel = { kind: "dev" };
+  else {
+    const match = VERSION_SEGMENT.exec(last);
+    if (match) channel = { kind: "version", version: match[1] };
+  }
+  if (!channel) return { channel: { kind: "latest" }, basePath: withTrailingSlash(pathname) };
+  return { channel, basePath: withTrailingSlash(segments.slice(0, -1).join("/")) };
+}
+function deployChannelLabel(channel) {
+  return channel.kind === "version" ? `v${channel.version}` : channel.kind;
+}
+function withTrailingSlash(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+
+// src/app/released-versions.ts
+import { useEffect, useState } from "react";
+function useReleasedVersions(pathname = typeof window === "undefined" ? "/" : window.location.pathname) {
+  const url = `${parseDeployPath(pathname).basePath}versions.json`;
+  const [result, setResult] = useState({ versions: null, error: false });
+  useEffect(() => {
+    let cancelled = false;
+    fetch(url, { cache: "no-store" }).then((res) => res.ok ? res.json() : Promise.reject(new Error(`HTTP ${res.status}`))).then((data) => {
+      if (cancelled) return;
+      if (!Array.isArray(data)) throw new Error("versions.json is not an array");
+      setResult({ versions: data, error: false });
+    }).catch(() => {
+      if (!cancelled) setResult({ versions: null, error: true });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [url]);
+  return result;
+}
+
+// src/app/widget-theme.tsx
+import { createContext, useCallback, useContext, useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import { jsx } from "react/jsx-runtime";
+var STORAGE_KEY = "theme";
+var DARK_QUERY = "(prefers-color-scheme: dark)";
+var THEMES = ["light", "dark", "system"];
+var ThemeContext = createContext(null);
+function useTheme() {
+  const value = useContext(ThemeContext);
+  return value ?? { theme: "system", resolvedTheme: systemTheme(), setTheme: noop };
+}
+function EmbeddedThemeProvider({ children }) {
+  const gristTheme = useNearestGristState().state.theme;
+  const system = useSystemTheme(gristTheme === null);
+  const resolvedTheme = gristTheme ?? system;
+  useApplyTheme(resolvedTheme);
+  const value = useMemo(
+    () => ({ theme: gristTheme ?? "system", resolvedTheme, setTheme: noop }),
+    [gristTheme, resolvedTheme]
+  );
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children });
+}
+function StandaloneThemeProvider({ children }) {
+  const [theme, setThemeState] = useState2(() => readStoredTheme() ?? "system");
+  const system = useSystemTheme(theme === "system");
+  const resolvedTheme = theme === "system" ? system : theme;
+  useApplyTheme(resolvedTheme);
+  const setTheme = useCallback((next) => {
+    writeStoredTheme(next);
+    setThemeState(next);
+  }, []);
+  useEffect2(() => {
+    const onKeyDown = (event) => {
+      if (event.repeat || event.metaKey || event.ctrlKey || event.altKey) return;
+      if (event.key.toLowerCase() !== "d" || isEditableTarget(event.target)) return;
+      setThemeState((current) => {
+        const currentResolved = current === "system" ? systemTheme() : current;
+        const next = currentResolved === "dark" ? "light" : "dark";
+        writeStoredTheme(next);
+        return next;
+      });
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, []);
+  useEffect2(() => {
+    const onStorage = (event) => {
+      if (event.key !== STORAGE_KEY) return;
+      setThemeState(isTheme(event.newValue) ? event.newValue : "system");
+    };
+    window.addEventListener("storage", onStorage);
+    return () => window.removeEventListener("storage", onStorage);
+  }, []);
+  const value = useMemo(
+    () => ({ theme, resolvedTheme, setTheme }),
+    [theme, resolvedTheme, setTheme]
+  );
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children });
+}
+function useSystemTheme(active) {
+  const [theme, setTheme] = useState2(systemTheme);
+  useEffect2(() => {
+    if (!active || typeof window.matchMedia !== "function") return;
+    const query = window.matchMedia(DARK_QUERY);
+    const onChange = () => setTheme(query.matches ? "dark" : "light");
+    onChange();
+    query.addEventListener("change", onChange);
+    return () => query.removeEventListener("change", onChange);
+  }, [active]);
+  return theme;
+}
+function useApplyTheme(theme) {
+  useEffect2(() => {
+    const root = document.documentElement;
+    if (root.classList.contains(theme) && !root.classList.contains(other(theme))) return;
+    const restoreTransitions = suspendTransitions();
+    root.classList.remove(other(theme));
+    root.classList.add(theme);
+    restoreTransitions();
+  }, [theme]);
+}
+function systemTheme() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return "light";
+  return window.matchMedia(DARK_QUERY).matches ? "dark" : "light";
+}
+function other(theme) {
+  return theme === "dark" ? "light" : "dark";
+}
+function suspendTransitions() {
+  const style = document.createElement("style");
+  style.appendChild(
+    document.createTextNode("*,*::before,*::after{-webkit-transition:none!important;transition:none!important}")
+  );
+  document.head.appendChild(style);
+  return () => {
+    window.getComputedStyle(document.body);
+    requestAnimationFrame(() => requestAnimationFrame(() => style.remove()));
+  };
+}
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  return target.isContentEditable || target.closest("input, textarea, select, [contenteditable='true']") !== null;
+}
+function isTheme(value) {
+  return value !== null && THEMES.includes(value);
+}
+function readStoredTheme() {
+  try {
+    const value = localStorage.getItem(STORAGE_KEY);
+    return isTheme(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeStoredTheme(theme) {
+  try {
+    localStorage.setItem(STORAGE_KEY, theme);
+  } catch {
+  }
+}
+function noop() {
+}
+
+// src/app/mount-grist-widget.tsx
+import { StrictMode, Suspense } from "react";
+import { createRoot } from "react-dom/client";
+
+// src/app/chrome/tokens.ts
+var token = (name, fallback) => `var(--${name}, ${fallback})`;
+var tokens = {
+  background: token("background", "#ffffff"),
+  foreground: token("foreground", "#0a0a0a"),
+  card: token("card", "#ffffff"),
+  mutedForeground: token("muted-foreground", "#737373"),
+  border: token("border", "#e5e5e5"),
+  primary: token("primary", "#171717"),
+  primaryForeground: token("primary-foreground", "#fafafa"),
+  destructive: token("destructive", "#dc2626"),
+  radius: token("radius", "0.625rem")
+};
+var pageStyle = {
+  boxSizing: "border-box",
+  display: "flex",
+  flexDirection: "column",
+  justifyContent: "center",
+  maxWidth: "28rem",
+  minHeight: "100%",
+  margin: "0 auto",
+  padding: "4rem 1.5rem",
+  color: tokens.foreground,
+  font: "inherit"
+};
+var eyebrowStyle = {
+  margin: "0 0 0.5rem",
+  textAlign: "center",
+  fontSize: "0.875rem",
+  fontWeight: 500,
+  color: tokens.mutedForeground
+};
+var headingStyle = {
+  margin: 0,
+  textAlign: "center",
+  fontSize: "1.5rem",
+  fontWeight: 600,
+  letterSpacing: "-0.01em"
+};
+var leadStyle = {
+  margin: "0.75rem auto 2rem",
+  maxWidth: "24rem",
+  textAlign: "center",
+  fontSize: "0.875rem",
+  lineHeight: 1.5,
+  color: tokens.mutedForeground
+};
+var cardStyle = {
+  boxSizing: "border-box",
+  marginBottom: "1rem",
+  padding: "1.25rem",
+  border: `1px solid ${tokens.border}`,
+  borderRadius: tokens.radius,
+  background: tokens.card
+};
+var cardTitleStyle = {
+  margin: "0 0 0.375rem",
+  fontSize: "1rem",
+  fontWeight: 600
+};
+var cardTextStyle = {
+  margin: 0,
+  fontSize: "0.875rem",
+  lineHeight: 1.5,
+  color: tokens.mutedForeground
+};
+var codeStyle = {
+  fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+  fontSize: "0.8125rem",
+  color: tokens.foreground
+};
+
+// src/app/chrome/widget-title.ts
+function widgetTitle() {
+  const title = typeof document === "undefined" ? "" : document.title.trim();
+  return title || "Grist widget";
+}
+
+// src/app/chrome/local-dev-page.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function LocalDevPage() {
+  return /* @__PURE__ */ jsxs("main", { style: pageStyle, children: [
+    /* @__PURE__ */ jsxs("p", { style: eyebrowStyle, children: [
+      widgetTitle(),
+      " \xB7 local dev"
+    ] }),
+    /* @__PURE__ */ jsx2("h1", { style: headingStyle, children: "Not embedded in Grist" }),
+    /* @__PURE__ */ jsx2("p", { style: leadStyle, children: "This is the local dev server: there's no Grist here to render the widget against." }),
+    /* @__PURE__ */ jsxs("section", { style: cardStyle, children: [
+      /* @__PURE__ */ jsx2("h2", { style: cardTitleStyle, children: "Check it against real Grist" }),
+      /* @__PURE__ */ jsxs("p", { style: cardTextStyle, children: [
+        "Push to ",
+        /* @__PURE__ */ jsx2("code", { style: codeStyle, children: "dev" }),
+        ", then open its ",
+        /* @__PURE__ */ jsx2("code", { style: codeStyle, children: "/dev/" }),
+        " URL in a custom widget of a real Grist document: later pushes reload it there within seconds. Locally,",
+        " ",
+        /* @__PURE__ */ jsx2("code", { style: codeStyle, children: "pnpm test" }),
+        " runs the widget against an emulated Grist."
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { style: cardStyle, children: [
+      /* @__PURE__ */ jsx2("h2", { style: cardTitleStyle, children: "Starting from another example?" }),
+      /* @__PURE__ */ jsxs("p", { style: cardTextStyle, children: [
+        /* @__PURE__ */ jsx2("code", { style: codeStyle, children: "npx create-grist-widget list" }),
+        " shows the examples, and",
+        " ",
+        /* @__PURE__ */ jsx2("code", { style: codeStyle, children: "npx create-grist-widget use <example>" }),
+        " swaps this widget for one."
+      ] })
+    ] })
+  ] });
+}
+
+// src/app/chrome/release-page.tsx
+import { useState as useState3 } from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function ReleasePage({ channel }) {
+  const label = deployChannelLabel(channel);
+  return /* @__PURE__ */ jsxs2("main", { style: pageStyle, children: [
+    /* @__PURE__ */ jsxs2("p", { style: eyebrowStyle, children: [
+      widgetTitle(),
+      " \xB7 ",
+      label
+    ] }),
+    /* @__PURE__ */ jsx3("h1", { style: headingStyle, children: "Grist isn't loaded here" }),
+    /* @__PURE__ */ jsxs2("p", { style: leadStyle, children: [
+      "This is the ",
+      /* @__PURE__ */ jsx3("code", { style: codeStyle, children: label }),
+      " build, opened outside Grist. Hover a version to see when it was released."
+    ] }),
+    /* @__PURE__ */ jsx3(ChannelLinks, { current: channel }),
+    /* @__PURE__ */ jsx3(InstallUrl, {})
+  ] });
+}
+function ChannelLinks({ current }) {
+  const { basePath } = parseDeployPath(window.location.pathname);
+  const { versions } = useReleasedVersions();
+  const isCurrent = (channel) => channel.kind === current.kind && (channel.kind !== "version" || current.kind === "version" && channel.version === current.version);
+  return /* @__PURE__ */ jsxs2("nav", { "aria-label": "Versions", style: { display: "flex", flexWrap: "wrap", justifyContent: "center", gap: "0.5rem", marginBottom: "2rem" }, children: [
+    /* @__PURE__ */ jsx3(ChannelLink, { href: `${basePath}latest/`, active: isCurrent({ kind: "latest" }), children: "latest" }),
+    /* @__PURE__ */ jsx3(ChannelLink, { href: `${basePath}dev/`, active: isCurrent({ kind: "dev" }), children: "dev" }),
+    versions?.map((v) => /* @__PURE__ */ jsx3(
+      ChannelLink,
+      {
+        href: `${basePath}v${v.version}/`,
+        title: formatDate(v.publishedAt),
+        active: isCurrent({ kind: "version", version: v.version }),
+        children: `v${v.version}`
+      },
+      v.version
+    ))
+  ] });
+}
+function ChannelLink({
+  href,
+  title,
+  active,
+  children
+}) {
+  const style = {
+    padding: "0.25rem 0.75rem",
+    border: `1px solid ${active ? tokens.primary : tokens.border}`,
+    borderRadius: "9999px",
+    background: active ? tokens.primary : "transparent",
+    color: active ? tokens.primaryForeground : tokens.mutedForeground,
+    fontSize: "0.75rem",
+    fontWeight: 500,
+    textDecoration: "none"
+  };
+  return /* @__PURE__ */ jsx3("a", { href, title, "aria-current": active ? "page" : void 0, style, children });
+}
+function InstallUrl() {
+  const url = window.location.href;
+  const [copied, setCopied] = useState3(false);
+  function copy() {
+    void navigator.clipboard?.writeText(url).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    });
+  }
+  return /* @__PURE__ */ jsxs2("section", { style: cardStyle, children: [
+    /* @__PURE__ */ jsx3("h2", { style: cardTitleStyle, children: "Use it as a Grist custom widget" }),
+    /* @__PURE__ */ jsx3("p", { style: { ...cardTextStyle, marginBottom: "1rem" }, children: "Paste this URL into a custom widget's URL field in Grist." }),
+    /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: "0.5rem" }, children: [
+      /* @__PURE__ */ jsx3(
+        "input",
+        {
+          readOnly: true,
+          value: url,
+          "aria-label": "Widget URL",
+          onFocus: (event) => event.target.select(),
+          style: {
+            flex: 1,
+            minWidth: 0,
+            padding: "0.5rem 0.75rem",
+            border: `1px solid ${tokens.border}`,
+            borderRadius: tokens.radius,
+            background: "transparent",
+            color: tokens.foreground,
+            font: "inherit",
+            fontSize: "0.875rem"
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx3(
+        "button",
+        {
+          type: "button",
+          onClick: copy,
+          style: {
+            padding: "0.5rem 1rem",
+            border: "none",
+            borderRadius: tokens.radius,
+            background: tokens.primary,
+            color: tokens.primaryForeground,
+            font: "inherit",
+            fontSize: "0.875rem",
+            fontWeight: 500,
+            cursor: "pointer"
+          },
+          children: copied ? "Copied" : "Copy"
+        }
+      )
+    ] })
+  ] });
+}
+function formatDate(iso) {
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? iso : date.toLocaleDateString(void 0, { year: "numeric", month: "short", day: "numeric" });
+}
+
+// src/sdk/helpers/grist-sdk-alerts.ts
+var TITLE = {
+  "column-mapping": "Column mapping",
+  "mapping-pending": "Column mapping",
+  "section-not-linked": "Widget linking",
+  "source-not-wired": "Widget linking",
+  "action-error": "Action error",
+  "access-insufficient": "Access level",
+  "map-back-skip": "Write skipped",
+  "cell-issues": "Unexpected values"
+};
+var SEVERITY = {
+  "column-mapping": "warning",
+  "mapping-pending": "info",
+  "section-not-linked": "warning",
+  "source-not-wired": "warning",
+  "action-error": "error",
+  "access-insufficient": "error",
+  "map-back-skip": "warning",
+  "cell-issues": "warning"
+};
+var alert = (kind, message, ariaRole = "status") => ({
+  id: kind,
+  kind,
+  severity: SEVERITY[kind],
+  title: TITLE[kind],
+  ariaRole,
+  message
+});
+function isWidgetSectionNotLinked(interaction) {
+  const linking = parseGristWidgetLinkingInfo(interaction?.linking);
+  return Boolean(linking) && linking.asTarget == null;
+}
+function getGristSdkAlerts(state, widget, options = {}) {
+  if (deriveStatus(state) !== "ready") return [];
+  const out = [];
+  const mapping = deriveColumnMappingStatus(widget.columns, state.mappings);
+  if (mapping.pending) out.push(alert("mapping-pending", "Waiting for Grist to report column mappings."));
+  else if (!mapping.ok) {
+    const parts = ["Column mapping is incomplete."];
+    if (mapping.missing.length) parts.push(`Required columns: ${mapping.missing.join(", ")}.`);
+    if (mapping.emptyMultiples.length) parts.push(`Assign at least one sheet column for: ${mapping.emptyMultiples.join(", ")}.`);
+    out.push(alert("column-mapping", parts.join(" ")));
+  }
+  const failure = state.actionError ?? state.readError;
+  if (failure && isAccessInsufficientError(failure)) {
+    out.push(
+      alert(
+        "access-insufficient",
+        'This operation requires "Full document access". Set the Access level to "Full document access" in the Custom widget configuration panel.',
+        "alert"
+      )
+    );
+  } else if (state.actionError) {
+    out.push(alert("action-error", state.actionError, "alert"));
+  }
+  if (state.mapBackSkipped.length) {
+    const list = state.mapBackSkipped.join(", ");
+    out.push(alert("map-back-skip", `mapBack skipped multi-mapped column${state.mapBackSkipped.length === 1 ? "" : "s"}: ${list}.`));
+  }
+  const cellIssues = widget.cellIssues ?? [];
+  if (cellIssues.length) {
+    const first = cellIssues[0];
+    const where = first.column ? `${first.column} in row ${first.rowId}` : `row ${first.rowId}`;
+    const more = cellIssues.length > 1 ? ` (and ${cellIssues.length - 1} more)` : "";
+    out.push(alert("cell-issues", `${where}: ${first.message}${more}. Check the column's type, or the cell, in Grist.`));
+  }
+  const linking = parseGristWidgetLinkingInfo(state.interaction?.linking);
+  if (widget.allowSelectBy) {
+    if (linking && !linking.asSource) {
+      out.push(
+        alert(
+          "source-not-wired",
+          "This widget is configured as a selector (allowSelectBy) but no other section is using it as a link source yet. Link another section to read from this widget."
+        )
+      );
+    }
+  } else if (isWidgetSectionNotLinked(state.interaction)) {
+    const hint = options.sectionNotLinkedHint?.trim();
+    out.push(
+      alert(
+        "section-not-linked",
+        "This widget section is not linked to a table or selector. Link it from the page settings so the selected row is sent to the widget." + (hint ? ` ${hint}` : "")
+      )
+    );
+  }
+  const suppressed = widget.suppressAlerts ?? [];
+  return out.filter((a) => !suppressed.includes(a.kind));
+}
+function useGristSdkAlerts(options) {
+  const { connection, state, cellIssues } = useNearestGristState();
+  if (!connection) return [];
+  const { columns, allowSelectBy, suppressAlerts } = connection.runtime.options;
+  return getGristSdkAlerts(state, { columns, allowSelectBy, suppressAlerts, cellIssues }, options);
+}
+
+// src/app/chrome/widget-alerts.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var ALERT_OPTIONS = {
+  sectionNotLinkedHint: "In Grist, select this widget section on the page, then use Link to connect a table, card, or chart view as the selector."
+};
+function WidgetAlerts({ children }) {
+  const alerts = useGristSdkAlerts(ALERT_OPTIONS);
+  if (alerts.length === 0) return /* @__PURE__ */ jsx4(Fragment, { children });
+  return /* @__PURE__ */ jsxs3("div", { style: { display: "flex", flexDirection: "column", gap: "0.75rem" }, children: [
+    /* @__PURE__ */ jsx4("div", { style: { display: "flex", flexDirection: "column", gap: "0.75rem", padding: "0.75rem 0.75rem 0" }, children: alerts.map((alert2) => /* @__PURE__ */ jsx4(WidgetAlert, { alert: alert2 }, alert2.id)) }),
+    children
+  ] });
+}
+function WidgetAlert({ alert: alert2 }) {
+  const linkIcon = alert2.kind === "section-not-linked" || alert2.kind === "source-not-wired";
+  return /* @__PURE__ */ jsxs3("div", { role: alert2.ariaRole, style: { ...alertStyle, ...SEVERITY2[alert2.severity] }, children: [
+    /* @__PURE__ */ jsx4("span", { "aria-hidden": true, style: { flexShrink: 0, marginTop: "0.125rem" }, children: linkIcon ? /* @__PURE__ */ jsx4(LinkIcon, {}) : /* @__PURE__ */ jsx4(WarningIcon, {}) }),
+    /* @__PURE__ */ jsxs3("div", { style: { minWidth: 0 }, children: [
+      /* @__PURE__ */ jsx4("p", { style: { margin: 0, fontWeight: 500 }, children: alert2.title }),
+      /* @__PURE__ */ jsx4("p", { style: { margin: "0.25rem 0 0", color: tokens.mutedForeground }, children: alert2.message })
+    ] })
+  ] });
+}
+var alertStyle = {
+  boxSizing: "border-box",
+  display: "flex",
+  gap: "0.75rem",
+  padding: "0.75rem 1rem",
+  border: `1px solid ${tokens.border}`,
+  borderRadius: tokens.radius,
+  color: tokens.foreground,
+  fontSize: "0.875rem",
+  lineHeight: 1.5
+};
+var SEVERITY2 = {
+  error: { borderColor: tokens.destructive, color: tokens.destructive },
+  warning: { borderColor: "rgb(245 158 11 / 0.4)", background: "rgb(245 158 11 / 0.1)" },
+  info: { background: "transparent" }
+};
+var ICON = {
+  width: 16,
+  height: 16,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+function WarningIcon() {
+  return /* @__PURE__ */ jsxs3("svg", { ...ICON, children: [
+    /* @__PURE__ */ jsx4("path", { d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 9v4" }),
+    /* @__PURE__ */ jsx4("path", { d: "M12 17h.01" })
+  ] });
+}
+function LinkIcon() {
+  return /* @__PURE__ */ jsxs3("svg", { ...ICON, children: [
+    /* @__PURE__ */ jsx4("path", { d: "M9 17H7A5 5 0 0 1 7 7h2" }),
+    /* @__PURE__ */ jsx4("path", { d: "M15 7h2a5 5 0 1 1 0 10h-2" }),
+    /* @__PURE__ */ jsx4("line", { x1: "8", x2: "16", y1: "12", y2: "12" })
+  ] });
+}
+
+// src/app/mount-grist-widget.tsx
+import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+function mountGristWidget(config) {
+  const { root = "#root", ...props } = config;
+  const container = typeof root === "string" ? document.querySelector(root) : root;
+  if (!container) {
+    throw new Error(`mountGristWidget: no element matches "${String(root)}" to render the widget into.`);
+  }
+  const reactRoot = createRoot(container);
+  reactRoot.render(
+    /* @__PURE__ */ jsx5(StrictMode, { children: /* @__PURE__ */ jsx5(GristWidgetApp, { ...props }) })
+  );
+  return { unmount: () => reactRoot.unmount() };
+}
+function GristWidgetApp({
+  App,
+  options,
+  dev = false,
+  Alerts = WidgetAlerts,
+  LocalDevPage: LocalDevPage2 = LocalDevPage,
+  ReleasePage: ReleasePage2 = ReleasePage
+}) {
+  const Wrap = Alerts ?? PassThrough;
+  if (isEmbedded()) {
+    return /* @__PURE__ */ jsx5(GristWidgetProvider, { options, children: /* @__PURE__ */ jsx5(EmbeddedThemeProvider, { children: /* @__PURE__ */ jsx5(GristBoundary, { children: /* @__PURE__ */ jsx5("div", { style: FILL, children: /* @__PURE__ */ jsx5(Wrap, { children: /* @__PURE__ */ jsx5(Suspense, { fallback: null, children: /* @__PURE__ */ jsx5(App, {}) }) }) }) }) }) });
+  }
+  const channel = parseDeployPath(window.location.pathname).channel;
+  return /* @__PURE__ */ jsx5(StandaloneThemeProvider, { children: /* @__PURE__ */ jsx5("div", { style: FILL, children: dev ? /* @__PURE__ */ jsx5(LocalDevPage2, {}) : /* @__PURE__ */ jsx5(ReleasePage2, { channel }) }) });
+}
+var FILL = { minHeight: "100%", width: "100%" };
+function isEmbedded() {
+  return typeof window !== "undefined" && window.self !== window.top;
+}
+function PassThrough({ children }) {
+  return /* @__PURE__ */ jsx5(Fragment2, { children });
+}
+
+export {
+  parseDeployPath,
+  deployChannelLabel,
+  useReleasedVersions,
+  useTheme,
+  mountGristWidget,
+  GristWidgetApp
+};
+//# sourceMappingURL=chunk-P6VTEKWO.js.map