@spark-ui/hooks 11.1.0 → 11.1.2

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [11.1.2](https://github.com/leboncoin/spark-web/compare/v11.1.1...v11.1.2) (2025-10-31)
+
+**Note:** Version bump only for package @spark-ui/hooks
+
+## [11.1.1](https://github.com/leboncoin/spark-web/compare/v11.1.0...v11.1.1) (2025-10-30)
+
+**Note:** Version bump only for package @spark-ui/hooks
+
 # [11.1.0](https://github.com/leboncoin/spark-web/compare/v11.0.1...v11.1.0) (2025-10-29)
 
 **Note:** Version bump only for package @spark-ui/hooks

package/dist/use-combined-state/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This hook must be used when a component has both a controlled and uncontrolled mode.
+ * It will take care of updating the state value when a controlled mode (prop) is updated.
+ */
+declare function useCombinedState<T>(controlledValue?: T, defaultValue?: T, onChange?: (nextValue: T) => void): [
+    T | undefined,
+    (newValue: T, forceFlag?: (prev: T, next: T) => boolean) => void,
+    boolean,
+    T | undefined
+];
+
+export { useCombinedState };

package/dist/use-combined-state/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/use-combined-state/index.ts
+var use_combined_state_exports = {};
+__export(use_combined_state_exports, {
+  useCombinedState: () => useCombinedState
+});
+module.exports = __toCommonJS(use_combined_state_exports);
+
+// src/use-combined-state/useCombinedState.tsx
+var import_lodash = __toESM(require("lodash.isequal"));
+var import_react = require("react");
+function useCombinedState(controlledValue, defaultValue, onChange) {
+  const isControlled = controlledValue !== void 0;
+  const { current: initialValue } = (0, import_react.useRef)(isControlled ? controlledValue : defaultValue);
+  const [innerValue, setInnerValue] = (0, import_react.useState)(defaultValue);
+  const value = isControlled ? controlledValue : innerValue;
+  const updater = (0, import_react.useCallback)(
+    (next, shouldUpdateProp = (prevValue, nextValue) => !(0, import_lodash.default)(prevValue, nextValue)) => {
+      const nextValue = typeof next !== "function" ? next : next(value);
+      const shouldUpdate = shouldUpdateProp(value, nextValue);
+      if (shouldUpdate && !isControlled) {
+        setInnerValue(nextValue);
+      }
+      onChange && onChange(nextValue);
+    },
+    [isControlled, value, onChange]
+  );
+  return [value, updater, isControlled, initialValue];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCombinedState
+});
+//# sourceMappingURL=index.js.map

