@omerdlw/base-framework 1.0.6 → 2.0.1

package/dist/chunk-TV3WEF5G.js

@@ -0,0 +1,784 @@
+import { useLayoutEffect, useEffect, use, useRef, useCallback, useSyncExternalStore, useState } from 'react';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+function useRequiredContext(context, hookName, providerName) {
+  const value = use(context);
+  if (value === null) {
+    throw new Error(`${hookName} must be used within ${providerName}`);
+  }
+  return value;
+}
+function useStore(store, selector = (state) => state, isEqual = Object.is) {
+  const cacheRef = useRef({
+    isEqual: null,
+    selected: void 0,
+    selector: null,
+    snapshot: null
+  });
+  const getSelectedSnapshot = useCallback(() => {
+    const snapshot = store.getSnapshot();
+    const cache = cacheRef.current;
+    if (cache.snapshot === snapshot && cache.selector === selector && cache.isEqual === isEqual) {
+      return cache.selected;
+    }
+    const selected = selector(snapshot);
+    if (cache.snapshot !== null && cache.isEqual === isEqual && isEqual(cache.selected, selected)) {
+      cache.snapshot = snapshot;
+      cache.selector = selector;
+      return cache.selected;
+    }
+    cacheRef.current = {
+      isEqual,
+      selected,
+      selector,
+      snapshot
+    };
+    return selected;
+  }, [isEqual, selector, store]);
+  return useSyncExternalStore(
+    store.subscribe,
+    getSelectedSnapshot,
+    getSelectedSnapshot
+  );
+}
+function useClickOutside(ref, callback) {
+  const handlePointer = useCallback(
+    (event) => {
+      if (ref?.current && !ref.current.contains(event.target)) {
+        callback?.(event);
+      }
+    },
+    [callback, ref]
+  );
+  useEffect(() => {
+    document.addEventListener("pointerdown", handlePointer);
+    return () => document.removeEventListener("pointerdown", handlePointer);
+  }, [handlePointer]);
+}
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/utils/string.ts
+function trimToNull(value) {
+  if (value === null || value === void 0) return null;
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function stripTrailingSlash(url) {
+  if (typeof url !== "string") return "";
+  return url.replace(/\/+$/, "");
+}
+function normalizePath(path) {
+  const trimmed = trimToNull(path);
+  if (!trimmed) return "";
+  if (trimmed === "/") return "/";
+  return stripTrailingSlash(trimmed);
+}
+function isImageIconSource(icon) {
+  return typeof icon === "string" && (icon.startsWith("http://") || icon.startsWith("https://") || icon.startsWith("/") || icon.startsWith("data:image/"));
+}
+
+// src/utils/dom.ts
+var isBrowser = typeof window !== "undefined";
+var globalScrollLockCount = 0;
+var globalScrollLockStyles = null;
+function acquireGlobalScrollLock() {
+  if (typeof document === "undefined") return () => {
+  };
+  if (globalScrollLockCount === 0) {
+    globalScrollLockStyles = {
+      bodyOverflow: document.body.style.overflow,
+      bodyOverscrollBehavior: document.body.style.overscrollBehavior,
+      htmlOverflow: document.documentElement.style.overflow,
+      htmlOverscrollBehavior: document.documentElement.style.overscrollBehavior
+    };
+  }
+  globalScrollLockCount += 1;
+  document.body.style.overflow = "hidden";
+  document.body.style.overscrollBehavior = "none";
+  document.documentElement.style.overflow = "hidden";
+  document.documentElement.style.overscrollBehavior = "none";
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    globalScrollLockCount = Math.max(0, globalScrollLockCount - 1);
+    if (globalScrollLockCount > 0 || !globalScrollLockStyles) return;
+    document.body.style.overflow = globalScrollLockStyles.bodyOverflow;
+    document.body.style.overscrollBehavior = globalScrollLockStyles.bodyOverscrollBehavior;
+    document.documentElement.style.overflow = globalScrollLockStyles.htmlOverflow;
+    document.documentElement.style.overscrollBehavior = globalScrollLockStyles.htmlOverscrollBehavior;
+    globalScrollLockStyles = null;
+  };
+}
+function getSiteUrl() {
+  return stripTrailingSlash(
+    process.env.NEXT_PUBLIC_SITE_URL || "http://localhost:3000"
+  );
+}
+function getCurrentPath() {
+  if (!isBrowser) return "/";
+  return `${window.location.pathname}${window.location.search}`;
+}
+
+// src/utils/number.ts
+function clamp(value, min, max) {
+  const num = Number(value);
+  const finite = Number.isFinite(num) ? num : min;
+  return Math.min(Math.max(finite, min), max);
+}
+function toFiniteNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+// src/utils/object.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPlainObject(value) {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key) || !Object.is(
+      a[key],
+      b[key]
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+function toArray(value) {
+  if (value === null || value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/utils/timing.ts
+function debounce(func, wait = 300) {
+  let timeoutId = null;
+  function debounced(...args) {
+    if (timeoutId !== null) clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      func(...args);
+    }, wait);
+  }
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+function throttle(func, limit = 300) {
+  let lastRan = 0;
+  let timerId = null;
+  const throttled = function(...args) {
+    const now = Date.now();
+    if (now - lastRan >= limit) {
+      lastRan = now;
+      func(...args);
+    } else if (timerId === null) {
+      timerId = setTimeout(
+        () => {
+          lastRan = Date.now();
+          timerId = null;
+          func(...args);
+        },
+        limit - (now - lastRan)
+      );
+    }
+  };
+  throttled.cancel = () => {
+    if (timerId === null) return;
+    clearTimeout(timerId);
+    timerId = null;
+  };
+  return throttled;
+}
+
+// src/utils/report.ts
+var GLOBAL_SINK_KEY = /* @__PURE__ */ Symbol.for("__base_framework_report_sink__");
+var _global = globalThis;
+function report(scope, error, level = "error") {
+  const sink = _global[GLOBAL_SINK_KEY];
+  if (sink) {
+    try {
+      sink(scope, error, level);
+      return;
+    } catch {
+    }
+  }
+  if (process.env.NODE_ENV === "production" && typeof window !== "undefined") {
+    return;
+  }
+  console[level](`[${scope}]`, error);
+}
+function setReportSink(next) {
+  _global[GLOBAL_SINK_KEY] = next;
+  return () => {
+    if (_global[GLOBAL_SINK_KEY] === next) _global[GLOBAL_SINK_KEY] = null;
+  };
+}
+
+// src/utils/user-message.ts
+var USER_MESSAGES = Object.freeze({
+  generic: "Something went wrong. Please try again",
+  network: "You appear to be offline. Check your connection and try again",
+  timeout: "That took too long. Please try again",
+  unauthorized: "Your session has expired. Please sign in again",
+  forbidden: "You don't have permission to do that",
+  notFound: "We couldn't find what you were looking for",
+  rateLimited: "Too many attempts. Please wait a moment and try again",
+  server: "We're having trouble on our end. Please try again in a moment"
+});
+var UserError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "UserError";
+    this.status = status;
+  }
+};
+var NETWORK_FAILURE = /failed to fetch|network|load failed|fetch failed/i;
+function readField(source, field, type) {
+  const value = source?.[field];
+  return typeof value === type ? value : void 0;
+}
+function readPayloadMessage(error) {
+  const payload = error?.payload;
+  const message = readField(payload, "error", "string")?.trim();
+  return message || void 0;
+}
+function toUserMessage(error, { codes, fallback = USER_MESSAGES.generic } = {}) {
+  if (typeof error === "string") return error.trim() || fallback;
+  if (!error || typeof error !== "object") return fallback;
+  if (error instanceof UserError) {
+    if (error.status === 401) return USER_MESSAGES.unauthorized;
+    return error.message || fallback;
+  }
+  if (error.name === "AbortError") return fallback;
+  const code = readField(error, "code", "string");
+  if (code && codes?.[code]) return codes[code];
+  const status = readField(error, "status", "number");
+  if (status === 401) return USER_MESSAGES.unauthorized;
+  if (status === 429) return USER_MESSAGES.rateLimited;
+  if (status === 408 || status === 504) return USER_MESSAGES.timeout;
+  if (status !== void 0 && status >= 500) return USER_MESSAGES.server;
+  if (status !== void 0 && status >= 400) {
+    const authored = readPayloadMessage(error);
+    if (authored) return authored;
+    if (status === 403) return USER_MESSAGES.forbidden;
+    if (status === 404) return USER_MESSAGES.notFound;
+    return fallback;
+  }
+  const isOffline = typeof navigator !== "undefined" && navigator.onLine === false;
+  if (isOffline || NETWORK_FAILURE.test(error.message ?? "") && (error instanceof TypeError || /fetch/i.test(error.name))) {
+    return USER_MESSAGES.network;
+  }
+  return fallback;
+}
+
+// src/utils/store.ts
+function freezeStoreSnapshot(state) {
+  if (process.env.NODE_ENV === "production" || !state || typeof state !== "object") {
+    return state;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const freeze = (value) => {
+    if (seen.has(value) || Object.isFrozen(value)) return;
+    seen.add(value);
+    const prototype = Object.getPrototypeOf(value);
+    if (Array.isArray(value) || prototype === Object.prototype || prototype === null) {
+      for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor && "value" in descriptor && descriptor.value !== null) {
+          if (typeof descriptor.value === "object") freeze(descriptor.value);
+        }
+      }
+    }
+    Object.freeze(value);
+  };
+  freeze(state);
+  return state;
+}
+function createStore(initialState, { freezeSnapshots = true } = {}) {
+  const listeners2 = /* @__PURE__ */ new Set();
+  const prepare = freezeSnapshots ? freezeStoreSnapshot : (state) => state;
+  let snapshot = prepare(initialState);
+  const publish = (nextStateOrUpdater) => {
+    const nextState = typeof nextStateOrUpdater === "function" ? nextStateOrUpdater(snapshot) : nextStateOrUpdater;
+    if (Object.is(snapshot, nextState)) return false;
+    snapshot = prepare(nextState);
+    for (const listener of listeners2) {
+      try {
+        listener();
+      } catch (error) {
+        report("CoreStore subscriber", error, "warn");
+      }
+    }
+    return true;
+  };
+  const setState = (updater) => {
+    if (typeof updater === "function") {
+      return publish(updater);
+    }
+    if (snapshot && typeof snapshot === "object" && updater && typeof updater === "object") {
+      return publish({ ...snapshot, ...updater });
+    }
+    return publish(updater);
+  };
+  return Object.freeze({
+    getSnapshot() {
+      return snapshot;
+    },
+    publish,
+    setState,
+    subscribe(listener) {
+      if (typeof listener !== "function") return () => {
+      };
+      listeners2.add(listener);
+      return () => listeners2.delete(listener);
+    }
+  });
+}
+
+// src/utils/scheduler.ts
+var DEFAULT_SCHEDULER_FRAME_MS = 16;
+var EMPTY_SCHEDULER_TASKS = Object.freeze(
+  []
+);
+function getDefaultSchedulerNow() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function createScheduler({
+  cancelFrame = typeof window !== "undefined" && typeof window.cancelAnimationFrame === "function" ? (id) => window.cancelAnimationFrame(id) : (id) => clearTimeout(id),
+  clearTimer = (id) => clearTimeout(id),
+  defaultLabel = "scheduled-task",
+  now = getDefaultSchedulerNow,
+  requestFrame = typeof window !== "undefined" && typeof window.requestAnimationFrame === "function" ? (cb) => window.requestAnimationFrame(cb) : (cb) => setTimeout(cb, DEFAULT_SCHEDULER_FRAME_MS),
+  scheduleTimer = (cb, delayMs) => setTimeout(cb, delayMs)
+} = {}) {
+  const listeners2 = /* @__PURE__ */ new Set();
+  const tasks = /* @__PURE__ */ new Map();
+  let nextTaskId = 0;
+  let snapshot = {
+    pendingCount: 0,
+    tasks: EMPTY_SCHEDULER_TASKS
+  };
+  const publish = () => {
+    const currentTasks = [];
+    for (const task of tasks.values()) {
+      currentTasks.push({
+        createdAt: task.createdAt,
+        dueAt: task.dueAt,
+        id: task.id,
+        kind: task.kind,
+        label: task.label
+      });
+    }
+    snapshot = {
+      pendingCount: tasks.size,
+      tasks: currentTasks
+    };
+    for (const listener of listeners2) {
+      try {
+        listener();
+      } catch (error) {
+        report("Scheduler subscriber", error, "warn");
+      }
+    }
+  };
+  const scheduleInternal = (kind, callback, delayMs, options = {}) => {
+    if (typeof callback !== "function") return null;
+    const safeDelay = Math.max(0, Number(delayMs) || 0);
+    const taskId = ++nextTaskId;
+    const createdAt = now();
+    const invoke = (timestamp = now()) => {
+      if (!tasks.has(taskId)) return;
+      tasks.delete(taskId);
+      publish();
+      callback(timestamp);
+    };
+    const nativeId = kind === "frame" ? requestFrame(invoke) : scheduleTimer(invoke, safeDelay);
+    tasks.set(taskId, {
+      cancel: kind === "frame" ? cancelFrame : clearTimer,
+      createdAt,
+      dueAt: createdAt + (kind === "frame" ? DEFAULT_SCHEDULER_FRAME_MS : safeDelay),
+      id: taskId,
+      kind,
+      label: typeof options.label === "string" && options.label ? options.label : defaultLabel,
+      nativeId
+    });
+    publish();
+    return taskId;
+  };
+  const cancel = (taskId) => {
+    const task = tasks.get(taskId);
+    if (!task) return false;
+    tasks.delete(taskId);
+    try {
+      task.cancel(task.nativeId);
+    } catch (error) {
+      report("Scheduler cancellation", error, "warn");
+    }
+    publish();
+    return true;
+  };
+  return Object.freeze({
+    cancel,
+    cancelAll() {
+      if (tasks.size === 0) return [];
+      const taskIds = [];
+      for (const [taskId, task] of tasks) {
+        taskIds.push(taskId);
+        try {
+          task.cancel(task.nativeId);
+        } catch (error) {
+          report("Scheduler cancellation", error, "warn");
+        }
+      }
+      tasks.clear();
+      publish();
+      return taskIds;
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    now,
+    schedule(callback, delayMs = 0, options = {}) {
+      return scheduleInternal("timer", callback, delayMs, options);
+    },
+    scheduleFrame(callback, options = {}) {
+      return scheduleInternal(
+        "frame",
+        callback,
+        DEFAULT_SCHEDULER_FRAME_MS,
+        options
+      );
+    },
+    subscribe(listener) {
+      if (typeof listener !== "function") return () => {
+      };
+      listeners2.add(listener);
+      return () => listeners2.delete(listener);
+    }
+  });
+}
+
+// src/hooks/use-isomorphic-layout-effect.ts
+var useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;
+
+// src/events.ts
+var EVENT_TYPES = Object.freeze({
+  API_UNAUTHORIZED: "API_UNAUTHORIZED",
+  STATE_CHANGE: "STATE_CHANGE",
+  API_ERROR: "API_ERROR",
+  APP_ERROR: "APP_ERROR"
+});
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  subscribe(event, callback) {
+    if (typeof event !== "string" || !event || typeof callback !== "function") {
+      return () => {
+      };
+    }
+    const listeners2 = this.events.get(event) || /* @__PURE__ */ new Set();
+    listeners2.add(callback);
+    this.events.set(event, listeners2);
+    return () => {
+      listeners2.delete(callback);
+      if (listeners2.size === 0) this.events.delete(event);
+    };
+  }
+  emit(event, payload) {
+    const listeners2 = this.events.get(event);
+    if (!listeners2 || listeners2.size === 0) return;
+    const snapshot = Array.from(listeners2);
+    for (const callback of snapshot) {
+      try {
+        callback(payload);
+      } catch (error) {
+        report(`Event listener (${String(event)})`, error);
+      }
+    }
+  }
+  emitDebounced(event, payload, waitMs = 100) {
+    const existing = this.debounceTimers.get(event);
+    if (existing) clearTimeout(existing);
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(event);
+      this.emit(event, payload);
+    }, waitMs);
+    this.debounceTimers.set(event, timer);
+  }
+  cancelDebounced(event) {
+    if (event) {
+      const timer = this.debounceTimers.get(event);
+      if (timer) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(event);
+      }
+    } else {
+      for (const timer of this.debounceTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.debounceTimers.clear();
+    }
+  }
+  unsubscribeAll(event) {
+    this.cancelDebounced(event);
+    if (event) this.events.delete(event);
+    else this.events.clear();
+  }
+  hasListeners(event) {
+    return Boolean(this.events.get(event)?.size);
+  }
+  getListenerCount(event) {
+    return this.events.get(event)?.size || 0;
+  }
+  getAllEvents() {
+    return [...this.events.keys()];
+  }
+};
+var GLOBAL_EVENTS_KEY = /* @__PURE__ */ Symbol.for("__base_framework_global_events__");
+var _global2 = globalThis;
+var globalEvents = _global2[GLOBAL_EVENTS_KEY] ?? (_global2[GLOBAL_EVENTS_KEY] = new EventEmitter());
+
+// src/hooks/use-global-event.ts
+function useGlobalEvent(event, callback, options) {
+  const callbackRef = useRef(callback);
+  const debounceTimerRef = useRef(null);
+  const lastThrottleTimeRef = useRef(0);
+  const throttleTimerRef = useRef(null);
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const debounceMs = options?.debounceMs;
+  const throttleMs = options?.throttleMs;
+  useEffect(() => {
+    if (!event) return;
+    const events = Array.isArray(event) ? event.filter(Boolean) : [event];
+    if (events.length === 0) return;
+    const handler = (payload) => {
+      if (debounceMs != null && debounceMs > 0) {
+        if (debounceTimerRef.current !== null) {
+          clearTimeout(debounceTimerRef.current);
+        }
+        debounceTimerRef.current = setTimeout(() => {
+          debounceTimerRef.current = null;
+          callbackRef.current?.(payload);
+        }, debounceMs);
+        return;
+      }
+      if (throttleMs != null && throttleMs > 0) {
+        const now = Date.now();
+        const remaining = throttleMs - (now - lastThrottleTimeRef.current);
+        if (remaining <= 0) {
+          if (throttleTimerRef.current !== null) {
+            clearTimeout(throttleTimerRef.current);
+            throttleTimerRef.current = null;
+          }
+          lastThrottleTimeRef.current = now;
+          callbackRef.current?.(payload);
+        } else if (throttleTimerRef.current === null) {
+          throttleTimerRef.current = setTimeout(() => {
+            lastThrottleTimeRef.current = Date.now();
+            throttleTimerRef.current = null;
+            callbackRef.current?.(payload);
+          }, remaining);
+        }
+        return;
+      }
+      callbackRef.current?.(payload);
+    };
+    const unsubs = events.map((ev) => globalEvents.subscribe(ev, handler));
+    return () => {
+      unsubs.forEach((unsub) => unsub());
+      if (debounceTimerRef.current !== null) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+      if (throttleTimerRef.current !== null) {
+        clearTimeout(throttleTimerRef.current);
+        throttleTimerRef.current = null;
+      }
+    };
+  }, [event, debounceMs, throttleMs]);
+}
+var listeners = /* @__PURE__ */ new Set();
+var activeFullscreenStateIds = /* @__PURE__ */ new Set();
+var ACTIVE_FULLSCREEN_ROOT_SELECTOR = '[data-fullscreen-state-root="true"][data-affect-global-state="true"]';
+var domObserver = null;
+var lastSnapshot = false;
+function getDomSnapshot() {
+  if (typeof document === "undefined") {
+    return activeFullscreenStateIds.size > 0;
+  }
+  return document.querySelector(ACTIVE_FULLSCREEN_ROOT_SELECTOR) !== null;
+}
+function emitChange() {
+  listeners.forEach((listener) => listener());
+}
+function emitIfSnapshotChanged() {
+  const nextSnapshot = getDomSnapshot();
+  if (nextSnapshot === lastSnapshot) {
+    return;
+  }
+  lastSnapshot = nextSnapshot;
+  emitChange();
+}
+function ensureDomObserver() {
+  if (typeof document === "undefined" || domObserver || listeners.size === 0) {
+    return;
+  }
+  domObserver = new MutationObserver(() => {
+    emitIfSnapshotChanged();
+  });
+  domObserver.observe(document.documentElement, {
+    attributes: true,
+    childList: true,
+    subtree: true,
+    attributeFilter: [
+      "data-fullscreen-state",
+      "data-fullscreen-state-root",
+      "data-affect-global-state"
+    ]
+  });
+}
+function releaseDomObserver() {
+  if (listeners.size > 0 || !domObserver) {
+    return;
+  }
+  domObserver.disconnect();
+  domObserver = null;
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  ensureDomObserver();
+  emitIfSnapshotChanged();
+  return () => {
+    listeners.delete(listener);
+    releaseDomObserver();
+  };
+}
+function getSnapshot() {
+  return getDomSnapshot();
+}
+function useIsFullscreenStateActive() {
+  return useSyncExternalStore(subscribe, getSnapshot, () => false);
+}
+function useControllableState({
+  defaultValue,
+  onChange,
+  value
+}) {
+  const [uncontrolledValue, setUncontrolledValue] = useState(defaultValue);
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value : uncontrolledValue;
+  const valueRef = useRef(currentValue);
+  const onChangeRef = useRef(onChange);
+  useIsomorphicLayoutEffect(() => {
+    valueRef.current = currentValue;
+    onChangeRef.current = onChange;
+  });
+  const setValue = useCallback(
+    (next) => {
+      const resolvedNext = typeof next === "function" ? next(valueRef.current) : next;
+      if (!Object.is(valueRef.current, resolvedNext)) {
+        if (!isControlled) {
+          setUncontrolledValue(resolvedNext);
+        }
+        onChangeRef.current?.(resolvedNext);
+      }
+    },
+    [isControlled]
+  );
+  return [currentValue, setValue];
+}
+function isEditableElement(target) {
+  if (!target || typeof target.tagName !== "string") {
+    return false;
+  }
+  const element = target;
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
+    return true;
+  }
+  return Boolean(element.isContentEditable);
+}
+function matchesKeyCombo(event, combo) {
+  const parts = combo.toLowerCase().split("+").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) return false;
+  const keyPart = parts[parts.length - 1];
+  const modifiers = new Set(parts.slice(0, -1));
+  const wantsMod = modifiers.has("mod") || modifiers.has("cmd") || modifiers.has("meta");
+  const wantsCtrl = modifiers.has("ctrl") || modifiers.has("control");
+  const wantsAlt = modifiers.has("alt") || modifiers.has("option");
+  const wantsShift = modifiers.has("shift");
+  const isModPressed = event.metaKey || event.ctrlKey;
+  if (wantsMod && !isModPressed) return false;
+  if (!wantsMod && !wantsCtrl && (event.metaKey || event.ctrlKey)) return false;
+  if (wantsCtrl && !event.ctrlKey) return false;
+  if (wantsAlt !== event.altKey) return false;
+  if (wantsShift !== event.shiftKey) return false;
+  const pressedKey = event.key.toLowerCase();
+  if (keyPart === "esc" || keyPart === "escape") {
+    return pressedKey === "escape" || pressedKey === "esc";
+  }
+  if (keyPart === "space") {
+    return pressedKey === " " || pressedKey === "spacebar";
+  }
+  return pressedKey === keyPart;
+}
+function useHotkey(combo, callback, options) {
+  const callbackRef = useRef(callback);
+  useIsomorphicLayoutEffect(() => {
+    callbackRef.current = callback;
+  });
+  const enabled = options?.enabled ?? true;
+  const enableOnFormTags = options?.enableOnFormTags ?? false;
+  const preventDefault = options?.preventDefault ?? true;
+  const stopPropagation = options?.stopPropagation ?? false;
+  useEffect(() => {
+    if (!isBrowser || !enabled || !combo) return;
+    const combos = (Array.isArray(combo) ? combo : [combo]).filter(Boolean);
+    if (combos.length === 0) return;
+    const handleKeyDown = (event) => {
+      if (!enableOnFormTags && isEditableElement(event.target)) return;
+      const matched = combos.some((c) => matchesKeyCombo(event, c));
+      if (!matched) return;
+      if (preventDefault) event.preventDefault();
+      if (stopPropagation) event.stopPropagation();
+      callbackRef.current?.(event);
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [combo, enabled, enableOnFormTags, preventDefault, stopPropagation]);
+}
+function useEscapeKey(callback, enabled = true) {
+  useHotkey("escape", callback, {
+    enabled,
+    enableOnFormTags: true,
+    preventDefault: false
+  });
+}
+
+export { EVENT_TYPES, EventEmitter, USER_MESSAGES, UserError, acquireGlobalScrollLock, clamp, cn, createScheduler, createStore, debounce, getCurrentPath, getSiteUrl, globalEvents, isBrowser, isImageIconSource, isObject, isPlainObject, normalizePath, report, setReportSink, shallowEqual, stripTrailingSlash, throttle, toArray, toFiniteNumber, toUserMessage, trimToNull, useClickOutside, useControllableState, useEscapeKey, useGlobalEvent, useHotkey, useIsFullscreenStateActive, useIsomorphicLayoutEffect, useRequiredContext, useStore };
+//# sourceMappingURL=chunk-TV3WEF5G.js.map
+//# sourceMappingURL=chunk-TV3WEF5G.js.map