@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-SC6RRD2D.js

@@ -0,0 +1,38 @@
+"use client";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+
+// src/app/lib/copy-link.ts
+async function writeClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    await navigator.clipboard.writeText(text);
+    return;
+  }
+  const area = document.createElement("textarea");
+  area.value = text;
+  area.setAttribute("readonly", "");
+  area.style.position = "fixed";
+  area.style.opacity = "0";
+  document.body.append(area);
+  area.select();
+  const copied = document.execCommand("copy");
+  area.remove();
+  if (!copied) throw new Error("The browser blocked copying.");
+}
+async function copyLink(url) {
+  try {
+    await writeClipboard(url);
+    toast.success("Link copied");
+  } catch (error) {
+    toast.error("Couldn't copy the link.", { description: userErrorText(error) });
+  }
+}
+
+export {
+  copyLink
+};
+//# sourceMappingURL=chunk-SC6RRD2D.js.map

package/dist/chunk-SC6RRD2D.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/app/lib/copy-link.ts"],"sourcesContent":["import { toast } from \"./toast\";\nimport { userErrorText } from \"../../ui/api-error\";\n\n/** Puts text on the clipboard, with a fallback for embeds without the async clipboard. */\nexport async function writeClipboard(text: string): Promise<void> {\n  if (typeof navigator !== \"undefined\" && navigator.clipboard?.writeText) {\n    await navigator.clipboard.writeText(text);\n    return;\n  }\n  // Older embeds without the async clipboard: a hidden textarea and execCommand.\n  const area = document.createElement(\"textarea\");\n  area.value = text;\n  area.setAttribute(\"readonly\", \"\");\n  area.style.position = \"fixed\";\n  area.style.opacity = \"0\";\n  document.body.append(area);\n  area.select();\n  const copied = document.execCommand(\"copy\");\n  area.remove();\n  if (!copied) throw new Error(\"The browser blocked copying.\");\n}\n\n/**\n * Copies an address and says so, the same way for chats and artifacts:\n * \"Link copied\", or why it couldn't be copied.\n */\nexport async function copyLink(url: string): Promise<void> {\n  try {\n    await writeClipboard(url);\n    toast.success(\"Link copied\");\n  } catch (error) {\n    toast.error(\"Couldn't copy the link.\", { description: userErrorText(error) });\n  }\n}\n"],"mappings":";;;;;;;;;AAIA,eAAsB,eAAe,MAA6B;AAChE,MAAI,OAAO,cAAc,eAAe,UAAU,WAAW,WAAW;AACtE,UAAM,UAAU,UAAU,UAAU,IAAI;AACxC;AAAA,EACF;AAEA,QAAM,OAAO,SAAS,cAAc,UAAU;AAC9C,OAAK,QAAQ;AACb,OAAK,aAAa,YAAY,EAAE;AAChC,OAAK,MAAM,WAAW;AACtB,OAAK,MAAM,UAAU;AACrB,WAAS,KAAK,OAAO,IAAI;AACzB,OAAK,OAAO;AACZ,QAAM,SAAS,SAAS,YAAY,MAAM;AAC1C,OAAK,OAAO;AACZ,MAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,8BAA8B;AAC7D;AAMA,eAAsB,SAAS,KAA4B;AACzD,MAAI;AACF,UAAM,eAAe,GAAG;AACxB,UAAM,QAAQ,aAAa;AAAA,EAC7B,SAAS,OAAO;AACd,UAAM,MAAM,2BAA2B,EAAE,aAAa,cAAc,KAAK,EAAE,CAAC;AAAA,EAC9E;AACF;","names":[]}

package/dist/chunk-SEO7TICN.js

