@studiometa/js-toolkit 2.2.0 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studiometa/js-toolkit",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "A set of useful little bits of JavaScript to boost your project! 🚀",
   "publishConfig": {
     "access": "public"

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/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,