@octanejs/radix 0.1.32 → 0.1.33

package/dist/cjs/scroll-lock.cjs

@@ -0,0 +1,67 @@
+"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 scroll_lock_exports = {};
+__export(scroll_lock_exports, {
+  useScrollLock: () => useScrollLock
+});
+module.exports = __toCommonJS(scroll_lock_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+let lockCount = 0;
+let originalOverflow = "";
+let originalPaddingRight = "";
+function lockBody() {
+  if (lockCount === 0) {
+    const body = document.body;
+    originalOverflow = body.style.overflow;
+    originalPaddingRight = body.style.paddingRight;
+    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    if (scrollbarWidth > 0) {
+      const computedPadding = parseInt(getComputedStyle(body).paddingRight, 10) || 0;
+      body.style.paddingRight = `${computedPadding + scrollbarWidth}px`;
+    }
+    body.style.overflow = "hidden";
+  }
+  lockCount++;
+}
+function unlockBody() {
+  lockCount = Math.max(0, lockCount - 1);
+  if (lockCount === 0) {
+    document.body.style.overflow = originalOverflow;
+    document.body.style.paddingRight = originalPaddingRight;
+  }
+}
+function useScrollLock(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useScrollLock");
+  const enabled = user[0] ?? true;
+  (0, import_octane.useEffect)(
+    () => {
+      if (!enabled) return;
+      lockBody();
+      return unlockBody;
+    },
+    [enabled],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useScrollLock
+});

package/dist/cjs/use-callback-ref.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 use_callback_ref_exports = {};
+__export(use_callback_ref_exports, {
+  useCallbackRef: () => useCallbackRef
+});
+module.exports = __toCommonJS(use_callback_ref_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function useCallbackRef(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useCallbackRef");
+  const callback = user[0];
+  const callbackRef = (0, import_octane.useRef)(callback, (0, import_internal.subSlot)(slot, "ref"));
+  (0, import_octane.useEffect)(
+    () => {
+      callbackRef.current = callback;
+    },
+    void 0,
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return (0, import_octane.useMemo)(
+    () => ((...fnArgs) => callbackRef.current?.(...fnArgs)),
+    [],
+    (0, import_internal.subSlot)(slot, "m")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCallbackRef
+});

package/dist/cjs/use-effect-event.cjs

@@ -0,0 +1,52 @@
+"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_effect_event_exports = {};
+__export(use_effect_event_exports, {
+  useEffectEvent: () => useEffectEvent
+});
+module.exports = __toCommonJS(use_effect_event_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function useEffectEvent(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useEffectEvent");
+  const callback = user[0];
+  const ref = (0, import_octane.useRef)(
+    () => {
+      throw new Error("Cannot call an event handler while rendering.");
+    },
+    (0, import_internal.subSlot)(slot, "ref")
+  );
+  (0, import_octane.useInsertionEffect)(
+    () => {
+      ref.current = callback;
+    },
+    void 0,
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return (0, import_octane.useMemo)(
+    () => ((...fnArgs) => ref.current?.(...fnArgs)),
+    [],
+    (0, import_internal.subSlot)(slot, "m")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEffectEvent
+});

package/dist/cjs/use-is-hydrated.cjs

@@ -0,0 +1,43 @@
+"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_is_hydrated_exports = {};
+__export(use_is_hydrated_exports, {
+  useIsHydrated: () => useIsHydrated
+});
+module.exports = __toCommonJS(use_is_hydrated_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function subscribe() {
+  return () => {
+  };
+}
+function useIsHydrated(...args) {
+  const [, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useIsHydrated");
+  return (0, import_octane.useSyncExternalStore)(
+    subscribe,
+    () => true,
+    () => false,
+    (0, import_internal.subSlot)(slot, "s")
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIsHydrated
+});

package/dist/cjs/use-previous.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 use_previous_exports = {};
+__export(use_previous_exports, {
+  usePrevious: () => usePrevious
+});
+module.exports = __toCommonJS(use_previous_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function previousCommittedValue(current, previous) {
+  return previous === void 0 ? current : previous.source;
+}
+const PREVIOUS_VALUE_OPTIONS = {
+  sourceEqual: (previous, next) => previous === next
+};
+function usePrevious(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("usePrevious");
+  const value = user[0];
+  const [previous] = (0, import_octane.useLinkedState)(
+    value,
+    previousCommittedValue,
+    PREVIOUS_VALUE_OPTIONS,
+    (0, import_internal.subSlot)(slot, "previous")
+  );
+  return previous;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePrevious
+});

package/dist/cjs/use-size.cjs

@@ -0,0 +1,69 @@
+"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_size_exports = {};
+__export(use_size_exports, {
+  useSize: () => useSize
+});
+module.exports = __toCommonJS(use_size_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function useSize(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useSize");
+  const element = user[0];
+  const [size, setSize] = (0, import_octane.useState)(
+    void 0,
+    (0, import_internal.subSlot)(slot, "size")
+  );
+  (0, import_octane.useLayoutEffect)(
+    () => {
+      if (element) {
+        setSize({ width: element.offsetWidth, height: element.offsetHeight });
+        if (typeof ResizeObserver === "undefined") return;
+        const resizeObserver = new ResizeObserver((entries) => {
+          if (!Array.isArray(entries) || !entries.length) return;
+          const entry = entries[0];
+          let width;
+          let height;
+          if ("borderBoxSize" in entry) {
+            const borderSizeEntry = entry["borderBoxSize"];
+            const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+            width = borderSize["inlineSize"];
+            height = borderSize["blockSize"];
+          } else {
+            width = element.offsetWidth;
+            height = element.offsetHeight;
+          }
+          setSize({ width, height });
+        });
+        resizeObserver.observe(element, { box: "border-box" });
+        return () => resizeObserver.unobserve(element);
+      } else {
+        setSize(void 0);
+      }
+    },
+    [element],
+    (0, import_internal.subSlot)(slot, "e")
+  );
+  return size;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSize
+});

package/dist/cjs/useControllableState.cjs

@@ -0,0 +1,80 @@
+"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 useControllableState_exports = {};
+__export(useControllableState_exports, {
+  useControllableState: () => useControllableState
+});
+module.exports = __toCommonJS(useControllableState_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function useControllableState(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useControllableState");
+  const { prop, defaultProp, onChange } = user[0] ?? {};
+  const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState(
+    defaultProp,
+    onChange,
+    slot
+  );
+  const isControlled = prop !== void 0;
+  const value = isControlled ? prop : uncontrolledProp;
+  const setValue = (0, import_octane.useCallback)(
+    ((nextValue) => {
+      if (isControlled) {
+        const resolved = isFunction(nextValue) ? nextValue(prop) : nextValue;
+        if (resolved !== prop) onChangeRef.current?.(resolved);
+      } else {
+        setUncontrolledProp(nextValue);
+      }
+    }),
+    [isControlled, prop, setUncontrolledProp],
+    (0, import_internal.subSlot)(slot, "setValue")
+  );
+  return [value, setValue];
+}
+function useUncontrolledState(defaultProp, onChange, slot) {
+  const [value, setValue] = (0, import_octane.useState)(defaultProp, (0, import_internal.subSlot)(slot, "state"));
+  const prevValueRef = (0, import_octane.useRef)(value, (0, import_internal.subSlot)(slot, "prev"));
+  const onChangeRef = (0, import_octane.useRef)(onChange, (0, import_internal.subSlot)(slot, "onChangeRef"));
+  (0, import_octane.useInsertionEffect)(
+    () => {
+      onChangeRef.current = onChange;
+    },
+    [onChange],
+    (0, import_internal.subSlot)(slot, "onChangeEffect")
+  );
+  (0, import_octane.useEffect)(
+    () => {
+      if (prevValueRef.current !== value) {
+        onChangeRef.current?.(value);
+        prevValueRef.current = value;
+      }
+    },
+    [value],
+    (0, import_internal.subSlot)(slot, "changeEffect")
+  );
+  return [value, setValue, onChangeRef];
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useControllableState
+});

package/dist/cjs/useId.cjs

@@ -0,0 +1,36 @@
+"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 useId_exports = {};
+__export(useId_exports, {
+  useId: () => useId
+});
+module.exports = __toCommonJS(useId_exports);
+var import_octane = require("octane");
+var import_internal = require("./internal.cjs");
+function useId(...args) {
+  const [user, slotArg] = (0, import_internal.splitSlot)(args);
+  const slot = slotArg ?? (0, import_internal.S)("useId");
+  const deterministicId = user[0];
+  const id = (0, import_octane.useId)(slot);
+  return deterministicId || `radix-${id}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useId
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/radix",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -32,17 +32,23 @@
   "types": "src/index.ts",
   "files": [
     "src",
-    "README.md"
+    "README.md",
+    "dist/cjs"
   ],
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./src/index.ts"
+    }
   },
   "dependencies": {
     "aria-hidden": "^1.2.6",
-    "@octanejs/floating-ui": "0.1.32"
+    "@octanejs/floating-ui": "0.1.33"
   },
   "peerDependencies": {
-    "octane": "0.1.33"
+    "octane": "0.1.34"
   },
   "devDependencies": {
     "@tsrx/react": "^0.2.56",
@@ -51,9 +57,10 @@
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "vitest": "^4.1.10",
-    "octane": "0.1.33"
+    "octane": "0.1.34"
   },
   "scripts": {
-    "test": "vitest run"
+    "test": "vitest run",
+    "build:cjs": "node ../../scripts/build-package-commonjs.mjs"
   }
 }