@octanejs/base-ui 0.1.31 → 0.1.32

package/dist/cjs/utils/field/useLabelableId.cjs

@@ -0,0 +1,105 @@
+"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 useLabelableId_exports = {};
+__export(useLabelableId_exports, {
+  useLabelableId: () => useLabelableId
+});
+module.exports = __toCommonJS(useLabelableId_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_noop = require("../noop.cjs");
+var import_useBaseUiId = require("../useBaseUiId.cjs");
+var import_useRefWithInit = require("../useRefWithInit.cjs");
+var import_useStableCallback = require("../useStableCallback.cjs");
+var import_LabelableContext = require("./LabelableContext.cjs");
+function isElement(el) {
+  return el != null && el instanceof Element;
+}
+function useLabelableId(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useLabelableId");
+  const { id, implicit = false, controlRef } = user[0] ?? {};
+  const { controlId, registerControlId } = (0, import_LabelableContext.useLabelableContext)();
+  const defaultId = (0, import_useBaseUiId.useBaseUiId)(id, (0, import_internal.subSlot)(slot, "def"));
+  const controlIdForEffect = implicit ? controlId : void 0;
+  const controlSourceRef = (0, import_useRefWithInit.useRefWithInit)(
+    () => /* @__PURE__ */ Symbol("labelable-control"),
+    (0, import_internal.subSlot)(slot, "src")
+  );
+  const hasRegisteredRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "has"));
+  const hadExplicitIdRef = (0, import_octane.useRef)(id != null, (0, import_internal.subSlot)(slot, "had"));
+  const unregisterControlId = (0, import_useStableCallback.useStableCallback)(
+    () => {
+      if (!hasRegisteredRef.current || registerControlId === import_noop.NOOP) {
+        return;
+      }
+      hasRegisteredRef.current = false;
+      registerControlId(controlSourceRef.current, void 0);
+    },
+    (0, import_internal.subSlot)(slot, "unreg")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (registerControlId === import_noop.NOOP) {
+        return void 0;
+      }
+      let nextId;
+      if (implicit) {
+        const elem = controlRef?.current;
+        if (isElement(elem) && elem.closest("label") != null) {
+          nextId = id ?? null;
+        } else {
+          nextId = controlIdForEffect ?? defaultId;
+        }
+      } else if (id != null) {
+        hadExplicitIdRef.current = true;
+        nextId = id;
+      } else if (hadExplicitIdRef.current) {
+        nextId = defaultId;
+      } else {
+        unregisterControlId();
+        return void 0;
+      }
+      if (nextId === void 0) {
+        unregisterControlId();
+        return void 0;
+      }
+      hasRegisteredRef.current = true;
+      registerControlId(controlSourceRef.current, nextId);
+      return void 0;
+    },
+    [
+      id,
+      controlRef,
+      controlIdForEffect,
+      registerControlId,
+      implicit,
+      defaultId,
+      controlSourceRef,
+      unregisterControlId
+    ],
+    (0, import_internal.subSlot)(slot, "e:reg")
+  );
+  (0, import_octane.useEffect)(() => unregisterControlId, [unregisterControlId], (0, import_internal.subSlot)(slot, "e:cleanup"));
+  return controlId ?? defaultId;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLabelableId
+});

package/dist/cjs/utils/field/useRegisterFieldControl.cjs

@@ -0,0 +1,60 @@
+"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 useRegisterFieldControl_exports = {};
+__export(useRegisterFieldControl_exports, {
+  useRegisterFieldControl: () => useRegisterFieldControl
+});
+module.exports = __toCommonJS(useRegisterFieldControl_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_FieldRootContext = require("./FieldRootContext.cjs");
+function useRegisterFieldControl(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useRegisterFieldControl");
+  const controlRef = user[0];
+  const id = user[1];
+  const value = user[2];
+  const getFormValueOverride = user[3];
+  const enabled = user[4] ?? true;
+  const name = user[5];
+  const { registerFieldControl } = (0, import_FieldRootContext.useFieldRootContext)();
+  const sourceRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "src"));
+  if (!sourceRef.current) {
+    sourceRef.current = /* @__PURE__ */ Symbol();
+  }
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      const source = sourceRef.current;
+      if (!source || !enabled) {
+        return void 0;
+      }
+      const registration = { controlRef, getValue: getFormValueOverride, id, name, value };
+      registerFieldControl(source, registration);
+      return () => {
+        registerFieldControl(source, void 0);
+      };
+    },
+    [controlRef, enabled, getFormValueOverride, id, name, registerFieldControl, value],
+    (0, import_internal.subSlot)(slot, "e:reg")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRegisterFieldControl
+});

