@studiometa/js-toolkit 2.0.0-beta.9 → 2.0.0

package/utils/math/ease.cjs

@@ -0,0 +1,88 @@
+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);
+
+// packages/js-toolkit/utils/math/ease.js
+var ease_exports = {};
+__export(ease_exports, {
+  createEaseInOut: () => createEaseInOut,
+  createEaseOut: () => createEaseOut,
+  easeInCirc: () => easeInCirc,
+  easeInCubic: () => easeInCubic,
+  easeInExpo: () => easeInExpo,
+  easeInOutCirc: () => easeInOutCirc,
+  easeInOutCubic: () => easeInOutCubic,
+  easeInOutExpo: () => easeInOutExpo,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutQuart: () => easeInOutQuart,
+  easeInOutQuint: () => easeInOutQuint,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInQuart: () => easeInQuart,
+  easeInQuint: () => easeInQuint,
+  easeInSine: () => easeInSine,
+  easeOutCirc: () => easeOutCirc,
+  easeOutCubic: () => easeOutCubic,
+  easeOutExpo: () => easeOutExpo,
+  easeOutQuad: () => easeOutQuad,
+  easeOutQuart: () => easeOutQuart,
+  easeOutQuint: () => easeOutQuint,
+  easeOutSine: () => easeOutSine
+});
+module.exports = __toCommonJS(ease_exports);
+function createEaseOut(easeIn) {
+  return (progress) => 1 - easeIn(1 - progress);
+}
+function createEaseInOut(easeIn) {
+  return (progress) => progress === 0 ? 0 : progress === 1 ? 1 : progress < 0.5 ? easeIn(progress * 2) / 2 : 1 - easeIn((1 - progress) * 2) / 2;
+}
+function easeInQuad(progress) {
+  return progress ** 2;
+}
+var easeOutQuad = createEaseOut(easeInQuad);
+var easeInOutQuad = createEaseInOut(easeInQuad);
+function easeInCubic(progress) {
+  return progress ** 3;
+}
+var easeOutCubic = createEaseOut(easeInCubic);
+var easeInOutCubic = createEaseInOut(easeInCubic);
+function easeInQuart(progress) {
+  return progress ** 4;
+}
+var easeOutQuart = createEaseOut(easeInQuart);
+var easeInOutQuart = createEaseInOut(easeInQuart);
+function easeInQuint(progress) {
+  return progress ** 5;
+}
+var easeOutQuint = createEaseOut(easeInQuint);
+var easeInOutQuint = createEaseInOut(easeInQuint);
+function easeInSine(progress) {
+  return progress === 1 ? 1 : -Math.cos(progress * Math.PI / 2) + 1;
+}
+var easeOutSine = createEaseOut(easeInSine);
+var easeInOutSine = createEaseInOut(easeInSine);
+function easeInCirc(progress) {
+  return -(Math.sqrt(1 - progress * progress) - 1);
+}
+var easeOutCirc = createEaseOut(easeInCirc);
+var easeInOutCirc = createEaseInOut(easeInCirc);
+function easeInExpo(progress) {
+  return 2 ** (10 * (progress - 1));
+}
+var easeOutExpo = createEaseOut(easeInExpo);
+var easeInOutExpo = createEaseInOut(easeInExpo);
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/ease.d.ts

@@ -12,7 +12,7 @@ export function createEaseOut(easeIn: EasingFunction): EasingFunction;
  * Create an in-out easing function.
  *
  * @param  {EasingFunction} easeIn The ease in function.