@@ -0,0 +1,94 @@
+"use client";
+
+// src/app/lib/site-tool-consent.tsx
+import {
+  createContext,
+  lazy,
+  Suspense,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SiteToolConsentDialog = lazy(
+  () => import("./app/lib/site-tool-consent-dialog.js").then((module) => ({
+    default: module.SiteToolConsentDialog
+  }))
+);
+var SiteToolConnect = lazy(
+  () => import("./app/lib/site-tool-consent-dialog.js").then((module) => ({ default: module.SiteToolConnect }))
+);
+var MAX_PENDING = 8;
+var SiteToolConsentContext = createContext(null);
+function SiteToolConsentProvider({ children }) {
+  const [queue, setQueue] = useState([]);
+  const queued = useRef([]);
+  const nextId = useRef(0);
+  const settle = useCallback((item, value) => {
+    if (!queued.current.includes(item)) return;
+    queued.current = queued.current.filter((candidate) => candidate !== item);
+    setQueue(queued.current);
+    if (item.kind === "confirm") item.done(value);
+    else item.done(value);
+  }, []);
+  useEffect(
+    () => () => {
+      for (const item of queued.current) settle(item, item.kind === "confirm" ? null : false);
+    },
+    [settle]
+  );
+  const enqueue = useCallback(
+    (make, signal, cancelled) => new Promise((resolve) => {
+      if (signal.aborted || queued.current.length >= MAX_PENDING) return resolve(cancelled);
+      const item = make(resolve, nextId.current += 1);
+      signal.addEventListener("abort", () => settle(item, cancelled), { once: true });
+      queued.current = [...queued.current, item];
+      setQueue(queued.current);
+    }),
+    [settle]
+  );
+  const host = useMemo(
+    () => ({
+      confirmToolCall: (prompt) => enqueue(
+        (done, id) => ({ id, kind: "confirm", prompt, done }),
+        prompt.signal,
+        null
+      ),
+      connectForToolCall: (prompt) => enqueue(
+        (done, id) => ({ id, kind: "connect", prompt, done }),
+        prompt.signal,
+        false
+      )
+    }),
+    [enqueue]
+  );
+  const current = queue[0];
+  return /* @__PURE__ */ jsxs(SiteToolConsentContext.Provider, { value: host, children: [
+    children,
+    /* @__PURE__ */ jsx(Suspense, { fallback: null, children: current?.kind === "confirm" ? /* @__PURE__ */ jsx(
+      SiteToolConsentDialog,
+      {
+        prompt: current.prompt,
+        onDecision: (decision) => settle(current, decision)
+      },
+      current.id
+    ) : current?.kind === "connect" ? /* @__PURE__ */ jsx(
+      SiteToolConnect,
+      {
+        request: current.prompt,
+        onDone: (ok) => settle(current, ok)
+      },
+      current.id
+    ) : null })
+  ] });
+}
+var useSiteToolConsentHost = () => useContext(SiteToolConsentContext);
+
+export {
+  SiteToolConsentProvider,
+  useSiteToolConsentHost
+};
+//# sourceMappingURL=chunk-SEO7TICN.js.map

package/dist/chunk-SHHJCL7X.js

@@ -0,0 +1,432 @@
+"use client";
+import {
+  SubscriptionAccountMenu
+} from "./chunk-O4JOE3R7.js";
+import {
+  BillingClassMark
+} from "./chunk-GKVJIDHF.js";
+import {
+  Skeleton
+} from "./chunk-HJO32O7Z.js";
+import {
+  isCodexProductModel
+} from "./chunk-3PZ7JZI2.js";
+import {
+  useSessionModelAccount
+} from "./chunk-LWNBJHJM.js";
+import {
+  useCodexAccounts
+} from "./chunk-TWCYCCDA.js";
+import {
+  connectedSubscriptionProvider
+} from "./chunk-ZHC47M2B.js";
+
+// src/app/components/session/subscription-account-indicator.tsx
+import { useState } from "react";
+
+// src/app/components/session/subscription-account.ts
+import { isClaudeSubscriptionModelId } from "@opengeni/contracts/claude-subscription-model-ids";
+var PROVIDER = {
+  codex: { name: "Codex", billingClass: "codex_subscription" },
+  claude: { name: "Claude", billingClass: "claude_subscription" },
+  xai: { name: "SuperGrok", billingClass: "supergrok_subscription" }
+};
+function subscriptionProviderPresentation(provider) {
+  return PROVIDER[provider] ?? { name: "Subscription", billingClass: "external" };
+}
+var WINDOW_LABEL = {
+  // Neutral ids: they do not say how long the window is.
+  primary: "Primary",
+  secondary: "Secondary",
+  five_hour: "5h",
+  seven_day: "Week",
+  seven_day_opus: "Week \xB7 Opus",
+  seven_day_sonnet: "Week \xB7 Sonnet",
+  overage: "Overage",
+  billing: "Billing"
+};
+var REFUSAL_COPY = {
+  inactive: "Unavailable",
+  personal_not_allowed: "Turned off here",
+  personal_not_owner_work: "Not available for this chat",
+  session_has_no_owner: "Needs an owner"
+};
+var STATUS_COPY = {
+  needs_relogin: "Needs reconnect",
+  error: "Error",
+  disabled: "Disabled",
+  revoked: "Revoked",
+  expired: "Expired",
+  suspended: "Suspended",
+  paused: "Paused",
+  inactive: "Inactive",
+  limit_reached: "Limit reached"
+};
+function time(value) {
+  if (!value || !Number.isFinite(Date.parse(value))) return null;
+  return new Date(value).toLocaleString(void 0, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function accountLabel(account) {
+  return account.label ?? account.email ?? account.plan ?? "Account";
+}
+function accountStatus(account) {
+  if (account.refusal && account.refusal !== "inactive") return REFUSAL_COPY[account.refusal];
+  if (account.status !== "active") return STATUS_COPY[account.status] ?? account.status;
+  return account.refusal ? REFUSAL_COPY[account.refusal] : null;
+}
+function accountSource(account) {
+  return account.source === "personal" ? "Your account" : account.source === "workspace" ? "This workspace" : account.source === "organization" ? "Organization" : null;
+}
+function windowLabel(id) {
+  return WINDOW_LABEL[id] ?? id;
+}
+function subscriptionAccountUsage(usage, now = Date.now()) {
+  if (!usage) return { message: "No usage reading yet" };
+  const observed = time(usage.observedAt);
+  const windows = usage.windows.map((window) => {
+    const reset = time(window.resetsAt);
+    const past = reset !== null && Date.parse(window.resetsAt) <= now;
+    return {
+      label: windowLabel(window.id),
+      usedPercent: window.usedPercent,
+      detail: [
+        window.status === "unknown" ? "Status unknown" : window.status === "warning" ? "Near its limit" : window.status === "exhausted" ? "Limit reached" : null,
+        past ? "Reset passed; usage may be outdated" : reset ? `Resets ${reset}` : null
+      ].filter(Boolean).join(" \xB7 ")
+    };
+  });
+  const exhaustedTime = time(usage.exhaustedUntil);
+  const exhausted = usage.exhaustedKind !== null && !(usage.exhaustedUntil && Date.parse(usage.exhaustedUntil) <= now);
+  return {
+    windows,
+    ...windows.length === 0 ? {
+      message: exhausted ? `Limit reached${exhaustedTime ? ` until ${exhaustedTime}` : ""}` : "No usage reading yet"
+    } : {},
+    ...observed ? { note: `Updated ${observed}` } : {},
+    ...windows.length > 0 ? {
+      summary: `${windows.map(
+        (window) => `${window.label} ${window.usedPercent === null ? "unknown" : `${Math.round(window.usedPercent)}%`}`
+      ).join(" \xB7 ")} used`
+    } : {}
+  };
+}
+function nearLimit(usage) {
+  return (usage?.windows ?? []).some(
+    (window) => window.status === "warning" || window.status === "exhausted" || window.usedPercent !== null && window.usedPercent >= 90
+  );
+}
+function tightestWindow(windows) {
+  let tightest;
+  for (const window of windows ?? []) {
+    if (window.usedPercent === null || !Number.isFinite(window.usedPercent)) continue;
+    if (!tightest || window.usedPercent > tightest.usedPercent) {
+      tightest = { label: window.label, usedPercent: window.usedPercent };
+    }
+  }
+  return tightest;
+}
+function showsSubscriptionAccountMenu(state) {
+  return state.unavailable || state.accounts.length > 0 || state.current !== null || state.currentHidden || state.waiting || !state.automatic;
+}
+function subscriptionAccountProvider(modelId, model) {
+  if (isCodexProductModel(modelId)) return "codex";
+  if (isClaudeSubscriptionModelId(modelId)) return "claude";
+  return model ? connectedSubscriptionProvider(model) : null;
+}
+function subscriptionAccountMenuContent(state) {
+  const { name } = subscriptionProviderPresentation(state.provider);
+  const current = state.current;
+  const unknown = state.unavailable && !current && !state.currentHidden;
+  const displayName = current ? accountLabel(current) : state.currentHidden ? "Account unavailable" : unknown ? "Accounts unavailable" : "Automatic";
+  const status = current ? accountStatus(current) : null;
+  const selectionLabel = state.waiting ? "Limit reached" : state.serving && (current || state.currentHidden) ? "Current account" : !state.automatic && !unknown && (!current || current.id === state.chosenId) ? "Chosen account" : current ? "Current account" : "Account selection";
+  const usageNearLimit = nearLimit(current?.usage);
+  const tone = current?.status === "needs_relogin" || current?.status === "error" ? "bad" : status || state.waiting || usageNearLimit ? "warn" : "ok";
+  const usage = !current ? {
+    message: state.currentHidden ? "Account usage hidden" : unknown ? "Usage unavailable" : "Choose an account to see usage"
+  } : state.usageCheck === "checking" ? { checking: true } : state.usageCheck === "failed" ? { unavailable: true } : subscriptionAccountUsage(current.usage);
+  const accounts = state.accounts.map((account) => {
+    const rowUsage = account.id === current?.id || state.usageCheck === "checking" ? void 0 : subscriptionAccountUsage(account.usage);
+    return {
+      id: account.id,
+      label: accountLabel(account),
+      plan: account.plan,
+      status: accountStatus(account),
+      detail: [
+        accountLabel(account),
+        account.email,
+        account.plan,
+        accountSource(account),
+        accountStatus(account)
+      ].filter(Boolean).join(" \xB7 "),
+      personal: account.source === "personal",
+      disabled: !account.choosable,
+      usageSummary: rowUsage?.summary,
+      usageBar: rowUsage?.summary ? tightestWindow(rowUsage.windows) : void 0
+    };
+  });
+  return {
+    ariaLabel: [
+      `${name} account`,
+      displayName,
+      state.waiting ? "Limit reached" : status ?? (usageNearLimit ? "Near its limit" : null)
+    ].filter(Boolean).join(" \xB7 "),
+    selectionLabel,
+    displayName,
+    identity: current?.email && current.email !== displayName ? current.email : null,
+    metadata: current ? [current.plan, accountSource(current), status].filter(Boolean).join(" \xB7 ") || `${name} subscription` : `${name} subscription`,
+    tone,
+    usage,
+    accounts,
+    selectedId: state.automatic || unknown ? null : state.chosenId,
+    automaticSelected: state.automatic && !unknown,
+    actionLabel: state.waiting ? "Retry with" : "Use for next turn",
+    automaticLabel: "Automatic",
+    emptyMessage: state.unavailable ? "Accounts unavailable." : "No accounts available.",
+    error: state.mutationError ? `Couldn't switch: ${state.mutationError}` : null,
+    note: state.appliedTo === "waiting_turn" ? "Selection saved. Capacity is being rechecked." : state.appliedTo === "next_turn" ? "Selection saved for the next turn." : state.waiting ? "Changing accounts retries the waiting turn." : "Applies next turn. The current turn keeps its account."
+  };
+}
+
+// src/app/components/session/subscription-account-indicator.tsx
+import { jsx } from "react/jsx-runtime";
+function SubscriptionAccountIndicator(props) {
+  return props.provider === "codex" ? /* @__PURE__ */ jsx(CodexAccountSource, { ...props }) : /* @__PURE__ */ jsx(SharedAccountSource, { ...props });
+}
+function SubscriptionAccountControl({
+  state,
+  onChoose,
+  onOpenChange
+}) {
+  const { name, billingClass } = subscriptionProviderPresentation(state.provider);
+  if (state.loading) {
+    return /* @__PURE__ */ jsx(
+      Skeleton,
+      {
+        role: "status",
+        className: "h-6 w-11 shrink-0 rounded-full",
+        "aria-label": `Loading ${name} account`
+      }
+    );
+  }
+  if (!showsSubscriptionAccountMenu(state)) {
+    return /* @__PURE__ */ jsx(
+      BillingClassMark,
+      {
+        billingClass,
+        className: "size-3.5 shrink-0 text-fg-muted",
+        "aria-label": ""
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    SubscriptionAccountMenu,
+    {
+      ...subscriptionAccountMenuContent(state),
+      triggerMark: /* @__PURE__ */ jsx(
+        BillingClassMark,
+        {
+          billingClass,
+          className: "size-3.5 text-current",
+          "aria-label": ""
+        }
+      ),
+      headerMark: /* @__PURE__ */ jsx(BillingClassMark, { billingClass, className: "size-4 text-current" }),
+      choosing: state.choosing,
+      choosingTarget: state.choosingTarget,
+      onChoose,
+      onOpenChange
+    }
+  );
+}
+function sharedAccount(option) {
+  return {
+    id: option.connectionId,
+    label: option.label,
+    email: option.accountEmail,
+    plan: option.planType,
+    source: option.personal ? "personal" : option.source,
+    status: option.status,
+    refusal: option.refusal,
+    choosable: option.choosable,
+    usage: option.usage
+  };
+}
+function sharedAccountState(provider, account, servingTurnId) {
+  const choice = account.choice;
+  const options = (choice?.accounts ?? []).filter((each) => each.provider === provider);
+  const binding = choice?.bindings?.find((each) => each.provider === provider) ?? (choice?.binding?.provider === provider ? choice.binding : null);
+  const explicit = binding?.choice === "explicit";
+  const serving = choice?.serving && choice.serving.turnId === servingTurnId && choice.serving.provider === provider ? choice.serving : null;
+  const currentId = serving ? serving.connectionId : binding?.connectionId;
+  const current = currentId ? options.find((each) => each.connectionId === currentId) ?? null : null;
+  return {
+    provider,
+    loading: account.loading && !choice,
+    unavailable: !choice,
+    accounts: options.map(sharedAccount),
+    current: current ? sharedAccount(current) : null,
+    currentHidden: !current && (explicit || serving !== null),
+    serving: serving !== null,
+    automatic: !explicit,
+    chosenId: explicit ? binding?.connectionId ?? null : null,
+    waiting: false,
+    // Only the authorized stored reading; opening the menu never probes a provider.
+    usageCheck: "idle",
+    choosing: account.choosing,
+    choosingTarget: account.choosingTarget,
+    appliedTo: account.appliedTo,
+    mutationError: account.mutationError?.message ?? null
+  };
+}
+function SharedAccountSource(props) {
+  const { provider } = props;
+  const account = useSessionModelAccount({
+    workspaceId: props.workspaceId,
+    sessionId: props.sessionId,
+    provider,
+    organizationId: props.organizationId,
+    pollIntervalMs: 6e4,
+    ...props.events !== void 0 ? { events: props.events } : {}
+  });
+  const state = sharedAccountState(provider, account, props.servingTurnId);
+  return /* @__PURE__ */ jsx(
+    SubscriptionAccountControl,
+    {
+      state,
+      onChoose: (id) => {
+        if (!state.unavailable && (id === null ? state.automatic : !state.automatic && state.chosenId === id)) {
+          return;
+        }
+        void account.choose(id);
+      }
+    }
+  );
+}
+var AUTO = "auto";
+var LIVE_USAGE_REUSE_MS = 3e4;
+function codexUsage(account, live, now = Date.now()) {
+  const window = (id, reading) => {
+    if (!reading) return [];
+    const usedPercent = typeof reading.percent === "number" ? reading.percent : typeof reading.remaining === "number" ? 100 - reading.remaining : null;
+    return [
+      {
+        id,
+        usedPercent,
+        resetsAt: reading.resetAt ?? null,
+        status: usedPercent === null ? "unknown" : usedPercent >= 100 ? "exhausted" : usedPercent >= 90 ? "warning" : "ok"
+      }
+    ];
+  };
+  const windows = [
+    ...window("five_hour", account.fiveHour),
+    ...window("seven_day", account.weekly)
+  ];
+  const exhaustedUntil = account.exhaustedUntil && Date.parse(account.exhaustedUntil) > now ? account.exhaustedUntil : null;
+  if (windows.length === 0 && !exhaustedUntil) return null;
+  return {
+    observedAt: live?.usage?.fetchedAt ?? account.usageCheckedAt ?? null,
+    windows,
+    exhaustedUntil,
+    exhaustedKind: exhaustedUntil ? "quota" : null
+  };
+}
+function codexAccountState(codex, check) {
+  const awaitingFirstUsage = check.checking && codex.liveUsageUpdatedAt === null;
+  const selection = codex.currentSelection;
+  const effective = (selection ? codex.currentAccount : null) ?? codex.accounts.find(
+    (account2) => account2.id === (selection ? selection.credentialId : codex.pinnedAccountId)
+  ) ?? null;
+  const liveMissing = (id) => {
+    const status = codex.liveUsage[id]?.status;
+    return check.failed || check.checked && !status || status === "error" || status === "no-data";
+  };
+  const account = (each) => ({
+    id: each.id,
+    // The ChatGPT account id names an account only when nothing else does.
+    label: each.label ?? (each.email || each.plan ? null : each.chatgptAccountId ?? null),
+    email: each.email ?? null,
+    plan: each.plan ?? null,
+    source: each.source ?? null,
+    status: each.status,
+    refusal: null,
+    choosable: true,
+    usage: liveMissing(each.id) ? null : codexUsage(each, codex.liveUsage[each.id])
+  });
+  return {
+    provider: "codex",
+    loading: codex.loading && !effective,
+    unavailable: Boolean(codex.error),
+    accounts: codex.accounts.map(account),
+    current: effective ? account(effective) : null,
+    currentHidden: !effective && Boolean(selection?.credentialId ?? codex.pinnedAccountId),
+    serving: selection !== null,
+    automatic: codex.pinnedAccountId === null,
+    chosenId: codex.pinnedAccountId,
+    waiting: selection?.waiting === true,
+    usageCheck: awaitingFirstUsage ? "checking" : effective && liveMissing(effective.id) ? "failed" : "idle",
+    choosing: codex.pinning,
+    choosingTarget: codex.pinningTarget === AUTO ? null : codex.pinningTarget ?? void 0,
+    appliedTo: codex.switchAppliedTo,
+    mutationError: codex.mutationError?.message ?? null
+  };
+}
+function CodexAccountSource(props) {
+  const codex = useCodexAccounts({
+    sessionId: props.sessionId,
+    pollIntervalMs: 3e4,
+    ...props.events !== void 0 ? { events: props.events } : {}
+  });
+  const [checkingUsage, setCheckingUsage] = useState(false);
+  const [usageChecked, setUsageChecked] = useState(false);
+  const [usageCheckFailed, setUsageCheckFailed] = useState(false);
+  const state = codexAccountState(codex, {
+    checking: checkingUsage,
+    checked: usageChecked,
+    failed: usageCheckFailed
+  });
+  const waiting = state.waiting;
+  return /* @__PURE__ */ jsx(
+    SubscriptionAccountControl,
+    {
+      state,
+      onChoose: (id) => {
+        if (codex.pinnedAccountId === id && !waiting && !state.unavailable) return;
+        void codex.pin(id ?? AUTO);
+      },
+      onOpenChange: (open) => {
+        if (!open) return;
+        setCheckingUsage(true);
+        setUsageChecked(false);
+        setUsageCheckFailed(false);
+        void codex.refreshUsage({ maxAgeMs: LIVE_USAGE_REUSE_MS }).then(
+          (ok) => {
+            setUsageChecked(ok);
+            setUsageCheckFailed(!ok);
+            setCheckingUsage(false);
+          },
+          () => {
+            setUsageCheckFailed(true);
+            setCheckingUsage(false);
+          }
+        );
+      }
+    }
+  );
+}
+
+export {
+  subscriptionAccountProvider,
+  SubscriptionAccountIndicator,
+  SubscriptionAccountControl,
+  sharedAccount,
+  sharedAccountState,
+  codexUsage,
+  codexAccountState
+};
+//# sourceMappingURL=chunk-SHHJCL7X.js.map

package/dist/chunk-SIRLACNZ.js

@@ -0,0 +1,114 @@
+"use client";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle
+} from "./chunk-ZQCND77P.js";
+import {
+  Button
+} from "./chunk-7QQN3KNP.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/ui/confirm-dialog.tsx
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function destructiveActionFocusTarget(trigger, fallback) {
+  if (focusTargetAvailable(trigger)) return trigger;
+  return focusTargetAvailable(fallback) ? fallback : null;
+}
+function focusTargetAvailable(target) {
+  return Boolean(
+    target?.isConnected && !target.matches(":disabled, [aria-disabled='true'], [inert]") && !target.closest("[inert]")
+  );
+}
+function ConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  children,
+  confirmLabel,
+  confirmDisabled = false,
+  pendingLabel,
+  cancelLabel,
+  cancelAutoFocus = false,
+  destructive = true,
+  restoreFocusRef,
+  restoreFocusFallbackRef,
+  onConfirm
+}) {
+  const msg = useOpenGeniText();
+  const [pending, setPending] = useState(false);
+  const confirm = async () => {
+    if (pending || confirmDisabled) return;
+    setPending(true);
+    try {
+      const result = await onConfirm();
+      if (result !== false) {
+        onOpenChange(false);
+      }
+    } catch {
+    } finally {
+      setPending(false);
+    }
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open, onOpenChange: (next) => pending ? void 0 : onOpenChange(next), children: /* @__PURE__ */ jsxs(
+    DialogContent,
+    {
+      showCloseButton: false,
+      className: "sm:max-w-md",
+      onCloseAutoFocus: (event) => {
+        const destination = destructiveActionFocusTarget(
+          restoreFocusRef?.current ?? null,
+          restoreFocusFallbackRef?.current ?? null
+        );
+        if (!destination) return;
+        event.preventDefault();
+        destination.focus();
+      },
+      children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsx(DialogTitle, { className: "text-base", children: title }),
+          description ? /* @__PURE__ */ jsx(DialogDescription, { children: description }) : null
+        ] }),
+        children,
+        /* @__PURE__ */ jsxs(DialogFooter, { children: [
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: "ghost",
+              autoFocus: cancelAutoFocus,
+              className: "min-h-11",
+              disabled: pending,
+              onClick: () => onOpenChange(false),
+              children: cancelLabel ?? msg("formDialog.cancel")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              type: "button",
+              variant: destructive ? "destructive" : "default",
+              className: "min-h-11",
+              disabled: pending || confirmDisabled,
+              onClick: () => void confirm(),
+              children: pending ? pendingLabel ?? msg("formDialog.working") : confirmLabel
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+
+export {
+  destructiveActionFocusTarget,
+  ConfirmDialog
+};
+//# sourceMappingURL=chunk-SIRLACNZ.js.map