@studiometa/js-toolkit 2.2.0-alpha.0 → 2.2.1

package/Base/managers/EventsManager.cjs

@@ -35,21 +35,34 @@ module.exports = __toCommonJS(EventsManager_exports);
 var import_getAllProperties = __toESM(require("../../utils/object/getAllProperties.cjs"), 1);
 var import_AbstractManager = __toESM(require("./AbstractManager.cjs"), 1);
 var import_RefsManager = require("./RefsManager.cjs");
+var names = /* @__PURE__ */ new Map();
 function normalizeName(name) {
-  return name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim();
+  if (!names.has(name)) {
+    names.set(name, name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim());
+  }
+  return names.get(name);
 }
+var eventNames = /* @__PURE__ */ new Map();
 function normalizeEventName(name) {
-  return name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "");
+  if (!eventNames.has(name)) {
+    eventNames.set(name, name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, ""));
+  }
+  return eventNames.get(name);
+}
+var regexes = /* @__PURE__ */ new Map();
+function getRegex(regex) {
+  if (!regexes.has(regex)) {
+    regexes.set(regex, new RegExp(regex));
+  }
+  return regexes.get(regex);
 }
 function __getEventNameByMethod(that, method, name = "") {
-  const normalizedName = normalizeName(name);
-  const regex = new RegExp(`^on${normalizedName}([A-Z].*)$`);
+  const regex = getRegex(`^on${normalizeName(name)}([A-Z].*)$`);
   const [, event] = method.match(regex);
   return normalizeEventName(event);
 }
 function __getEventMethodsByName(that, name = "") {
-  const normalizedName = normalizeName(name);
-  const regex = new RegExp(`^on${normalizedName}[A-Z].*$`);
+  const regex = getRegex(`^on${normalizeName(name)}[A-Z].*$`);
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
   if (!methods) {

package/Base/managers/EventsManager.d.ts

@@ -1,7 +1,3 @@
-/**
- * @typedef {import('../index.js').default} Base
- * @typedef {import('./ChildrenManager.js').default} ChildrenManager
- */
 /**
  * Normalize the given name to PascalCase, such as:
  *

package/Base/managers/EventsManager.js

@@ -7,21 +7,34 @@ var __publicField = (obj, key, value) => {
 import getAllProperties from "../../utils/object/getAllProperties.js";
 import AbstractManager from "./AbstractManager.js";
 import { normalizeRefName } from "./RefsManager.js";
+const names = /* @__PURE__ */ new Map();
 function normalizeName(name) {
-  return name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim();
+  if (!names.has(name)) {
+    names.set(name, name.replace(/[A-Z]([A-Z].*)/g, (c) => c.toLowerCase()).replace(/[^a-zA-Z\d\s:]/g, " ").replace(/(^\w|\s+\w)/g, (c) => c.trim().toUpperCase()).trim());
+  }
+  return names.get(name);
 }
+const eventNames = /* @__PURE__ */ new Map();
 function normalizeEventName(name) {
-  return name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "");
+  if (!eventNames.has(name)) {
+    eventNames.set(name, name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, ""));
+  }
+  return eventNames.get(name);
+}
+const regexes = /* @__PURE__ */ new Map();
+function getRegex(regex) {
+  if (!regexes.has(regex)) {
+    regexes.set(regex, new RegExp(regex));
+  }
+  return regexes.get(regex);
 }
 function __getEventNameByMethod(that, method, name = "") {
-  const normalizedName = normalizeName(name);
-  const regex = new RegExp(`^on${normalizedName}([A-Z].*)$`);
+  const regex = getRegex(`^on${normalizeName(name)}([A-Z].*)$`);
   const [, event] = method.match(regex);
   return normalizeEventName(event);
 }
 function __getEventMethodsByName(that, name = "") {
-  const normalizedName = normalizeName(name);
-  const regex = new RegExp(`^on${normalizedName}[A-Z].*$`);
+  const regex = getRegex(`^on${normalizeName(name)}[A-Z].*$`);
   const key = regex.toString();
   let methods = that.__methodsCache.get(key);
   if (!methods) {

package/Base/managers/OptionsManager.cjs

@@ -76,12 +76,12 @@ function __register(that, name, config) {
 }
 var OptionsManager = class extends import_AbstractManager.default {
   constructor(base) {
+    var _a, _b;
     super(base);
     __publicField(this, "__values", {});
     __publicField(this, "name", "Base");
     __publicField(this, "debug", false);
     __publicField(this, "log", false);
-    var _a, _b;
     this.__hideProperties(["__values", "__defaultValues"]);
     const schema = this.__config.options || {};
     this.name = this.__config.name;

package/Base/managers/OptionsManager.js

@@ -49,12 +49,12 @@ function __register(that, name, config) {
 }
 class OptionsManager extends AbstractManager {
   constructor(base) {
+    var _a, _b;
     super(base);
     __publicField(this, "__values", {});
     __publicField(this, "name", "Base");
     __publicField(this, "debug", false);
     __publicField(this, "log", false);
-    var _a, _b;
     this.__hideProperties(["__values", "__defaultValues"]);
     const schema = this.__config.options || {};
     this.name = this.__config.name;

package/decorators/withVue2.cjs

@@ -31,9 +31,9 @@ var withVue2_default = (BaseClass, Vue) => {
   var _a, _b, _c;
   return _c = class extends BaseClass {
     constructor(element) {
+      var _a2;
       super(element);
       __publicField(this, "$vue");
-      var _a2;
       const vueConfig = (_a2 = this.vueConfig) != null ? _a2 : this.constructor.vueConfig;
       if (!vueConfig) {
         throw new Error("[withVue] You must define a `vueConfig` object.");

package/decorators/withVue2.js

@@ -8,9 +8,9 @@ var withVue2_default = (BaseClass, Vue) => {
   var _a, _b, _c;
   return _c = class extends BaseClass {
     constructor(element) {
+      var _a2;
       super(element);
       __publicField(this, "$vue");
-      var _a2;
       const vueConfig = (_a2 = this.vueConfig) != null ? _a2 : this.constructor.vueConfig;
       if (!vueConfig) {
         throw new Error("[withVue] You must define a `vueConfig` object.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studiometa/js-toolkit",
-  "version": "2.2.0-alpha.0",
+  "version": "2.2.1",
   "description": "A set of useful little bits of JavaScript to boost your project! 🚀",
   "publishConfig": {
     "access": "public"
@@ -39,7 +39,7 @@
     "toolkit"
   ],
   "dependencies": {
-    "@motionone/easing": "^10.8.0",
+    "@motionone/easing": "^10.9.0",
     "deepmerge": "^4.2.2"
   }
 }

package/utils/css/animate.d.ts

@@ -1,21 +1,20 @@
 /**
  * @typedef {import('./transform.js').TransformProps} TransformProps
- * @typedef {import('../math/ease.js').EasingFunction} EasingFn
  * @typedef {[number, number, number, number]} BezierCurve
  * @typedef {{
  *   duration?: number;
- *   easing?: EasingFn|BezierCurve;
+ *   easing?: import('../math/createEases.js').EasingFunction|BezierCurve;
  *   onProgress?: (progress: number, easedProgress: number) => void;
  *   onFinish?: (progress: number, easedProgress: number) => void;
  *  }} Options
  * @typedef {TransformProps & {
  *   opacity?: number;
  *   transformOrigin?: string;
- *   easing?: EasingFn|BezierCurve;
+ *   easing?: import('../math/createEases.js').EasingFunction|BezierCurve;
  *   offset?: number;
  * }} Keyframe
  * @typedef {Keyframe & {
- *   easing: EasingFn;
+ *   easing: import('../math/createEases.js').EasingFunction;
  *   offset: number;
  * }} NormalizedKeyframe
  * @typedef {{
@@ -35,17 +34,16 @@
  */
 export function animate(element: HTMLElement, keyframes: Keyframe[], options?: Options): Animate;
 export type TransformProps = import('./transform.js').TransformProps;
-export type EasingFn = import('../math/ease.js').EasingFunction;
 export type BezierCurve = [number, number, number, number];
 export type Options = Options;
 export type Keyframe = TransformProps & {
     opacity?: number;
     transformOrigin?: string;
-    easing?: EasingFn | [number, number, number, number];
+    easing?: import('../math/createEases.js').EasingFunction | [number, number, number, number];
     offset?: number;
 };
 export type NormalizedKeyframe = Keyframe & {
-    easing: EasingFn;
+    easing: import('../math/createEases.js').EasingFunction;
     offset: number;
 };
 export type Animate = {

package/utils/css/transition.cjs

@@ -31,7 +31,7 @@ __export(transition_exports, {
   setClassesOrStyles: () => setClassesOrStyles
 });
 module.exports = __toCommonJS(transition_exports);
-var import_nextFrame = __toESM(require("../nextFrame.cjs"), 1);
+var import_nextFrame = require("../nextFrame.cjs");
 var classes = __toESM(require("./classes.cjs"), 1);
 var styles = __toESM(require("./styles.cjs"), 1);
 var cache = /* @__PURE__ */ new WeakMap();
@@ -67,11 +67,11 @@ async function start(element, classesOrStyles) {
   const trs = Transition.getInstance(element);
   trs.isTransitioning = true;
   setClassesOrStyles(element, classesOrStyles.from);
-  await (0, import_nextFrame.default)();
-  await (0, import_nextFrame.default)();
+  await (0, import_nextFrame.nextFrame)();
+  await (0, import_nextFrame.nextFrame)();
   setClassesOrStyles(element, classesOrStyles.active);
-  await (0, import_nextFrame.default)();
-  await (0, import_nextFrame.default)();
+  await (0, import_nextFrame.nextFrame)();
+  await (0, import_nextFrame.nextFrame)();
 }
 async function next(element, classesOrStyles) {
   const hasTransition = testTransition(element);
@@ -83,7 +83,7 @@ async function next(element, classesOrStyles) {
     }
     setClassesOrStyles(element, classesOrStyles.from, "remove");
     setClassesOrStyles(element, classesOrStyles.to);
-    await (0, import_nextFrame.default)();
+    await (0, import_nextFrame.nextFrame)();
     if (!hasTransition) {
       resolve();
     }

package/utils/css/transition.js

@@ -4,7 +4,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-import nextFrame from "../nextFrame.js";
+import { nextFrame } from "../nextFrame.js";
 import * as classes from "./classes.js";
 import * as styles from "./styles.js";
 const cache = /* @__PURE__ */ new WeakMap();

package/utils/index.cjs

@@ -31,7 +31,7 @@ __export(utils_exports, {
   isFunction: () => import_isFunction.default,
   keyCodes: () => import_keyCodes.default,
   memoize: () => import_memoize.default,
-  nextFrame: () => import_nextFrame.default,
+  nextFrame: () => import_nextFrame.nextFrame,
   nextMicrotask: () => import_nextMicrotask.default,
   nextTick: () => import_nextTick.default,
   objectToURLSearchParams: () => import_history.objectToURLSearchParams,
@@ -43,7 +43,7 @@ var import_debounce = __toESM(require("./debounce.cjs"), 1);
 var import_focusTrap = __toESM(require("./focusTrap.cjs"), 1);
 var import_keyCodes = __toESM(require("./keyCodes.cjs"), 1);
 var import_memoize = __toESM(require("./memoize.cjs"), 1);
-var import_nextFrame = __toESM(require("./nextFrame.cjs"), 1);
+var import_nextFrame = require("./nextFrame.cjs");
 var import_nextTick = __toESM(require("./nextTick.cjs"), 1);
 var import_nextMicrotask = __toESM(require("./nextMicrotask.cjs"), 1);
 var import_throttle = __toESM(require("./throttle.cjs"), 1);

package/utils/index.d.ts

@@ -2,7 +2,7 @@ export { default as debounce } from "./debounce.js";
 export { default as focusTrap } from "./focusTrap.js";
 export { default as keyCodes } from "./keyCodes.js";
 export { default as memoize } from "./memoize.js";
-export { default as nextFrame } from "./nextFrame.js";
+export { nextFrame } from "./nextFrame.js";
 export { default as nextTick } from "./nextTick.js";
 export { default as nextMicrotask } from "./nextMicrotask.js";
 export { default as throttle } from "./throttle.js";

package/utils/index.js

@@ -2,13 +2,13 @@ import { default as default2 } from "./debounce.js";
 import { default as default3 } from "./focusTrap.js";
 import { default as default4 } from "./keyCodes.js";
 import { default as default5 } from "./memoize.js";
-import { default as default6 } from "./nextFrame.js";
-import { default as default7 } from "./nextTick.js";
-import { default as default8 } from "./nextMicrotask.js";
-import { default as default9 } from "./throttle.js";
-import { default as default10 } from "./scrollTo.js";
-import { default as default11 } from "./isDefined.js";
-import { default as default12 } from "./isFunction.js";
+import { nextFrame } from "./nextFrame.js";
+import { default as default6 } from "./nextTick.js";
+import { default as default7 } from "./nextMicrotask.js";
+import { default as default8 } from "./throttle.js";
+import { default as default9 } from "./scrollTo.js";
+import { default as default10 } from "./isDefined.js";
+import { default as default11 } from "./isFunction.js";
 export * from "./css/index.js";
 import {
   objectToURLSearchParams,
@@ -24,14 +24,14 @@ export {
   default3 as focusTrap,
   push as historyPush,
   replace as historyReplace,
-  default11 as isDefined,
-  default12 as isFunction,
+  default10 as isDefined,
+  default11 as isFunction,
   default4 as keyCodes,
   default5 as memoize,
-  default6 as nextFrame,
-  default8 as nextMicrotask,
-  default7 as nextTick,
+  nextFrame,
+  default7 as nextMicrotask,
+  default6 as nextTick,
   objectToURLSearchParams,
-  default10 as scrollTo,
-  default9 as throttle
+  default9 as scrollTo,
+  default8 as throttle
 };

package/utils/math/createEases.cjs

@@ -0,0 +1,32 @@
+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/createEases.js
+var createEases_exports = {};
+__export(createEases_exports, {
+  createEaseInOut: () => createEaseInOut,
+  createEaseOut: () => createEaseOut
+});
+module.exports = __toCommonJS(createEases_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;
+}
+if (module.exports.default) module.exports = module.exports.default;

package/utils/math/createEases.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @typedef {(progress: number) => number} EasingFunction
+ */
+/**
+ * Create an out easing function.
+ *
+ * @param   {EasingFunction} easeIn The ease in function.
+ * @returns {EasingFunction}        The out function.
+ */
+export function createEaseOut(easeIn: EasingFunction): EasingFunction;
+/**
+ * Create an in-out easing function.
+ *
+ * @param  {EasingFunction} easeIn The ease in function.
+ * @returns {EasingFunction}        The in-out function.
+ */
+export function createEaseInOut(easeIn: EasingFunction): EasingFunction;
+export type EasingFunction = (progress: number) => number;

package/utils/math/createEases.js

@@ -0,0 +1,10 @@
+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;
+}
+export {
+  createEaseInOut,
+  createEaseOut
+};

package/utils/math/ease.cjs

@@ -19,8 +19,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/js-toolkit/utils/math/ease.js
 var ease_exports = {};
 __export(ease_exports, {
-  createEaseInOut: () => createEaseInOut,
-  createEaseOut: () => createEaseOut,
   easeInCirc: () => easeInCirc,
   easeInCubic: () => easeInCubic,
   easeInExpo: () => easeInExpo,
@@ -44,45 +42,40 @@ __export(ease_exports, {
   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;
-}
+var import_createEases = require("./createEases.cjs");
 function easeInQuad(progress) {
   return progress ** 2;
 }
-var easeOutQuad = createEaseOut(easeInQuad);
-var easeInOutQuad = createEaseInOut(easeInQuad);
+var easeOutQuad = (0, import_createEases.createEaseOut)(easeInQuad);
+var easeInOutQuad = (0, import_createEases.createEaseInOut)(easeInQuad);
 function easeInCubic(progress) {
   return progress ** 3;
 }
-var easeOutCubic = createEaseOut(easeInCubic);
-var easeInOutCubic = createEaseInOut(easeInCubic);
+var easeOutCubic = (0, import_createEases.createEaseOut)(easeInCubic);
+var easeInOutCubic = (0, import_createEases.createEaseInOut)(easeInCubic);
 function easeInQuart(progress) {
   return progress ** 4;
 }
-var easeOutQuart = createEaseOut(easeInQuart);
-var easeInOutQuart = createEaseInOut(easeInQuart);
+var easeOutQuart = (0, import_createEases.createEaseOut)(easeInQuart);
+var easeInOutQuart = (0, import_createEases.createEaseInOut)(easeInQuart);
 function easeInQuint(progress) {
   return progress ** 5;
 }
-var easeOutQuint = createEaseOut(easeInQuint);
-var easeInOutQuint = createEaseInOut(easeInQuint);
+var easeOutQuint = (0, import_createEases.createEaseOut)(easeInQuint);
+var easeInOutQuint = (0, import_createEases.createEaseInOut)(easeInQuint);
 function easeInSine(progress) {
   return progress === 1 ? 1 : -Math.cos(progress * Math.PI / 2) + 1;
 }
-var easeOutSine = createEaseOut(easeInSine);
-var easeInOutSine = createEaseInOut(easeInSine);
+var easeOutSine = (0, import_createEases.createEaseOut)(easeInSine);
+var easeInOutSine = (0, import_createEases.createEaseInOut)(easeInSine);
 function easeInCirc(progress) {
   return -(Math.sqrt(1 - progress * progress) - 1);
 }
-var easeOutCirc = createEaseOut(easeInCirc);
-var easeInOutCirc = createEaseInOut(easeInCirc);
+var easeOutCirc = (0, import_createEases.createEaseOut)(easeInCirc);
+var easeInOutCirc = (0, import_createEases.createEaseInOut)(easeInCirc);
 function easeInExpo(progress) {
   return 2 ** (10 * (progress - 1));
 }
-var easeOutExpo = createEaseOut(easeInExpo);
-var easeInOutExpo = createEaseInOut(easeInExpo);
+var easeOutExpo = (0, import_createEases.createEaseOut)(easeInExpo);
+var easeInOutExpo = (0, import_createEases.createEaseInOut)(easeInExpo);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/math/ease.d.ts

@@ -1,22 +1,6 @@
 /**
- * @typedef {(progress: number) => number} EasingFunction
- */
-/**
- * Create an out easing function.
- *
- * @param   {EasingFunction} easeIn The ease in function.
- * @returns {EasingFunction}        The out function.
- */
-export function createEaseOut(easeIn: EasingFunction): EasingFunction;
-/**
- * Create an in-out easing function.
- *
- * @param  {EasingFunction} easeIn The ease in function.
- * @returns {EasingFunction}        The in-out function.
- */
-export function createEaseInOut(easeIn: EasingFunction): EasingFunction;
-/**
- * @type {EasingFunction}
+ * @param  {number} progress Progress value betwen 0 and 1.
+ * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInQuad(progress: number): number;
 /**
@@ -61,18 +45,17 @@ export function easeInCirc(progress: number): number;
  * @returns {number}          Eased value between 0 and 1.
  */
 export function easeInExpo(progress: number): number;
-export function easeOutQuad(progress: number): number;
-export function easeInOutQuad(progress: number): number;
-export function easeOutCubic(progress: number): number;
-export function easeInOutCubic(progress: number): number;
-export function easeOutQuart(progress: number): number;
-export function easeInOutQuart(progress: number): number;
-export function easeOutQuint(progress: number): number;
-export function easeInOutQuint(progress: number): number;
-export function easeOutSine(progress: number): number;
-export function easeInOutSine(progress: number): number;
-export function easeOutCirc(progress: number): number;
-export function easeInOutCirc(progress: number): number;
-export function easeOutExpo(progress: number): number;
-export function easeInOutExpo(progress: number): number;
-export type EasingFunction = (progress: number) => number;
+export const easeOutQuad: import("./createEases.js").EasingFunction;
+export const easeInOutQuad: import("./createEases.js").EasingFunction;
+export const easeOutCubic: import("./createEases.js").EasingFunction;
+export const easeInOutCubic: import("./createEases.js").EasingFunction;
+export const easeOutQuart: import("./createEases.js").EasingFunction;
+export const easeInOutQuart: import("./createEases.js").EasingFunction;
+export const easeOutQuint: import("./createEases.js").EasingFunction;
+export const easeInOutQuint: import("./createEases.js").EasingFunction;
+export const easeOutSine: import("./createEases.js").EasingFunction;
+export const easeInOutSine: import("./createEases.js").EasingFunction;
+export const easeOutCirc: import("./createEases.js").EasingFunction;
+export const easeInOutCirc: import("./createEases.js").EasingFunction;
+export const easeOutExpo: import("./createEases.js").EasingFunction;
+export const easeInOutExpo: import("./createEases.js").EasingFunction;

package/utils/math/ease.js

@@ -1,9 +1,4 @@
-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;
-}
+import { createEaseOut, createEaseInOut } from "./createEases.js";
 function easeInQuad(progress) {
   return progress ** 2;
 }
@@ -40,8 +35,6 @@ function easeInExpo(progress) {
 const easeOutExpo = createEaseOut(easeInExpo);
 const easeInOutExpo = createEaseInOut(easeInExpo);
 export {
-  createEaseInOut,
-  createEaseOut,
   easeInCirc,
   easeInCubic,
   easeInExpo,

package/utils/math/index.cjs

@@ -42,4 +42,5 @@ var import_map = __toESM(require("./map.cjs"), 1);
 var import_round = __toESM(require("./round.cjs"), 1);
 __reExport(math_exports, require("./ease.cjs"), module.exports);
 var ease = __toESM(require("./ease.cjs"), 1);
+__reExport(math_exports, require("./createEases.cjs"), module.exports);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/math/index.d.ts

@@ -6,4 +6,5 @@ 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";
+export * from "./createEases.js";
 export * as ease from "./ease.js";

package/utils/math/index.js

@@ -7,6 +7,7 @@ import { default as default7 } from "./map.js";
 import { default as default8 } from "./round.js";
 export * from "./ease.js";
 import * as ease from "./ease.js";
+export * from "./createEases.js";
 export {
   default2 as clamp,
   default3 as clamp01,

package/utils/nextFrame.cjs

@@ -19,9 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/js-toolkit/utils/nextFrame.js
 var nextFrame_exports = {};
 __export(nextFrame_exports, {
-  default: () => nextFrame,
   getCancelRaf: () => getCancelRaf,
-  getRaf: () => getRaf
+  getRaf: () => getRaf,
+  nextFrame: () => nextFrame
 });
 module.exports = __toCommonJS(nextFrame_exports);
 function getRaf() {

package/utils/nextFrame.d.ts

@@ -24,4 +24,4 @@ export function getCancelRaf(): (id: number) => void;
  * console.log('hello world');
  * ```
  */
-export default function nextFrame<T extends () => any>(fn?: T): Promise<T extends Function ? ReturnType<T> : undefined>;
+export function nextFrame<T extends () => any>(fn?: T): Promise<T extends Function ? ReturnType<T> : undefined>;

package/utils/nextFrame.js

@@ -10,7 +10,7 @@ function nextFrame(fn) {
   });
 }
 export {
-  nextFrame as default,
   getCancelRaf,
-  getRaf
+  getRaf,
+  nextFrame
 };

package/utils/scheduler.cjs

@@ -27,6 +27,7 @@ function getScheduler(steps) {
   const stepsFns = {};
   const api = {};
   let isScheduled = false;
+  const resolvedPromise = Promise.resolve();
   function run(tasks) {
     let task;
     while (task = tasks.shift()) {
@@ -47,7 +48,7 @@ function getScheduler(steps) {
       return;
     }
     isScheduled = true;
-    requestAnimationFrame(flush);
+    resolvedPromise.then(flush);
   }
   steps.forEach((step) => {
     stepsFns[step] = [];
@@ -59,7 +60,8 @@ function getScheduler(steps) {
   return api;
 }
 var instances = /* @__PURE__ */ new Map();
-function useScheduler(steps = ["read", "write"]) {
+var domSchedulerSteps = ["read", "write", "afterWrite"];
+function useScheduler(steps = domSchedulerSteps) {
   const key = steps.join("-");
   if (instances.has(key)) {
     return instances.get(key);
@@ -68,5 +70,5 @@ function useScheduler(steps = ["read", "write"]) {
   instances.set(key, scheduler);
   return scheduler;
 }
-var domScheduler = useScheduler(["read", "write", "afterWrite"]);
+var domScheduler = useScheduler(domSchedulerSteps);
 if (module.exports.default) module.exports = module.exports.default;

package/utils/scheduler.js

@@ -2,6 +2,7 @@ function getScheduler(steps) {
   const stepsFns = {};
   const api = {};
   let isScheduled = false;
+  const resolvedPromise = Promise.resolve();
   function run(tasks) {
     let task;
     while (task = tasks.shift()) {
@@ -22,7 +23,7 @@ function getScheduler(steps) {
       return;
     }
     isScheduled = true;
-    requestAnimationFrame(flush);
+    resolvedPromise.then(flush);
   }
   steps.forEach((step) => {
     stepsFns[step] = [];
@@ -34,7 +35,8 @@ function getScheduler(steps) {
   return api;
 }
 const instances = /* @__PURE__ */ new Map();
-function useScheduler(steps = ["read", "write"]) {
+const domSchedulerSteps = ["read", "write", "afterWrite"];
+function useScheduler(steps = domSchedulerSteps) {
   const key = steps.join("-");
   if (instances.has(key)) {
     return instances.get(key);
@@ -43,7 +45,7 @@ function useScheduler(steps = ["read", "write"]) {
   instances.set(key, scheduler);
   return scheduler;
 }
-const domScheduler = useScheduler(["read", "write", "afterWrite"]);
+const domScheduler = useScheduler(domSchedulerSteps);
 export {
   domScheduler,
   useScheduler