- * @return {EasingFunction}        The in-out function.
+ * @returns {EasingFunction}        The in-out function.
  */
 export function createEaseInOut(easeIn: EasingFunction): EasingFunction;
 /**
@@ -23,42 +23,42 @@ export function easeInQuad(progress: number): number;
  * Ease in cubic.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInCubic(progress: number): number;
 /**
  * Ease in quart.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInQuart(progress: number): number;
 /**
  * Ease in quint.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInQuint(progress: number): number;
 /**
  * Ease in sine.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInSine(progress: number): number;
 /**
  * Ease in circ.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInCirc(progress: number): number;
 /**
  * Ease in exponential.
  *
  * @param  {number} progress Progress value betwen 0 and 1.
- * @return {number}          Eased value between 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInExpo(progress: number): number;
 export function easeOutQuad(progress: number): number;

package/utils/math/ease.js

@@ -1,41 +1,66 @@
-export function createEaseOut(easeIn) {
-  return progress => 1 - easeIn(1 - progress);
+function createEaseOut(easeIn) {
+  return (progress) => 1 - easeIn(1 - progress);
 }
-export function createEaseInOut(easeIn) {
-  return progress => progress === 0 ? 0 : progress === 1 ? 1 : progress < 0.5 ? easeIn(progress * 2) / 2 : 1 - easeIn((1 - progress) * 2) / 2;
+function createEaseInOut(easeIn) {
+  return (progress) => progress === 0 ? 0 : progress === 1 ? 1 : progress < 0.5 ? easeIn(progress * 2) / 2 : 1 - easeIn((1 - progress) * 2) / 2;
 }
-export function easeInQuad(progress) {
+function easeInQuad(progress) {
   return progress ** 2;
 }
-export var easeOutQuad = createEaseOut(easeInQuad);
-export var easeInOutQuad = createEaseInOut(easeInQuad);
-export function easeInCubic(progress) {
+const easeOutQuad = createEaseOut(easeInQuad);
+const easeInOutQuad = createEaseInOut(easeInQuad);
+function easeInCubic(progress) {
   return progress ** 3;
 }
-export var easeOutCubic = createEaseOut(easeInCubic);
-export var easeInOutCubic = createEaseInOut(easeInCubic);
-export function easeInQuart(progress) {
+const easeOutCubic = createEaseOut(easeInCubic);
+const easeInOutCubic = createEaseInOut(easeInCubic);
+function easeInQuart(progress) {
   return progress ** 4;
 }
-export var easeOutQuart = createEaseOut(easeInQuart);
-export var easeInOutQuart = createEaseInOut(easeInQuart);
-export function easeInQuint(progress) {
+const easeOutQuart = createEaseOut(easeInQuart);
+const easeInOutQuart = createEaseInOut(easeInQuart);
+function easeInQuint(progress) {
   return progress ** 5;
 }
-export var easeOutQuint = createEaseOut(easeInQuint);
-export var easeInOutQuint = createEaseInOut(easeInQuint);
-export function easeInSine(progress) {
+const easeOutQuint = createEaseOut(easeInQuint);
+const easeInOutQuint = createEaseInOut(easeInQuint);
+function easeInSine(progress) {
   return progress === 1 ? 1 : -Math.cos(progress * Math.PI / 2) + 1;
 }
-export var easeOutSine = createEaseOut(easeInSine);
-export var easeInOutSine = createEaseInOut(easeInSine);
-export function easeInCirc(progress) {
+const easeOutSine = createEaseOut(easeInSine);
+const easeInOutSine = createEaseInOut(easeInSine);
+function easeInCirc(progress) {
   return -(Math.sqrt(1 - progress * progress) - 1);
 }
-export var easeOutCirc = createEaseOut(easeInCirc);
-export var easeInOutCirc = createEaseInOut(easeInCirc);
-export function easeInExpo(progress) {
+const easeOutCirc = createEaseOut(easeInCirc);
+const easeInOutCirc = createEaseInOut(easeInCirc);
+function easeInExpo(progress) {
   return 2 ** (10 * (progress - 1));
 }
-export var easeOutExpo = createEaseOut(easeInExpo);
-export var easeInOutExpo = createEaseInOut(easeInExpo);
+const easeOutExpo = createEaseOut(easeInExpo);
+const easeInOutExpo = createEaseInOut(easeInExpo);
+export {
+  createEaseInOut,
+  createEaseOut,
+  easeInCirc,
+  easeInCubic,
+  easeInExpo,
+  easeInOutCirc,
+  easeInOutCubic,
+  easeInOutExpo,
+  easeInOutQuad,
+  easeInOutQuart,
+  easeInOutQuint,
+  easeInOutSine,
+  easeInQuad,
+  easeInQuart,
+  easeInQuint,
+  easeInSine,
+  easeOutCirc,
+  easeOutCubic,
+  easeOutExpo,
+  easeOutQuad,
+  easeOutQuart,
+  easeOutQuint,
+  easeOutSine
+};

package/utils/math/index.cjs

@@ -0,0 +1,43 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/js-toolkit/utils/math/index.js
+var math_exports = {};
+__export(math_exports, {
+  clamp: () => import_clamp.default,
+  clamp01: () => import_clamp01.default,
+  damp: () => import_damp.default,
+  inertiaFinalValue: () => import_inertiaFinalValue.default,
+  lerp: () => import_lerp.default,
+  map: () => import_map.default,
+  round: () => import_round.default
+});
+module.exports = __toCommonJS(math_exports);
+var import_clamp = __toESM(require("./clamp.cjs"), 1);
+var import_clamp01 = __toESM(require("./clamp01.cjs"), 1);
+var import_damp = __toESM(require("./damp.cjs"), 1);
+var import_inertiaFinalValue = __toESM(require("./inertiaFinalValue.cjs"), 1);
+var import_lerp = __toESM(require("./lerp.cjs"), 1);
+var import_map = __toESM(require("./map.cjs"), 1);
+var import_round = __toESM(require("./round.cjs"), 1);
+__reExport(math_exports, require("./ease.cjs"), module.exports);
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/index.js

@@ -1,8 +1,17 @@
-export { default as clamp } from './clamp.js';
-export { default as clamp01 } from './clamp01.js';
-export { default as damp } from './damp.js';
-export { default as inertiaFinalValue } from './inertiaFinalValue.js';
-export { default as lerp } from './lerp.js';
-export { default as map } from './map.js';
-export { default as round } from './round.js';
-export * from './ease.js';
+import { default as default2 } from "./clamp.js";
+import { default as default3 } from "./clamp01.js";
+import { default as default4 } from "./damp.js";
+import { default as default5 } from "./inertiaFinalValue.js";
+import { default as default6 } from "./lerp.js";
+import { default as default7 } from "./map.js";
+import { default as default8 } from "./round.js";
+export * from "./ease.js";
+export {
+  default2 as clamp,
+  default3 as clamp01,
+  default4 as damp,
+  default5 as inertiaFinalValue,
+  default6 as lerp,
+  default7 as map,
+  default8 as round
+};

package/utils/math/inertiaFinalValue.cjs

@@ -0,0 +1,37 @@
+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);
+
+// packages/js-toolkit/utils/math/inertiaFinalValue.js
+var inertiaFinalValue_exports = {};
+__export(inertiaFinalValue_exports, {
+  default: () => inertiaFinalValue
+});
+module.exports = __toCommonJS(inertiaFinalValue_exports);
+function inertiaFinalValue(initialValue, initialDelta, dampFactor = 0.85) {
+  if (dampFactor >= 1 || dampFactor <= 0) {
+    throw new Error(`The \`factor\` parameter must be a number greater than 0 and smaller than 1, \`${dampFactor}\` given.`);
+  }
+  let delta = initialDelta;
+  let finalValue = initialValue;
+  while (Math.abs(delta) > 0.1) {
+    finalValue += delta;
+    delta *= dampFactor;
+  }
+  return finalValue;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/inertiaFinalValue.d.ts

@@ -1,9 +1,9 @@
 /**
  * Get the final damped value for a given factor.
  *
- * @param  {Number} initialValue The final value.
- * @param  {Number} initialDelta The current value.
- * @param  {Number=} [dampFactor=0.85] The speed to reach the target value.
- * @return {Number} The next value.
+ * @param   {number} initialValue The final value.
+ * @param   {number} initialDelta The current value.
+ * @param   {number} [dampFactor=0.85] The speed to reach the target value.
+ * @returns {number} The next value.
  */
