@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/unstable-use-media-query.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unstable_use_media_query_exports = {};
+__export(unstable_use_media_query_exports, {
+  useMediaQuery: () => useMediaQuery
+});
+module.exports = __toCommonJS(unstable_use_media_query_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+var import_addEventListener = require("./utils/addEventListener.cjs");
+function useMediaQuery(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useMediaQuery");
+  const rawQuery = user[0];
+  const options = user[1] ?? {};
+  const supportMatchMedia = typeof window !== "undefined" && typeof window.matchMedia !== "undefined";
+  const normalizedQuery = rawQuery.replace(/^@media( ?)/m, "");
+  const {
+    defaultMatches = false,
+    matchMedia = supportMatchMedia ? window.matchMedia : null,
+    ssrMatchMedia = null,
+    noSsr = false
+  } = options;
+  const getDefaultSnapshot = (0, import_octane.useCallback)(
+    () => defaultMatches,
+    [defaultMatches],
+    (0, import_internal.subSlot)(slot, "def")
+  );
+  const getServerSnapshot = (0, import_octane.useMemo)(
+    () => {
+      if (noSsr && matchMedia) {
+        return () => matchMedia(normalizedQuery).matches;
+      }
+      if (ssrMatchMedia !== null) {
+        const { matches } = ssrMatchMedia(normalizedQuery);
+        return () => matches;
+      }
+      return getDefaultSnapshot;
+    },
+    [getDefaultSnapshot, normalizedQuery, ssrMatchMedia, noSsr, matchMedia],
+    (0, import_internal.subSlot)(slot, "srv")
+  );
+  const [getSnapshot, subscribe] = (0, import_octane.useMemo)(
+    () => {
+      if (matchMedia === null) {
+        return [getDefaultSnapshot, () => () => {
+        }];
+      }
+      const mediaQueryList = matchMedia(normalizedQuery);
+      return [
+        () => mediaQueryList.matches,
+        (notify) => (0, import_addEventListener.addEventListener)(mediaQueryList, "change", notify)
+      ];
+    },
+    [getDefaultSnapshot, matchMedia, normalizedQuery],
+    (0, import_internal.subSlot)(slot, "sub")
+  );
+  return (0, import_octane.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot, (0, import_internal.subSlot)(slot, "store"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMediaQuery
+});

package/dist/cjs/use-render.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var use_render_exports = {};
+__export(use_render_exports, {
+  useRender: () => useRender
+});
+module.exports = __toCommonJS(use_render_exports);
+var import_internal = require("./internal.cjs");
+var import_useRenderElement = require("./utils/useRenderElement.cjs");
+function useRender(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useRender");
+  const params = user[0];
+  return (0, import_useRenderElement.useRenderElement)(
+    params.defaultTagName ?? "div",
+    params,
+    params,
+    (0, import_internal.subSlot)(slot, "re")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRender
+});

package/dist/cjs/utils/CSPContext.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CSPContext_exports = {};
+__export(CSPContext_exports, {
+  CSPContext: () => CSPContext,
+  useCSPContext: () => useCSPContext
+});
+module.exports = __toCommonJS(CSPContext_exports);
+var import_octane = require("octane");
+const CSPContext = (0, import_octane.createContext)(void 0);
+const DEFAULT_CSP_CONTEXT_VALUE = {
+  disableStyleElements: false
+};
+function useCSPContext(...args) {
+  void args;
+  return (0, import_octane.useContext)(CSPContext) ?? DEFAULT_CSP_CONTEXT_VALUE;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CSPContext,
+  useCSPContext
+});

package/dist/cjs/utils/CheckboxGroupContext.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CheckboxGroupContext_exports = {};
+__export(CheckboxGroupContext_exports, {
+  CheckboxGroupContext: () => CheckboxGroupContext,
+  useCheckboxGroupContext: () => useCheckboxGroupContext
+});
+module.exports = __toCommonJS(CheckboxGroupContext_exports);
+var import_octane = require("octane");
+const CheckboxGroupContext = (0, import_octane.createContext)(void 0);
+function useCheckboxGroupContext(optional = true) {
+  const context = (0, import_octane.useContext)(CheckboxGroupContext);
+  if (context === void 0 && !optional) {
+    throw new Error(
+      "Base UI: CheckboxGroupContext is missing. CheckboxGroup parts must be placed within <CheckboxGroup>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckboxGroupContext,
+  useCheckboxGroupContext
+});

package/dist/cjs/utils/CompositeRootContext.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CompositeRootContext_exports = {};
+__export(CompositeRootContext_exports, {
+  CompositeRootContext: () => CompositeRootContext,
+  useCompositeRootContext: () => useCompositeRootContext
+});
+module.exports = __toCommonJS(CompositeRootContext_exports);
+var import_octane = require("octane");
+const CompositeRootContext = (0, import_octane.createContext)(void 0);
+function useCompositeRootContext(optional = false) {
+  const context = (0, import_octane.useContext)(CompositeRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(
+      "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompositeRootContext,
+  useCompositeRootContext
+});

package/dist/cjs/utils/ContextMenuRootContext.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ContextMenuRootContext_exports = {};
+__export(ContextMenuRootContext_exports, {
+  ContextMenuRootContext: () => ContextMenuRootContext,
+  useContextMenuRootContext: () => useContextMenuRootContext
+});
+module.exports = __toCommonJS(ContextMenuRootContext_exports);
+var import_octane = require("octane");
+const ContextMenuRootContext = (0, import_octane.createContext)(
+  void 0
+);
+function useContextMenuRootContext(optional = true) {
+  const context = (0, import_octane.useContext)(ContextMenuRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(
+      "Base UI: ContextMenuRootContext is missing. ContextMenu parts must be placed within <ContextMenu.Root>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextMenuRootContext,
+  useContextMenuRootContext
+});

package/dist/cjs/utils/DirectionContext.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DirectionContext_exports = {};
+__export(DirectionContext_exports, {
+  DirectionContext: () => DirectionContext,
+  useDirection: () => useDirection
+});
+module.exports = __toCommonJS(DirectionContext_exports);
+var import_octane = require("octane");
+const DirectionContext = (0, import_octane.createContext)(void 0);
+function useDirection() {
+  return (0, import_octane.useContext)(DirectionContext) ?? "ltr";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectionContext,
+  useDirection
+});

package/dist/cjs/utils/FloatingPortalLite.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FloatingPortalLite_exports = {};
+__export(FloatingPortalLite_exports, {
+  FloatingPortalLite: () => FloatingPortalLite
+});
+module.exports = __toCommonJS(FloatingPortalLite_exports);
+var import_octane = require("octane");
+var import_internal = require("../internal.cjs");
+var import_FloatingPortal = require("./floating/FloatingPortal.cjs");
+function FloatingPortalLite(componentProps) {
+  const slot = (0, import_internal.S)("FloatingPortalLite");
+  const { children, container, className, render, style, ref, ...elementProps } = componentProps;
+  const { portalNode, portalSubtree } = (0, import_FloatingPortal.useFloatingPortalNode)(
+    { container, ref, componentProps: { render, className, style }, elementProps },
+    (0, import_internal.subSlot)(slot, "node")
+  );
+  if (!portalSubtree && !portalNode) {
+    return null;
+  }
+  return (0, import_octane.createElement)(import_octane.Fragment, {
+    children: [
+      (0, import_octane.createElement)(import_octane.Fragment, { key: "subtree", children: portalSubtree }),
+      portalNode ? (0, import_octane.createElement)(import_octane.Fragment, { key: "portal", children: (0, import_octane.createPortal)(children, portalNode) }) : null
+    ]
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingPortalLite
+});

package/dist/cjs/utils/InternalBackdrop.cjs

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InternalBackdrop_exports = {};
+__export(InternalBackdrop_exports, {
+  InternalBackdrop: () => InternalBackdrop
+});
+module.exports = __toCommonJS(InternalBackdrop_exports);
+var import_octane = require("octane");
+function InternalBackdrop(props) {
+  const { cutout, ref, ...otherProps } = props;
+  let clipPath;
+  if (cutout) {
+    const rect = cutout.getBoundingClientRect();
+    clipPath = `polygon(0% 0%,100% 0%,100% 100%,0% 100%,0% 0%,${rect.left}px ${rect.top}px,${rect.left}px ${rect.bottom}px,${rect.right}px ${rect.bottom}px,${rect.right}px ${rect.top}px,${rect.left}px ${rect.top}px)`;
+  }
+  return (0, import_octane.createElement)("div", {
+    ref,
+    role: "presentation",
+    ["data-base-ui-inert"]: "",
+    ...otherProps,
+    style: {
+      position: "fixed",
+      inset: 0,
+      userSelect: "none",
+      WebkitUserSelect: "none",
+      clipPath
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBackdrop
+});

package/dist/cjs/utils/MenubarContext.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MenubarContext_exports = {};
+__export(MenubarContext_exports, {
+  MenubarContext: () => MenubarContext,
+  useMenubarContext: () => useMenubarContext
+});
+module.exports = __toCommonJS(MenubarContext_exports);
+var import_octane = require("octane");
+const MenubarContext = (0, import_octane.createContext)(null);
+function useMenubarContext(optional) {
+  const context = (0, import_octane.useContext)(MenubarContext);
+  if (context === null && !optional) {
+    throw new Error(
+      "Base UI: MenubarContext is missing. Menubar parts must be placed within <Menubar>."
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenubarContext,
+  useMenubarContext
+});

package/dist/cjs/utils/RadioGroupContext.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RadioGroupContext_exports = {};
+__export(RadioGroupContext_exports, {
+  RadioGroupContext: () => RadioGroupContext,
+  useRadioGroupContext: () => useRadioGroupContext
+});
+module.exports = __toCommonJS(RadioGroupContext_exports);
+var import_octane = require("octane");
+const RadioGroupContext = (0, import_octane.createContext)(void 0);
+function useRadioGroupContext() {
+  return (0, import_octane.useContext)(RadioGroupContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RadioGroupContext,
+  useRadioGroupContext
+});

package/dist/cjs/utils/RequestQueue.cjs

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RequestQueue_exports = {};
+__export(RequestQueue_exports, {
+  RequestQueue: () => RequestQueue
+});
+module.exports = __toCommonJS(RequestQueue_exports);
+class RequestQueue {
+  pendingRequests = /* @__PURE__ */ new Map();
+  queuedRequests = /* @__PURE__ */ new Map();
+  fetchFn;
+  maxConcurrentRequests;
+  getKeyId;
+  constructor(options) {
+    this.fetchFn = options.fetchFn;
+    this.maxConcurrentRequests = options.maxConcurrentRequests ?? Infinity;
+    this.getKeyId = options.getKeyId ?? String;
+  }
+  /**
+   * Returns the next `count` entries to process from the queue.
+   * Default is FIFO (oldest first). Subclasses can override for different ordering.
+   */
+  pickEntries(count) {
+    const result = [];
+    const iterator = this.queuedRequests.entries();
+    for (let i = 0; i < count; i += 1) {
+      const { value } = iterator.next();
+      result.push(value);
+    }
+    return result;
+  }
+  processQueue = async () => {
+    if (this.queuedRequests.size === 0 || this.pendingRequests.size >= this.maxConcurrentRequests) {
+      return;
+    }
+    const loopLength = Math.min(
+      this.maxConcurrentRequests - this.pendingRequests.size,
+      this.queuedRequests.size
+    );
+    if (loopLength === 0) {
+      return;
+    }
+    const fetchPromises = [];
+    for (const [keyId, key] of this.pickEntries(loopLength)) {
+      this.queuedRequests.delete(keyId);
+      this.pendingRequests.set(keyId, key);
+      fetchPromises.push(
+        this.fetchFn(key).catch(() => {
+          this.pendingRequests.delete(keyId);
+        })
+      );
+    }
+    await Promise.all(fetchPromises);
+    if (this.queuedRequests.size > 0) {
+      await this.processQueue();
+    }
+  };
+  queue = async (keys) => {
+    for (const key of keys) {
+      const keyId = this.getKeyId(key);
+      if (!this.pendingRequests.has(keyId)) {
+        this.queuedRequests.set(keyId, key);
+      }
+    }
+    await this.processQueue();
+  };
+  setRequestSettled = async (key) => {
+    const keyId = this.getKeyId(key);
+    this.pendingRequests.delete(keyId);
+    await this.processQueue();
+  };
+  clear = () => {
+    this.queuedRequests.clear();
+    this.pendingRequests.clear();
+  };
+  clearPendingRequest = async (key) => {
+    const keyId = this.getKeyId(key);
+    this.pendingRequests.delete(keyId);
+    await this.processQueue();
+  };
+  getRequestStatus = (key) => {
+    const keyId = this.getKeyId(key);
+    if (this.pendingRequests.has(keyId)) {
+      return "pending";
+    }
+    if (this.queuedRequests.has(keyId)) {
+      return "queued";
+    }
+    return "unknown";
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestQueue
+});

package/dist/cjs/utils/TimeoutManager.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TimeoutManager_exports = {};
+__export(TimeoutManager_exports, {
+  TimeoutManager: () => TimeoutManager
+});
+module.exports = __toCommonJS(TimeoutManager_exports);
+class TimeoutManager {
+  ids = /* @__PURE__ */ new Map();
+  /** Starts `fn` after `delay`, replacing any timeout already running under `key`. */
+  start = (key, delay, fn) => {
+    this.clear(key);
+    const id = setTimeout(() => {
+      this.ids.delete(key);
+      fn();
+    }, delay);
+    this.ids.set(key, id);
+  };
+  clear = (key) => {
+    const id = this.ids.get(key);
+    if (id != null) {
+      clearTimeout(id);
+      this.ids.delete(key);
+    }
+  };
+  clearAll = () => {
+    this.ids.forEach(clearTimeout);
+    this.ids.clear();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimeoutManager
+});