@xortex/xcode 3.0.5 → 3.1.0

package/context/QueuedMessageContext.tsx

@@ -0,0 +1,63 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box } from '../ink.js';
+type QueuedMessageContextValue = {
+  isQueued: boolean;
+  isFirst: boolean;
+  /** Width reduction for container padding (e.g., 4 for paddingX={2}) */
+  paddingWidth: number;
+};
+const QueuedMessageContext = React.createContext<QueuedMessageContextValue | undefined>(undefined);
+export function useQueuedMessage() {
+  return React.useContext(QueuedMessageContext);
+}
+const PADDING_X = 2;
+type Props = {
+  isFirst: boolean;
+  useBriefLayout?: boolean;
+  children: React.ReactNode;
+};
+export function QueuedMessageProvider(t0) {
+  const $ = _c(9);
+  const {
+    isFirst,
+    useBriefLayout,
+    children
+  } = t0;
+  const padding = useBriefLayout ? 0 : PADDING_X;
+  const t1 = padding * 2;
+  let t2;
+  if ($[0] !== isFirst || $[1] !== t1) {
+    t2 = {
+      isQueued: true,
+      isFirst,
+      paddingWidth: t1
+    };
+    $[0] = isFirst;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const value = t2;
+  let t3;
+  if ($[3] !== children || $[4] !== padding) {
+    t3 = <Box paddingX={padding}>{children}</Box>;
+    $[3] = children;
+    $[4] = padding;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== t3 || $[7] !== value) {
+    t4 = <QueuedMessageContext.Provider value={value}>{t3}</QueuedMessageContext.Provider>;
+    $[6] = t3;
+    $[7] = value;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  return t4;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/context/fpsMetrics.tsx

@@ -0,0 +1,30 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext } from 'react';
+import type { FpsMetrics } from '../utils/fpsTracker.js';
+type FpsMetricsGetter = () => FpsMetrics | undefined;
+const FpsMetricsContext = createContext<FpsMetricsGetter | undefined>(undefined);
+type Props = {
+  getFpsMetrics: FpsMetricsGetter;
+  children: React.ReactNode;
+};
+export function FpsMetricsProvider(t0) {
+  const $ = _c(3);
+  const {
+    getFpsMetrics,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== children || $[1] !== getFpsMetrics) {
+    t1 = <FpsMetricsContext.Provider value={getFpsMetrics}>{children}</FpsMetricsContext.Provider>;
+    $[0] = children;
+    $[1] = getFpsMetrics;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  return t1;
+}
+export function useFpsMetrics() {
+  return useContext(FpsMetricsContext);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/context/mailbox.tsx

@@ -0,0 +1,38 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, useContext, useMemo } from 'react';
+import { Mailbox } from '../utils/mailbox.js';
+const MailboxContext = createContext<Mailbox | undefined>(undefined);
+type Props = {
+  children: React.ReactNode;
+};
+export function MailboxProvider(t0) {
+  const $ = _c(3);
+  const {
+    children
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = new Mailbox();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const mailbox = t1;
+  let t2;
+  if ($[1] !== children) {
+    t2 = <MailboxContext.Provider value={mailbox}>{children}</MailboxContext.Provider>;
+    $[1] = children;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+}
+export function useMailbox() {
+  const mailbox = useContext(MailboxContext);
+  if (!mailbox) {
+    throw new Error("useMailbox must be used within a MailboxProvider");
+  }
+  return mailbox;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/context/modalContext.tsx

@@ -0,0 +1,58 @@
+import { c as _c } from "react/compiler-runtime";
+import { createContext, type RefObject, useContext } from 'react';
+import type { ScrollBoxHandle } from '../ink/components/ScrollBox.js';
+
+/**
+ * Set by FullscreenLayout when rendering content in its `modal` slot —
+ * the absolute-positioned bottom-anchored pane for slash-command dialogs.
+ * Consumers use this to:
+ *
+ * - Suppress top-level framing — `Pane` skips its full-terminal-width
+ *   `Divider` (FullscreenLayout already draws the ▔ divider).
+ * - Size Select pagination to the available rows — the modal's inner
+ *   area is smaller than the terminal (rows minus transcript peek minus
+ *   divider), so components that cap their visible option count from
+ *   `useTerminalSize().rows` would overflow without this context.
+ * - Reset scroll on tab switch — Tabs keys its ScrollBox by
+ *   `selectedTabIndex`, remounting on tab switch so scrollTop resets to 0
+ *   without scrollTo() timing games.
+ *
+ * null = not inside the modal slot.
+ */
+type ModalCtx = {
+  rows: number;
+  columns: number;
+  scrollRef: RefObject<ScrollBoxHandle | null> | null;
+};
+export const ModalContext = createContext<ModalCtx | null>(null);
+export function useIsInsideModal() {
+  return useContext(ModalContext) !== null;
+}
+
+/**
+ * Available content rows/columns when inside a Modal, else falls back to
+ * the provided terminal size. Use instead of `useTerminalSize()` when a
+ * component caps its visible content height — the modal's inner area is
+ * smaller than the terminal.
+ */
+export function useModalOrTerminalSize(fallback) {
+  const $ = _c(3);
+  const ctx = useContext(ModalContext);
+  let t0;
+  if ($[0] !== ctx || $[1] !== fallback) {
+    t0 = ctx ? {
+      rows: ctx.rows,
+      columns: ctx.columns
+    } : fallback;
+    $[0] = ctx;
+    $[1] = fallback;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+export function useModalScrollRef() {
+  return useContext(ModalContext)?.scrollRef ?? null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjcmVhdGVDb250ZXh0IiwiUmVmT2JqZWN0IiwidXNlQ29udGV4dCIsIlNjcm9sbEJveEhhbmRsZSIsIk1vZGFsQ3R4Iiwicm93cyIsImNvbHVtbnMiLCJzY3JvbGxSZWYiLCJNb2RhbENvbnRleHQiLCJ1c2VJc0luc2lkZU1vZGFsIiwidXNlTW9kYWxPclRlcm1pbmFsU2l6ZSIsImZhbGxiYWNrIiwiJCIsIl9jIiwiY3R4IiwidDAiLCJ1c2VNb2RhbFNjcm9sbFJlZiJdLCJzb3VyY2VzIjpbIm1vZGFsQ29udGV4dC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlQ29udGV4dCwgdHlwZSBSZWZPYmplY3QsIHVzZUNvbnRleHQgfSBmcm9tICdyZWFjdCdcbmltcG9ydCB0eXBlIHsgU2Nyb2xsQm94SGFuZGxlIH0gZnJvbSAnLi4vaW5rL2NvbXBvbmVudHMvU2Nyb2xsQm94LmpzJ1xuXG4vKipcbiAqIFNldCBieSBGdWxsc2NyZWVuTGF5b3V0IHdoZW4gcmVuZGVyaW5nIGNvbnRlbnQgaW4gaXRzIGBtb2RhbGAgc2xvdCDigJRcbiAqIHRoZSBhYnNvbHV0ZS1wb3NpdGlvbmVkIGJvdHRvbS1hbmNob3JlZCBwYW5lIGZvciBzbGFzaC1jb21tYW5kIGRpYWxvZ3MuXG4gKiBDb25zdW1lcnMgdXNlIHRoaXMgdG86XG4gKlxuICogLSBTdXBwcmVzcyB0b3AtbGV2ZWwgZnJhbWluZyDigJQgYFBhbmVgIHNraXBzIGl0cyBmdWxsLXRlcm1pbmFsLXdpZHRoXG4gKiAgIGBEaXZpZGVyYCAoRnVsbHNjcmVlbkxheW91dCBhbHJlYWR5IGRyYXdzIHRoZSDilpQgZGl2aWRlcikuXG4gKiAtIFNpemUgU2VsZWN0IHBhZ2luYXRpb24gdG8gdGhlIGF2YWlsYWJsZSByb3dzIOKAlCB0aGUgbW9kYWwncyBpbm5lclxuICogICBhcmVhIGlzIHNtYWxsZXIgdGhhbiB0aGUgdGVybWluYWwgKHJvd3MgbWludXMgdHJhbnNjcmlwdCBwZWVrIG1pbnVzXG4gKiAgIGRpdmlkZXIpLCBzbyBjb21wb25lbnRzIHRoYXQgY2FwIHRoZWlyIHZpc2libGUgb3B0aW9uIGNvdW50IGZyb21cbiAqICAgYHVzZVRlcm1pbmFsU2l6ZSgpLnJvd3NgIHdvdWxkIG92ZXJmbG93IHdpdGhvdXQgdGhpcyBjb250ZXh0LlxuICogLSBSZXNldCBzY3JvbGwgb24gdGFiIHN3aXRjaCDigJQgVGFicyBrZXlzIGl0cyBTY3JvbGxCb3ggYnlcbiAqICAgYHNlbGVjdGVkVGFiSW5kZXhgLCByZW1vdW50aW5nIG9uIHRhYiBzd2l0Y2ggc28gc2Nyb2xsVG9wIHJlc2V0cyB0byAwXG4gKiAgIHdpdGhvdXQgc2Nyb2xsVG8oKSB0aW1pbmcgZ2FtZXMuXG4gKlxuICogbnVsbCA9IG5vdCBpbnNpZGUgdGhlIG1vZGFsIHNsb3QuXG4gKi9cbnR5cGUgTW9kYWxDdHggPSB7XG4gIHJvd3M6IG51bWJlclxuICBjb2x1bW5zOiBudW1iZXJcbiAgc2Nyb2xsUmVmOiBSZWZPYmplY3Q8U2Nyb2xsQm94SGFuZGxlIHwgbnVsbD4gfCBudWxsXG59XG5leHBvcnQgY29uc3QgTW9kYWxDb250ZXh0ID0gY3JlYXRlQ29udGV4dDxNb2RhbEN0eCB8IG51bGw+KG51bGwpXG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VJc0luc2lkZU1vZGFsKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gdXNlQ29udGV4dChNb2RhbENvbnRleHQpICE9PSBudWxsXG59XG5cbi8qKlxuICogQXZhaWxhYmxlIGNvbnRlbnQgcm93cy9jb2x1bW5zIHdoZW4gaW5zaWRlIGEgTW9kYWwsIGVsc2UgZmFsbHMgYmFjayB0b1xuICogdGhlIHByb3ZpZGVkIHRlcm1pbmFsIHNpemUuIFVzZSBpbnN0ZWFkIG9mIGB1c2VUZXJtaW5hbFNpemUoKWAgd2hlbiBhXG4gKiBjb21wb25lbnQgY2FwcyBpdHMgdmlzaWJsZSBjb250ZW50IGhlaWdodCDigJQgdGhlIG1vZGFsJ3MgaW5uZXIgYXJlYSBpc1xuICogc21hbGxlciB0aGFuIHRoZSB0ZXJtaW5hbC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHVzZU1vZGFsT3JUZXJtaW5hbFNpemUoZmFsbGJhY2s6IHtcbiAgcm93czogbnVtYmVyXG4gIGNvbHVtbnM6IG51bWJlclxufSk6IHsgcm93czogbnVtYmVyOyBjb2x1bW5zOiBudW1iZXIgfSB7XG4gIGNvbnN0IGN0eCA9IHVzZUNvbnRleHQoTW9kYWxDb250ZXh0KVxuICByZXR1cm4gY3R4ID8geyByb3dzOiBjdHgucm93cywgY29sdW1uczogY3R4LmNvbHVtbnMgfSA6IGZhbGxiYWNrXG59XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VNb2RhbFNjcm9sbFJlZigpOiBSZWZPYmplY3Q8U2Nyb2xsQm94SGFuZGxlIHwgbnVsbD4gfCBudWxsIHtcbiAgcmV0dXJuIHVzZUNvbnRleHQoTW9kYWxDb250ZXh0KT8uc2Nyb2xsUmVmID8/IG51bGxcbn1cbiJdLCJtYXBwaW5ncyI6IjtBQUFBLFNBQVNBLGFBQWEsRUFBRSxLQUFLQyxTQUFTLEVBQUVDLFVBQVUsUUFBUSxPQUFPO0FBQ2pFLGNBQWNDLGVBQWUsUUFBUSxnQ0FBZ0M7O0FBRXJFO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQSxLQUFLQyxRQUFRLEdBQUc7RUFDZEMsSUFBSSxFQUFFLE1BQU07RUFDWkMsT0FBTyxFQUFFLE1BQU07RUFDZkMsU0FBUyxFQUFFTixTQUFTLENBQUNFLGVBQWUsR0FBRyxJQUFJLENBQUMsR0FBRyxJQUFJO0FBQ3JELENBQUM7QUFDRCxPQUFPLE1BQU1LLFlBQVksR0FBR1IsYUFBYSxDQUFDSSxRQUFRLEdBQUcsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDO0FBRWhFLE9BQU8sU0FBQUssaUJBQUE7RUFBQSxPQUNFUCxVQUFVLENBQUNNLFlBQVksQ0FBQyxLQUFLLElBQUk7QUFBQTs7QUFHMUM7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxTQUFBRSx1QkFBQUMsUUFBQTtFQUFBLE1BQUFDLENBQUEsR0FBQUMsRUFBQTtFQUlMLE1BQUFDLEdBQUEsR0FBWVosVUFBVSxDQUFDTSxZQUFZLENBQUM7RUFBQSxJQUFBTyxFQUFBO0VBQUEsSUFBQUgsQ0FBQSxRQUFBRSxHQUFBLElBQUFGLENBQUEsUUFBQUQsUUFBQTtJQUM3QkksRUFBQSxHQUFBRCxHQUFHLEdBQUg7TUFBQVQsSUFBQSxFQUFjUyxHQUFHLENBQUFULElBQUs7TUFBQUMsT0FBQSxFQUFXUSxHQUFHLENBQUFSO0lBQW9CLENBQUMsR0FBekRLLFFBQXlEO0lBQUFDLENBQUEsTUFBQUUsR0FBQTtJQUFBRixDQUFBLE1BQUFELFFBQUE7SUFBQUMsQ0FBQSxNQUFBRyxFQUFBO0VBQUE7SUFBQUEsRUFBQSxHQUFBSCxDQUFBO0VBQUE7RUFBQSxPQUF6REcsRUFBeUQ7QUFBQTtBQUdsRSxPQUFPLFNBQUFDLGtCQUFBO0VBQUEsT0FDRWQsVUFBVSxDQUFDTSxZQUF1QixDQUFDLEVBQUFELFNBQVEsSUFBM0MsSUFBMkM7QUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/context/notifications.tsx

@@ -0,0 +1,240 @@
+import type * as React from 'react';
+import { useCallback, useEffect } from 'react';
+import { useAppStateStore, useSetAppState } from 'src/state/AppState.js';
+import type { Theme } from '../utils/theme.js';
+type Priority = 'low' | 'medium' | 'high' | 'immediate';
+type BaseNotification = {
+  key: string;
+  /**
+   * Keys of notifications that this notification invalidates.
+   * If a notification is invalidated, it will be removed from the queue
+   * and, if currently displayed, cleared immediately.
+   */
+  invalidates?: string[];
+  priority: Priority;
+  timeoutMs?: number;
+  /**
+   * Combine notifications with the same key, like Array.reduce().
+   * Called as fold(accumulator, incoming) when a notification with a matching
+   * key already exists in the queue or is currently displayed.
+   * Returns the merged notification (should carry fold forward for future merges).
+   */
+  fold?: (accumulator: Notification, incoming: Notification) => Notification;
+};
+type TextNotification = BaseNotification & {
+  text: string;
+  color?: keyof Theme;
+};
+type JSXNotification = BaseNotification & {
+  jsx: React.ReactNode;
+};
+type AddNotificationFn = (content: Notification) => void;
+type RemoveNotificationFn = (key: string) => void;
+export type Notification = TextNotification | JSXNotification;
+const DEFAULT_TIMEOUT_MS = 8000;
+
+// Track current timeout to clear it when immediate notifications arrive
+let currentTimeoutId: NodeJS.Timeout | null = null;
+export function useNotifications(): {
+  addNotification: AddNotificationFn;
+  removeNotification: RemoveNotificationFn;
+} {
+  const store = useAppStateStore();
+  const setAppState = useSetAppState();
+
+  // Process queue when current notification finishes or queue changes
+  const processQueue = useCallback(() => {
+    setAppState(prev => {
+      const next = getNext(prev.notifications.queue);
+      if (prev.notifications.current !== null || !next) {
+        return prev;
+      }
+      currentTimeoutId = setTimeout((setAppState, nextKey, processQueue) => {
+        currentTimeoutId = null;
+        setAppState(prev => {
+          // Compare by key instead of reference to handle re-created notifications
+          if (prev.notifications.current?.key !== nextKey) {
+            return prev;
+          }
+          return {
+            ...prev,
+            notifications: {
+              queue: prev.notifications.queue,
+              current: null
+            }
+          };
+        });
+        processQueue();
+      }, next.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, next.key, processQueue);
+      return {
+        ...prev,
+        notifications: {
+          queue: prev.notifications.queue.filter(_ => _ !== next),
+          current: next
+        }
+      };
+    });
+  }, [setAppState]);
+  const addNotification = useCallback<AddNotificationFn>((notif: Notification) => {
+    // Handle immediate priority notifications
+    if (notif.priority === 'immediate') {
+      // Clear any existing timeout since we're showing a new immediate notification
+      if (currentTimeoutId) {
+        clearTimeout(currentTimeoutId);
+        currentTimeoutId = null;
+      }
+
+      // Set up timeout for the immediate notification
+      currentTimeoutId = setTimeout((setAppState, notif, processQueue) => {
+        currentTimeoutId = null;
+        setAppState(prev => {
+          // Compare by key instead of reference to handle re-created notifications
+          if (prev.notifications.current?.key !== notif.key) {
+            return prev;
+          }
+          return {
+            ...prev,
+            notifications: {
+              queue: prev.notifications.queue.filter(_ => !notif.invalidates?.includes(_.key)),
+              current: null
+            }
+          };
+        });
+        processQueue();
+      }, notif.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, notif, processQueue);
+
+      // Show the immediate notification right away
+      setAppState(prev => ({
+        ...prev,
+        notifications: {
+          current: notif,
+          queue:
+          // Only re-queue the current notification if it's not immediate
+          [...(prev.notifications.current ? [prev.notifications.current] : []), ...prev.notifications.queue].filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key))
+        }
+      }));
+      return; // IMPORTANT: Exit addNotification for immediate notifications
+    }
+
+    // Handle non-immediate notifications
+    setAppState(prev => {
+      // Check if we can fold into an existing notification with the same key
+      if (notif.fold) {
+        // Fold into current notification if keys match
+        if (prev.notifications.current?.key === notif.key) {
+          const folded = notif.fold(prev.notifications.current, notif);
+          // Reset timeout for the folded notification
+          if (currentTimeoutId) {
+            clearTimeout(currentTimeoutId);
+            currentTimeoutId = null;
+          }
+          currentTimeoutId = setTimeout((setAppState, foldedKey, processQueue) => {
+            currentTimeoutId = null;
+            setAppState(p => {
+              if (p.notifications.current?.key !== foldedKey) {
+                return p;
+              }
+              return {
+                ...p,
+                notifications: {
+                  queue: p.notifications.queue,
+                  current: null
+                }
+              };
+            });
+            processQueue();
+          }, folded.timeoutMs ?? DEFAULT_TIMEOUT_MS, setAppState, folded.key, processQueue);
+          return {
+            ...prev,
+            notifications: {
+              current: folded,
+              queue: prev.notifications.queue
+            }
+          };
+        }
+
+        // Fold into queued notification if keys match
+        const queueIdx = prev.notifications.queue.findIndex(_ => _.key === notif.key);
+        if (queueIdx !== -1) {
+          const folded = notif.fold(prev.notifications.queue[queueIdx]!, notif);
+          const newQueue = [...prev.notifications.queue];
+          newQueue[queueIdx] = folded;
+          return {
+            ...prev,
+            notifications: {
+              current: prev.notifications.current,
+              queue: newQueue
+            }
+          };
+        }
+      }
+
+      // Only add to queue if not already present (prevent duplicates)
+      const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key));
+      const shouldAdd = !queuedKeys.has(notif.key) && prev.notifications.current?.key !== notif.key;
+      if (!shouldAdd) return prev;
+      const invalidatesCurrent = prev.notifications.current !== null && notif.invalidates?.includes(prev.notifications.current.key);
+      if (invalidatesCurrent && currentTimeoutId) {
+        clearTimeout(currentTimeoutId);
+        currentTimeoutId = null;
+      }
+      return {
+        ...prev,
+        notifications: {
+          current: invalidatesCurrent ? null : prev.notifications.current,
+          queue: [...prev.notifications.queue.filter(_ => _.priority !== 'immediate' && !notif.invalidates?.includes(_.key)), notif]
+        }
+      };
+    });
+
+    // Process queue after adding the notification
+    processQueue();
+  }, [setAppState, processQueue]);
+  const removeNotification = useCallback<RemoveNotificationFn>((key: string) => {
+    setAppState(prev => {
+      const isCurrent = prev.notifications.current?.key === key;
+      const inQueue = prev.notifications.queue.some(n => n.key === key);
+      if (!isCurrent && !inQueue) {
+        return prev;
+      }
+      if (isCurrent && currentTimeoutId) {
+        clearTimeout(currentTimeoutId);
+        currentTimeoutId = null;
+      }
+      return {
+        ...prev,
+        notifications: {
+          current: isCurrent ? null : prev.notifications.current,
+          queue: prev.notifications.queue.filter(n => n.key !== key)
+        }
+      };
+    });
+    processQueue();
+  }, [setAppState, processQueue]);
+
+  // Process queue on mount if there are notifications in the initial state.
+  // Imperative read (not useAppState) — a subscription in a mount-only
+  // effect would be vestigial and make every caller re-render on queue changes.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref
+  useEffect(() => {
+    if (store.getState().notifications.queue.length > 0) {
+      processQueue();
+    }
+  }, []);
+  return {
+    addNotification,
+    removeNotification
+  };
+}
+const PRIORITIES: Record<Priority, number> = {
+  immediate: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+export function getNext(queue: Notification[]): Notification | undefined {
+  if (queue.length === 0) return undefined;
+  return queue.reduce((min, n) => PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useAppStateStore","useSetAppState","Theme","Priority","BaseNotification","key","invalidates","priority","timeoutMs","fold","accumulator","Notification","incoming","TextNotification","text","color","JSXNotification","jsx","ReactNode","AddNotificationFn","content","RemoveNotificationFn","DEFAULT_TIMEOUT_MS","currentTimeoutId","NodeJS","Timeout","useNotifications","addNotification","removeNotification","store","setAppState","processQueue","prev","next","getNext","notifications","queue","current","setTimeout","nextKey","filter","_","notif","clearTimeout","includes","folded","foldedKey","p","queueIdx","findIndex","newQueue","queuedKeys","Set","map","shouldAdd","has","invalidatesCurrent","isCurrent","inQueue","some","n","getState","length","PRIORITIES","Record","immediate","high","medium","low","undefined","reduce","min"],"sources":["notifications.tsx"],"sourcesContent":["import type * as React from 'react'\nimport { useCallback, useEffect } from 'react'\nimport { useAppStateStore, useSetAppState } from 'src/state/AppState.js'\nimport type { Theme } from '../utils/theme.js'\n\ntype Priority = 'low' | 'medium' | 'high' | 'immediate'\n\ntype BaseNotification = {\n  key: string\n  /**\n   * Keys of notifications that this notification invalidates.\n   * If a notification is invalidated, it will be removed from the queue\n   * and, if currently displayed, cleared immediately.\n   */\n  invalidates?: string[]\n  priority: Priority\n  timeoutMs?: number\n  /**\n   * Combine notifications with the same key, like Array.reduce().\n   * Called as fold(accumulator, incoming) when a notification with a matching\n   * key already exists in the queue or is currently displayed.\n   * Returns the merged notification (should carry fold forward for future merges).\n   */\n  fold?: (accumulator: Notification, incoming: Notification) => Notification\n}\n\ntype TextNotification = BaseNotification & {\n  text: string\n  color?: keyof Theme\n}\n\ntype JSXNotification = BaseNotification & {\n  jsx: React.ReactNode\n}\n\ntype AddNotificationFn = (content: Notification) => void\ntype RemoveNotificationFn = (key: string) => void\n\nexport type Notification = TextNotification | JSXNotification\n\nconst DEFAULT_TIMEOUT_MS = 8000\n\n// Track current timeout to clear it when immediate notifications arrive\nlet currentTimeoutId: NodeJS.Timeout | null = null\n\nexport function useNotifications(): {\n  addNotification: AddNotificationFn\n  removeNotification: RemoveNotificationFn\n} {\n  const store = useAppStateStore()\n  const setAppState = useSetAppState()\n\n  // Process queue when current notification finishes or queue changes\n  const processQueue = useCallback(() => {\n    setAppState(prev => {\n      const next = getNext(prev.notifications.queue)\n      if (prev.notifications.current !== null || !next) {\n        return prev\n      }\n\n      currentTimeoutId = setTimeout(\n        (setAppState, nextKey, processQueue) => {\n          currentTimeoutId = null\n          setAppState(prev => {\n            // Compare by key instead of reference to handle re-created notifications\n            if (prev.notifications.current?.key !== nextKey) {\n              return prev\n            }\n            return {\n              ...prev,\n              notifications: {\n                queue: prev.notifications.queue,\n                current: null,\n              },\n            }\n          })\n          processQueue()\n        },\n        next.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n        setAppState,\n        next.key,\n        processQueue,\n      )\n\n      return {\n        ...prev,\n        notifications: {\n          queue: prev.notifications.queue.filter(_ => _ !== next),\n          current: next,\n        },\n      }\n    })\n  }, [setAppState])\n\n  const addNotification = useCallback<AddNotificationFn>(\n    (notif: Notification) => {\n      // Handle immediate priority notifications\n      if (notif.priority === 'immediate') {\n        // Clear any existing timeout since we're showing a new immediate notification\n        if (currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        // Set up timeout for the immediate notification\n        currentTimeoutId = setTimeout(\n          (setAppState, notif, processQueue) => {\n            currentTimeoutId = null\n            setAppState(prev => {\n              // Compare by key instead of reference to handle re-created notifications\n              if (prev.notifications.current?.key !== notif.key) {\n                return prev\n              }\n              return {\n                ...prev,\n                notifications: {\n                  queue: prev.notifications.queue.filter(\n                    _ => !notif.invalidates?.includes(_.key),\n                  ),\n                  current: null,\n                },\n              }\n            })\n            processQueue()\n          },\n          notif.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n          setAppState,\n          notif,\n          processQueue,\n        )\n\n        // Show the immediate notification right away\n        setAppState(prev => ({\n          ...prev,\n          notifications: {\n            current: notif,\n            queue:\n              // Only re-queue the current notification if it's not immediate\n              [\n                ...(prev.notifications.current\n                  ? [prev.notifications.current]\n                  : []),\n                ...prev.notifications.queue,\n              ].filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n          },\n        }))\n        return // IMPORTANT: Exit addNotification for immediate notifications\n      }\n\n      // Handle non-immediate notifications\n      setAppState(prev => {\n        // Check if we can fold into an existing notification with the same key\n        if (notif.fold) {\n          // Fold into current notification if keys match\n          if (prev.notifications.current?.key === notif.key) {\n            const folded = notif.fold(prev.notifications.current, notif)\n            // Reset timeout for the folded notification\n            if (currentTimeoutId) {\n              clearTimeout(currentTimeoutId)\n              currentTimeoutId = null\n            }\n            currentTimeoutId = setTimeout(\n              (setAppState, foldedKey, processQueue) => {\n                currentTimeoutId = null\n                setAppState(p => {\n                  if (p.notifications.current?.key !== foldedKey) {\n                    return p\n                  }\n                  return {\n                    ...p,\n                    notifications: {\n                      queue: p.notifications.queue,\n                      current: null,\n                    },\n                  }\n                })\n                processQueue()\n              },\n              folded.timeoutMs ?? DEFAULT_TIMEOUT_MS,\n              setAppState,\n              folded.key,\n              processQueue,\n            )\n\n            return {\n              ...prev,\n              notifications: {\n                current: folded,\n                queue: prev.notifications.queue,\n              },\n            }\n          }\n\n          // Fold into queued notification if keys match\n          const queueIdx = prev.notifications.queue.findIndex(\n            _ => _.key === notif.key,\n          )\n          if (queueIdx !== -1) {\n            const folded = notif.fold(\n              prev.notifications.queue[queueIdx]!,\n              notif,\n            )\n            const newQueue = [...prev.notifications.queue]\n            newQueue[queueIdx] = folded\n            return {\n              ...prev,\n              notifications: {\n                current: prev.notifications.current,\n                queue: newQueue,\n              },\n            }\n          }\n        }\n\n        // Only add to queue if not already present (prevent duplicates)\n        const queuedKeys = new Set(prev.notifications.queue.map(_ => _.key))\n        const shouldAdd =\n          !queuedKeys.has(notif.key) &&\n          prev.notifications.current?.key !== notif.key\n\n        if (!shouldAdd) return prev\n\n        const invalidatesCurrent =\n          prev.notifications.current !== null &&\n          notif.invalidates?.includes(prev.notifications.current.key)\n\n        if (invalidatesCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: invalidatesCurrent ? null : prev.notifications.current,\n            queue: [\n              ...prev.notifications.queue.filter(\n                _ =>\n                  _.priority !== 'immediate' &&\n                  !notif.invalidates?.includes(_.key),\n              ),\n              notif,\n            ],\n          },\n        }\n      })\n\n      // Process queue after adding the notification\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  const removeNotification = useCallback<RemoveNotificationFn>(\n    (key: string) => {\n      setAppState(prev => {\n        const isCurrent = prev.notifications.current?.key === key\n        const inQueue = prev.notifications.queue.some(n => n.key === key)\n\n        if (!isCurrent && !inQueue) {\n          return prev\n        }\n\n        if (isCurrent && currentTimeoutId) {\n          clearTimeout(currentTimeoutId)\n          currentTimeoutId = null\n        }\n\n        return {\n          ...prev,\n          notifications: {\n            current: isCurrent ? null : prev.notifications.current,\n            queue: prev.notifications.queue.filter(n => n.key !== key),\n          },\n        }\n      })\n\n      processQueue()\n    },\n    [setAppState, processQueue],\n  )\n\n  // Process queue on mount if there are notifications in the initial state.\n  // Imperative read (not useAppState) — a subscription in a mount-only\n  // effect would be vestigial and make every caller re-render on queue changes.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only effect, store is a stable context ref\n  useEffect(() => {\n    if (store.getState().notifications.queue.length > 0) {\n      processQueue()\n    }\n  }, [])\n\n  return { addNotification, removeNotification }\n}\n\nconst PRIORITIES: Record<Priority, number> = {\n  immediate: 0,\n  high: 1,\n  medium: 2,\n  low: 3,\n}\nexport function getNext(queue: Notification[]): Notification | undefined {\n  if (queue.length === 0) return undefined\n  return queue.reduce((min, n) =>\n    PRIORITIES[n.priority] < PRIORITIES[min.priority] ? n : min,\n  )\n}\n"],"mappings":"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","ignoreList":[]}