package/dist/use-combined-state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/use-combined-state/index.ts","../../src/use-combined-state/useCombinedState.tsx"],"sourcesContent":["export { useCombinedState } from './useCombinedState'\n","import isEqual from 'lodash.isequal'\nimport { SetStateAction, useCallback, useRef, useState } from 'react'\n\n/**\n * This hook must be used when a component has both a controlled and uncontrolled mode.\n * It will take care of updating the state value when a controlled mode (prop) is updated.\n */\nexport function useCombinedState<T>(\n  controlledValue?: T,\n  defaultValue?: T,\n  onChange?: (nextValue: T) => void\n): [\n  T | undefined,\n  (newValue: T, forceFlag?: (prev: T, next: T) => boolean) => void,\n  boolean,\n  T | undefined,\n] {\n  const isControlled = controlledValue !== undefined\n  const { current: initialValue } = useRef(isControlled ? controlledValue : defaultValue)\n\n  const [innerValue, setInnerValue] = useState(defaultValue as T)\n  const value = isControlled ? (controlledValue as T) : innerValue\n\n  const updater = useCallback(\n    (\n      next: SetStateAction<T>,\n      shouldUpdateProp = (prevValue: T, nextValue: T) => !isEqual(prevValue, nextValue)\n    ) => {\n      const nextValue = typeof next !== 'function' ? next : (next as (value: T) => T)(value)\n      const shouldUpdate = shouldUpdateProp(value, nextValue)\n      if (shouldUpdate && !isControlled) {\n        setInnerValue(nextValue)\n      }\n      onChange && onChange(nextValue)\n    },\n    [isControlled, value, onChange]\n  )\n\n  return [value, updater, isControlled, initialValue]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,oBAAoB;AACpB,mBAA8D;AAMvD,SAAS,iBACd,iBACA,cACA,UAMA;AACA,QAAM,eAAe,oBAAoB;AACzC,QAAM,EAAE,SAAS,aAAa,QAAI,qBAAO,eAAe,kBAAkB,YAAY;AAEtF,QAAM,CAAC,YAAY,aAAa,QAAI,uBAAS,YAAiB;AAC9D,QAAM,QAAQ,eAAgB,kBAAwB;AAEtD,QAAM,cAAU;AAAA,IACd,CACE,MACA,mBAAmB,CAAC,WAAc,cAAiB,KAAC,cAAAA,SAAQ,WAAW,SAAS,MAC7E;AACH,YAAM,YAAY,OAAO,SAAS,aAAa,OAAQ,KAAyB,KAAK;AACrF,YAAM,eAAe,iBAAiB,OAAO,SAAS;AACtD,UAAI,gBAAgB,CAAC,cAAc;AACjC,sBAAc,SAAS;AAAA,MACzB;AACA,kBAAY,SAAS,SAAS;AAAA,IAChC;AAAA,IACA,CAAC,cAAc,OAAO,QAAQ;AAAA,EAChC;AAEA,SAAO,CAAC,OAAO,SAAS,cAAc,YAAY;AACpD;","names":["isEqual"]}

package/dist/use-merge-refs/index.d.ts

@@ -0,0 +1,7 @@
+import { Ref, RefCallback } from 'react';
+
+declare function assignRef<T>(ref: Ref<T> | null | undefined, value: T): void;
+declare function mergeRefs<T>(...refs: (Ref<T> | undefined)[]): RefCallback<T>;
+declare function useMergeRefs<T>(...refs: (Ref<T> | undefined)[]): RefCallback<T>;
+
+export { assignRef, mergeRefs, useMergeRefs };

package/dist/use-merge-refs/index.js

@@ -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);
+
+// src/use-merge-refs/index.ts
+var use_merge_refs_exports = {};
+__export(use_merge_refs_exports, {
+  assignRef: () => assignRef,
+  mergeRefs: () => mergeRefs,
+  useMergeRefs: () => useMergeRefs
+});
+module.exports = __toCommonJS(use_merge_refs_exports);
+
+// src/use-merge-refs/useMergeRefs.tsx
+var import_react = require("react");
+function assignRef(ref, value) {
+  if (ref == null) {
+    return;
+  }
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  try {
+    ;
+    ref.current = value;
+  } catch {
+    throw new Error(`Cannot assign value '${value}' to ref '${ref}'`);
+  }
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => assignRef(ref, value));
+  };
+}
+function useMergeRefs(...refs) {
+  return (0, import_react.useMemo)(() => mergeRefs(...refs), refs);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignRef,
+  mergeRefs,
+  useMergeRefs
+});
+//# sourceMappingURL=index.js.map