-export default function inertiaFinalValue(initialValue: number, initialDelta: number, dampFactor?: number | undefined): number;
+export default function inertiaFinalValue(initialValue: number, initialDelta: number, dampFactor?: number): number;

package/utils/math/inertiaFinalValue.js

@@ -1,17 +1,15 @@
-export default function inertiaFinalValue(initialValue, initialDelta) {
-  var dampFactor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.85;
-
+function inertiaFinalValue(initialValue, initialDelta, dampFactor = 0.85) {
   if (dampFactor >= 1 || dampFactor <= 0) {
-    throw new Error("The `factor` parameter must be a number greater than 0 and smaller than 1, `".concat(dampFactor, "` given."));
+    throw new Error(`The \`factor\` parameter must be a number greater than 0 and smaller than 1, \`${dampFactor}\` given.`);
   }
-
-  var delta = initialDelta;
-  var finalValue = initialValue;
-
+  let delta = initialDelta;
+  let finalValue = initialValue;
   while (Math.abs(delta) > 0.1) {
     finalValue += delta;
     delta *= dampFactor;
   }
-
   return finalValue;
-}
+}
+export {
+  inertiaFinalValue as default
+};

package/utils/math/lerp.cjs

@@ -0,0 +1,28 @@
+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);
+
+// packages/js-toolkit/utils/math/lerp.js
+var lerp_exports = {};
+__export(lerp_exports, {
+  default: () => lerp
+});
+module.exports = __toCommonJS(lerp_exports);
+function lerp(min, max, ratio) {
+  return (1 - ratio) * min + ratio * max;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/lerp.d.ts

@@ -1,9 +1,9 @@
 /**
  * Interpolate the ratio between a given interval.
  *
- * @param  {Number} min   The interval minimum value.
- * @param  {Number} max   The inverval maximum value.
- * @param  {Number} ratio The ratio to get.
- * @return {Number}       The value between min and max corresponding to ratio.
+ * @param  {number} min   The interval minimum value.
+ * @param  {number} max   The inverval maximum value.
+ * @param  {number} ratio The ratio to get.
+ * @returns {number}       The value between min and max corresponding to ratio.
  */
 export default function lerp(min: number, max: number, ratio: number): number;

package/utils/math/lerp.js

@@ -1,3 +1,6 @@
-export default function lerp(min, max, ratio) {
+function lerp(min, max, ratio) {
   return (1 - ratio) * min + ratio * max;
-}
+}
+export {
+  lerp as default
+};

package/utils/math/map.cjs

@@ -0,0 +1,28 @@
+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);
+
+// packages/js-toolkit/utils/math/map.js
+var map_exports = {};
+__export(map_exports, {
+  default: () => map
+});
+module.exports = __toCommonJS(map_exports);
+function map(value, inputMin, inputMax, outputMin, outputMax) {
+  return (value - inputMin) * (outputMax - outputMin) / (inputMax - inputMin) + outputMin;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/map.d.ts

@@ -1,11 +1,11 @@
 /**
  * Maps the value from one range of [inputMin..inputMax] to another range of [outputMin..outputMax].
  *
- * @param  {Number} value     The value to map.
- * @param  {Number} inputMin  The input's minimum value.
- * @param  {Number} inputMax  The input's maximum value.
- * @param  {Number} outputMin The output's minimum value.
- * @param  {Number} outputMax The output's maximum value.
- * @return {Number}           The input value mapped to the output range.
+ * @param  {number} value     The value to map.
+ * @param  {number} inputMin  The input's minimum value.
+ * @param  {number} inputMax  The input's maximum value.
+ * @param  {number} outputMin The output's minimum value.
+ * @param  {number} outputMax The output's maximum value.
+ * @returns {number}           The input value mapped to the output range.
  */
 export default function map(value: number, inputMin: number, inputMax: number, outputMin: number, outputMax: number): number;

package/utils/math/map.js

@@ -1,3 +1,6 @@
-export default function map(value, inputMin, inputMax, outputMin, outputMax) {
+function map(value, inputMin, inputMax, outputMin, outputMax) {
   return (value - inputMin) * (outputMax - outputMin) / (inputMax - inputMin) + outputMin;
-}
+}
+export {
+  map as default
+};

package/utils/math/round.cjs

@@ -0,0 +1,28 @@
+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);
+
+// packages/js-toolkit/utils/math/round.js
+var round_exports = {};
+__export(round_exports, {
+  default: () => round
+});
+module.exports = __toCommonJS(round_exports);
+function round(value, decimals = 0) {
+  return Number(value.toFixed(decimals));
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/round.d.ts

@@ -1,8 +1,8 @@
 /**
  * Round a value with a given number of decimals.
  *
- * @param  {Number} value The number to round.
- * @param  {Number=} [decimals=0] The number of decimals to keep.
- * @return {Number} A rounded number to the given decimals length.
+ * @param   {number} value The number to round.
+ * @param   {number} [decimals=0] The number of decimals to keep.
+ * @returns {number} A rounded number to the given decimals length.
  */
-export default function round(value: number, decimals?: number | undefined): number;
+export default function round(value: number, decimals?: number): number;

package/utils/math/round.js

@@ -1,4 +1,6 @@
-export default function round(value) {
-  var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function round(value, decimals = 0) {
   return Number(value.toFixed(decimals));
-}
+}
+export {
+  round as default
+};

package/utils/memoize.cjs

@@ -0,0 +1,43 @@
+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);
+
+// packages/js-toolkit/utils/memoize.js
+var memoize_exports = {};
+__export(memoize_exports, {
+  default: () => memoize
+});
+module.exports = __toCommonJS(memoize_exports);
+function memoize(fn, { maxAge = Number.POSITIVE_INFINITY, cacheKey = JSON.stringify, cache = /* @__PURE__ */ new Map() } = {}) {
+  return function memoized(...args) {
+    const key = cacheKey(args);
+    const date = Date.now();
+    if (cache.has(key)) {
+      const cached = cache.get(key);
+      if (date - cached.date < maxAge) {
+        return cached.data;
+      }
+    }
+    const data = fn(...args);
+    cache.set(key, {
+      data,
+      date: Date.now()
+    });
+    return data;
+  };
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/memoize.d.ts

@@ -15,7 +15,7 @@
  * @template {(...args:any) => any} T
  * @param  {T} fn
  * @param  {MemorizeOptions} options
- * @return {(...args:Parameters<T>) => ReturnType<T>}
+ * @returns {(...args:Parameters<T>) => ReturnType<T>}
  */
 export default function memoize<T extends (...args: any) => any>(fn: T, { maxAge, cacheKey, cache }?: MemorizeOptions): (...args: Parameters<T>) => ReturnType<T>;
 export type MemorizeCache = {

package/utils/memoize.js

@@ -1,30 +1,21 @@
-export default function memoize(fn) {
-  var {
-    maxAge = Number.POSITIVE_INFINITY,
-    cacheKey = JSON.stringify,
-    cache = new Map()
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return function memoized() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-
-    var key = cacheKey(args);
-    var date = Date.now();
-
+function memoize(fn, { maxAge = Number.POSITIVE_INFINITY, cacheKey = JSON.stringify, cache = /* @__PURE__ */ new Map() } = {}) {
+  return function memoized(...args) {
+    const key = cacheKey(args);
+    const date = Date.now();
     if (cache.has(key)) {
-      var cached = cache.get(key);
-
+      const cached = cache.get(key);
       if (date - cached.date < maxAge) {
         return cached.data;
       }
     }
-
-    var data = fn(...args);
+    const data = fn(...args);
     cache.set(key, {
       data,
       date: Date.now()
     });
     return data;
   };
-}
+}
+export {
+  memoize as default
+};