package/dist/cjs/utils/findRootOwnerId.cjs

@@ -0,0 +1,37 @@
+"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 findRootOwnerId_exports = {};
+__export(findRootOwnerId_exports, {
+  findRootOwnerId: () => findRootOwnerId
+});
+module.exports = __toCommonJS(findRootOwnerId_exports);
+var import_dom = require("@floating-ui/utils/dom");
+function findRootOwnerId(node) {
+  if ((0, import_dom.isHTMLElement)(node) && node.hasAttribute("data-rootownerid")) {
+    return node.getAttribute("data-rootownerid") ?? void 0;
+  }
+  if ((0, import_dom.isLastTraversableNode)(node)) {
+    return void 0;
+  }
+  return findRootOwnerId((0, import_dom.getParentNode)(node));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findRootOwnerId
+});

package/dist/cjs/utils/floating/FloatingDelayGroup.cjs

@@ -0,0 +1,219 @@
+"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 FloatingDelayGroup_exports = {};
+__export(FloatingDelayGroup_exports, {
+  FloatingDelayGroup: () => FloatingDelayGroup,
+  useDelayGroup: () => useDelayGroup
+});
+module.exports = __toCommonJS(FloatingDelayGroup_exports);
+var import_octane = require("octane");
+var import_internal = require("../../internal.cjs");
+var import_useTimeout = require("../useTimeout.cjs");
+var import_createChangeEventDetails = require("../createChangeEventDetails.cjs");
+var import_useHoverShared = require("./useHoverShared.cjs");
+const DEFAULT_CONTEXT = {
+  hasProvider: false,
+  timeoutMs: 0,
+  delayRef: { current: 0 },
+  initialDelayRef: { current: 0 },
+  timeout: new import_useTimeout.Timeout(),
+  currentIdRef: { current: null },
+  currentContextRef: { current: null }
+};
+const FloatingDelayGroupContext = (0, import_octane.createContext)(DEFAULT_CONTEXT);
+function resetDelayRef(delayRef, initialDelayRef) {
+  delayRef.current = initialDelayRef.current;
+}
+function FloatingDelayGroup(props) {
+  const slot = (0, import_internal.S)("FloatingDelayGroup");
+  const { children, delay, timeoutMs = 0 } = props;
+  const delayRef = (0, import_octane.useRef)(delay, (0, import_internal.subSlot)(slot, "delay"));
+  const initialDelayRef = (0, import_octane.useRef)(delay, (0, import_internal.subSlot)(slot, "initial"));
+  const currentIdRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "id"));
+  const currentContextRef = (0, import_octane.useRef)(null, (0, import_internal.subSlot)(slot, "ctxRef"));
+  const timeout = (0, import_useTimeout.useTimeout)((0, import_internal.subSlot)(slot, "to"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      initialDelayRef.current = delay;
+      if (!currentIdRef.current) {
+        delayRef.current = delay;
+        return;
+      }
+      delayRef.current = {
+        open: (0, import_useHoverShared.getDelay)(delayRef.current, "open"),
+        close: (0, import_useHoverShared.getDelay)(delay, "close")
+      };
+    },
+    [delay, currentIdRef, delayRef, initialDelayRef],
+    (0, import_internal.subSlot)(slot, "l:delay")
+  );
+  const contextValue = (0, import_octane.useMemo)(
+    () => ({
+      hasProvider: true,
+      delayRef,
+      initialDelayRef,
+      currentIdRef,
+      timeoutMs,
+      currentContextRef,
+      timeout
+    }),
+    [timeoutMs, timeout],
+    (0, import_internal.subSlot)(slot, "ctx")
+  );
+  return (0, import_octane.createElement)(FloatingDelayGroupContext.Provider, { value: contextValue, children });
+}
+function useDelayGroup(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useDelayGroup");
+  const context = user[0];
+  const options = user[1] ?? { open: false };
+  const { open } = options;
+  const store = context != null && "rootStore" in context ? context.rootStore : context;
+  const floatingId = store.useState("floatingId", (0, import_internal.subSlot)(slot, "s:id"));
+  const groupContext = (0, import_octane.useContext)(FloatingDelayGroupContext);
+  const {
+    currentIdRef,
+    delayRef,
+    timeoutMs,
+    initialDelayRef,
+    currentContextRef,
+    hasProvider,
+    timeout
+  } = groupContext;
+  const [isInstantPhase, setIsInstantPhase] = (0, import_octane.useState)(false, (0, import_internal.subSlot)(slot, "instant"));
+  const openRef = (0, import_octane.useRef)(open, (0, import_internal.subSlot)(slot, "open"));
+  const isUnmountedRef = (0, import_octane.useRef)(false, (0, import_internal.subSlot)(slot, "unmounted"));
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      openRef.current = open;
+    },
+    [open],
+    (0, import_internal.subSlot)(slot, "l:openRef")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      return () => {
+        isUnmountedRef.current = true;
+      };
+    },
+    [],
+    (0, import_internal.subSlot)(slot, "l:unmount")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      function unset() {
+        if (!isUnmountedRef.current) {
+          setIsInstantPhase(false);
+        }
+        currentContextRef.current?.setIsInstantPhase(false);
+        currentIdRef.current = null;
+        currentContextRef.current = null;
+        delayRef.current = initialDelayRef.current;
+        timeout.clear();
+      }
+      if (!currentIdRef.current) {
+        return void 0;
+      }
+      if (!open && currentIdRef.current === floatingId) {
+        setIsInstantPhase(false);
+        if (timeoutMs) {
+          const closingId = floatingId;
+          timeout.start(timeoutMs, () => {
+            if (store.select("open") || currentIdRef.current && currentIdRef.current !== closingId) {
+              return;
+            }
+            unset();
+          });
+          return () => {
+            if (openRef.current || currentIdRef.current !== closingId) {
+              timeout.clear();
+            }
+          };
+        }
+        unset();
+      }
+      return void 0;
+    },
+    [
+      open,
+      floatingId,
+      currentIdRef,
+      delayRef,
+      timeoutMs,
+      initialDelayRef,
+      currentContextRef,
+      timeout,
+      store
+    ],
+    (0, import_internal.subSlot)(slot, "l:close")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (!open) {
+        return;
+      }
+      const prevContext = currentContextRef.current;
+      const prevId = currentIdRef.current;
+      timeout.clear();
+      currentContextRef.current = { onOpenChange: store.setOpen, setIsInstantPhase };
+      currentIdRef.current = floatingId;
+      delayRef.current = {
+        open: 0,
+        close: (0, import_useHoverShared.getDelay)(initialDelayRef.current, "close")
+      };
+      if (prevId !== null && prevId !== floatingId) {
+        setIsInstantPhase(true);
+        prevContext?.setIsInstantPhase(true);
+        prevContext?.onOpenChange(false, (0, import_createChangeEventDetails.createChangeEventDetails)(import_createChangeEventDetails.REASONS.none));
+      } else {
+        setIsInstantPhase(false);
+        prevContext?.setIsInstantPhase(false);
+      }
+    },
+    [open, floatingId, store, currentIdRef, delayRef, initialDelayRef, currentContextRef, timeout],
+    (0, import_internal.subSlot)(slot, "l:open")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      return () => {
+        if (currentIdRef.current === floatingId) {
+          currentContextRef.current = null;
+          if (!openRef.current) {
+            return;
+          }
+          currentIdRef.current = null;
+          resetDelayRef(delayRef, initialDelayRef);
+          timeout.clear();
+        }
+      };
+    },
+    [currentContextRef, currentIdRef, delayRef, floatingId, initialDelayRef, timeout],
+    (0, import_internal.subSlot)(slot, "l:teardown")
+  );
+  return (0, import_octane.useMemo)(
+    () => ({ hasProvider, delayRef, isInstantPhase }),
+    [hasProvider, delayRef, isInstantPhase],
+    (0, import_internal.subSlot)(slot, "out")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloatingDelayGroup,
+  useDelayGroup
+});