package/dist/use-merge-refs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/use-merge-refs/index.ts","../../src/use-merge-refs/useMergeRefs.tsx"],"sourcesContent":["export { useMergeRefs, assignRef, mergeRefs } from './useMergeRefs'\n","import { Ref, RefCallback, RefObject, useMemo } from 'react'\n\nexport function assignRef<T>(ref: Ref<T> | null | undefined, value: T) {\n  if (ref == null) {\n    return\n  }\n\n  if (typeof ref === 'function') {\n    ref(value)\n\n    return\n  }\n\n  try {\n    ;(ref as RefObject<T | null>).current = value\n  } catch {\n    throw new Error(`Cannot assign value '${value}' to ref '${ref}'`)\n  }\n}\n\nexport function mergeRefs<T>(...refs: (Ref<T> | undefined)[]): RefCallback<T> {\n  return value => {\n    refs.forEach(ref => assignRef(ref, value))\n  }\n}\n\nexport function useMergeRefs<T>(...refs: (Ref<T> | undefined)[]) {\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  return useMemo(() => mergeRefs(...refs), refs)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAAqD;AAE9C,SAAS,UAAa,KAAgC,OAAU;AACrE,MAAI,OAAO,MAAM;AACf;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ,YAAY;AAC7B,QAAI,KAAK;AAET;AAAA,EACF;AAEA,MAAI;AACF;AAAC,IAAC,IAA4B,UAAU;AAAA,EAC1C,QAAQ;AACN,UAAM,IAAI,MAAM,wBAAwB,KAAK,aAAa,GAAG,GAAG;AAAA,EAClE;AACF;AAEO,SAAS,aAAgB,MAA8C;AAC5E,SAAO,WAAS;AACd,SAAK,QAAQ,SAAO,UAAU,KAAK,KAAK,CAAC;AAAA,EAC3C;AACF;AAEO,SAAS,gBAAmB,MAA8B;AAE/D,aAAO,sBAAQ,MAAM,UAAU,GAAG,IAAI,GAAG,IAAI;AAC/C;","names":[]}

package/dist/use-mounted-state/index.d.ts

@@ -0,0 +1,3 @@
+declare function useMountedState(): () => boolean;
+
+export { useMountedState };

package/dist/use-mounted-state/index.js

@@ -0,0 +1,44 @@
+"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);
+
+// src/use-mounted-state/index.ts
+var use_mounted_state_exports = {};
+__export(use_mounted_state_exports, {
+  useMountedState: () => useMountedState
+});
+module.exports = __toCommonJS(use_mounted_state_exports);
+
+// src/use-mounted-state/useMountedState.tsx
+var import_react = require("react");
+function useMountedState() {
+  const mountedRef = (0, import_react.useRef)(false);
+  const get = (0, import_react.useCallback)(() => mountedRef.current, []);
+  (0, import_react.useEffect)(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  return get;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMountedState
+});
+//# sourceMappingURL=index.js.map

package/dist/use-mounted-state/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/use-mounted-state/index.ts","../../src/use-mounted-state/useMountedState.tsx"],"sourcesContent":["export { useMountedState } from './useMountedState'\n","import { useCallback, useEffect, useRef } from 'react'\n\nexport function useMountedState(): () => boolean {\n  const mountedRef = useRef(false)\n  const get = useCallback(() => mountedRef.current, [])\n\n  useEffect(() => {\n    mountedRef.current = true\n\n    return () => {\n      mountedRef.current = false\n    }\n  }, [])\n\n  return get\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAA+C;AAExC,SAAS,kBAAiC;AAC/C,QAAM,iBAAa,qBAAO,KAAK;AAC/B,QAAM,UAAM,0BAAY,MAAM,WAAW,SAAS,CAAC,CAAC;AAEpD,8BAAU,MAAM;AACd,eAAW,UAAU;AAErB,WAAO,MAAM;AACX,iBAAW,UAAU;AAAA,IACvB;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;","names":[]}

package/dist/use-scroll-overflow/index.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+
+interface ScrollOverflow {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+declare function useScrollOverflow(scrollRef: RefObject<HTMLElement | null>, 
+/**
+ * Tolerance threshold for floating-point precision issues.
+ * Values below this threshold are considered as "no overflow" to handle sub-pixel rendering artifacts.
+ */
+{ precisionTreshold }?: {
+    precisionTreshold?: number;
+}): ScrollOverflow;
+
+export { type ScrollOverflow, useScrollOverflow };

package/dist/use-scroll-overflow/index.js

@@ -0,0 +1,73 @@
+"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);
+
+// src/use-scroll-overflow/index.ts
+var use_scroll_overflow_exports = {};
+__export(use_scroll_overflow_exports, {
+  useScrollOverflow: () => useScrollOverflow
+});
+module.exports = __toCommonJS(use_scroll_overflow_exports);
+
+// src/use-scroll-overflow/useScrollOverflow.tsx
+var import_react = require("react");
+function useScrollOverflow(scrollRef, { precisionTreshold = 0 } = {}) {
+  const [overflow, setOverflow] = (0, import_react.useState)({
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0
+  });
+  (0, import_react.useEffect)(() => {
+    const checkScrollContent = () => {
+      const scrollElement2 = scrollRef.current;
+      if (scrollElement2) {
+        const { scrollTop, scrollHeight, clientHeight, scrollLeft, scrollWidth, clientWidth } = scrollElement2;
+        const applyPrecision = (value) => {
+          return value <= precisionTreshold ? 0 : value;
+        };
+        const rightOverflow = scrollWidth - (scrollLeft + clientWidth);
+        const bottomOverflow = scrollHeight - (scrollTop + clientHeight);
+        setOverflow({
+          top: applyPrecision(scrollTop),
+          bottom: applyPrecision(bottomOverflow),
+          left: applyPrecision(scrollLeft),
+          right: applyPrecision(rightOverflow)
+        });
+      }
+    };
+    checkScrollContent();
+    const scrollElement = scrollRef.current;
+    if (scrollElement) {
+      scrollElement.addEventListener("scroll", checkScrollContent);
+      window.addEventListener("resize", checkScrollContent);
+    }
+    return () => {
+      if (scrollElement) {
+        scrollElement.removeEventListener("scroll", checkScrollContent);
+        window.removeEventListener("resize", checkScrollContent);
+      }
+    };
+  }, [scrollRef]);
+  return overflow;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useScrollOverflow
+});
+//# sourceMappingURL=index.js.map

package/dist/use-scroll-overflow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/use-scroll-overflow/index.ts","../../src/use-scroll-overflow/useScrollOverflow.tsx"],"sourcesContent":["export { useScrollOverflow } from './useScrollOverflow'\n\nexport type { ScrollOverflow } from './useScrollOverflow'\n","import { RefObject, useEffect, useState } from 'react'\n\nexport interface ScrollOverflow {\n  top: number\n  bottom: number\n  left: number\n  right: number\n}\n\nexport function useScrollOverflow(\n  scrollRef: RefObject<HTMLElement | null>,\n  /**\n   * Tolerance threshold for floating-point precision issues.\n   * Values below this threshold are considered as \"no overflow\" to handle sub-pixel rendering artifacts.\n   */\n  { precisionTreshold = 0 }: { precisionTreshold?: number } = {}\n): ScrollOverflow {\n  const [overflow, setOverflow] = useState<ScrollOverflow>({\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n  })\n\n  useEffect(() => {\n    const checkScrollContent = () => {\n      const scrollElement = scrollRef.current\n\n      if (scrollElement) {\n        const { scrollTop, scrollHeight, clientHeight, scrollLeft, scrollWidth, clientWidth } =\n          scrollElement\n\n        const applyPrecision = (value: number): number => {\n          return value <= precisionTreshold ? 0 : value\n        }\n\n        const rightOverflow = scrollWidth - (scrollLeft + clientWidth)\n        const bottomOverflow = scrollHeight - (scrollTop + clientHeight)\n\n        setOverflow({\n          top: applyPrecision(scrollTop),\n          bottom: applyPrecision(bottomOverflow),\n          left: applyPrecision(scrollLeft),\n          right: applyPrecision(rightOverflow),\n        })\n      }\n    }\n\n    checkScrollContent()\n\n    const scrollElement = scrollRef.current\n    if (scrollElement) {\n      scrollElement.addEventListener('scroll', checkScrollContent)\n      window.addEventListener('resize', checkScrollContent)\n    }\n\n    return () => {\n      if (scrollElement) {\n        scrollElement.removeEventListener('scroll', checkScrollContent)\n        window.removeEventListener('resize', checkScrollContent)\n      }\n    }\n  }, [scrollRef])\n\n  return overflow\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAA+C;AASxC,SAAS,kBACd,WAKA,EAAE,oBAAoB,EAAE,IAAoC,CAAC,GAC7C;AAChB,QAAM,CAAC,UAAU,WAAW,QAAI,uBAAyB;AAAA,IACvD,KAAK;AAAA,IACL,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,EACT,CAAC;AAED,8BAAU,MAAM;AACd,UAAM,qBAAqB,MAAM;AAC/B,YAAMA,iBAAgB,UAAU;AAEhC,UAAIA,gBAAe;AACjB,cAAM,EAAE,WAAW,cAAc,cAAc,YAAY,aAAa,YAAY,IAClFA;AAEF,cAAM,iBAAiB,CAAC,UAA0B;AAChD,iBAAO,SAAS,oBAAoB,IAAI;AAAA,QAC1C;AAEA,cAAM,gBAAgB,eAAe,aAAa;AAClD,cAAM,iBAAiB,gBAAgB,YAAY;AAEnD,oBAAY;AAAA,UACV,KAAK,eAAe,SAAS;AAAA,UAC7B,QAAQ,eAAe,cAAc;AAAA,UACrC,MAAM,eAAe,UAAU;AAAA,UAC/B,OAAO,eAAe,aAAa;AAAA,QACrC,CAAC;AAAA,MACH;AAAA,IACF;AAEA,uBAAmB;AAEnB,UAAM,gBAAgB,UAAU;AAChC,QAAI,eAAe;AACjB,oBAAc,iBAAiB,UAAU,kBAAkB;AAC3D,aAAO,iBAAiB,UAAU,kBAAkB;AAAA,IACtD;AAEA,WAAO,MAAM;AACX,UAAI,eAAe;AACjB,sBAAc,oBAAoB,UAAU,kBAAkB;AAC9D,eAAO,oBAAoB,UAAU,kBAAkB;AAAA,MACzD;AAAA,IACF;AAAA,EACF,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO;AACT;","names":["scrollElement"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spark-ui/hooks",
-  "version": "11.1.0",
+  "version": "11.1.2",
   "description": "Common hooks for Spark UI",
   "exports": {
     "./*": {
@@ -49,5 +49,5 @@
   },
   "homepage": "https://sparkui.vercel.app",
   "license": "MIT",
-  "gitHead": "abb3e63f1ffc9dcea0740c5bd9604197e0b4b671"
+  "gitHead": "66cc5f71af5198553d00742b71847d85e4119a40"
 }

package/tsup.config.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'tsup'
 export default defineConfig(() => {
   return {
     entryPoints: ['src/*/index.(ts|tsx)'],
-    format: ['esm'],
+    format: ['cjs', 'esm'],
     dts: true,
     sourcemap: true,
     external: ['react'],