animejs 4.2.0-beta.0 → 4.2.0

package/dist/modules/draggable/draggable.cjs

@@ -17,8 +17,8 @@ var timer = require('../timer/timer.cjs');
 var animation = require('../animation/animation.cjs');
 var composition = require('../animation/composition.cjs');
 var animatable = require('../animatable/animatable.cjs');
-var eases = require('../easings/eases.cjs');
-var spring = require('../spring/spring.cjs');
+var parser = require('../easings/eases/parser.cjs');
+var index = require('../easings/spring/index.cjs');
 var target = require('../utils/target.cjs');
 
 /**
@@ -40,7 +40,7 @@ var target = require('../utils/target.cjs');
 /**
  * @import {
  *   Spring,
- * } from '../spring/spring.js'
+ * } from '../easings/spring/index.js'
 */
 
 /**
@@ -178,7 +178,7 @@ class Draggable {
     const trigger = parameters.trigger;
     const modifier = parameters.modifier;
     const ease = parameters.releaseEase;
-    const customEase = ease && eases.parseEase(ease);
+    const customEase = ease && parser.parseEase(ease);
     const hasSpring = !helpers.isUnd(ease) && !helpers.isUnd(/** @type {Spring} */(ease).ease);
     const xProp = /** @type {String} */(helpers.isObj(paramX) && !helpers.isUnd(/** @type {Object} */(paramX).mapTo) ? /** @type {Object} */(paramX).mapTo : 'translateX');
     const yProp = /** @type {String} */(helpers.isObj(paramY) && !helpers.isUnd(/** @type {Object} */(paramY).mapTo) ? /** @type {Object} */(paramY).mapTo : 'translateY');
@@ -218,19 +218,19 @@ class Draggable {
     /** @type {Boolean|DraggableCursorParams} */
     this.cursor = false;
     /** @type {Spring} */
-    this.releaseXSpring = hasSpring ? /** @type {Spring} */(ease) : spring.createSpring({
+    this.releaseXSpring = hasSpring ? /** @type {Spring} */(ease) : index.spring({
       mass: values.setValue(parameters.releaseMass, 1),
       stiffness: values.setValue(parameters.releaseStiffness, 80),
       damping: values.setValue(parameters.releaseDamping, 20),
     });
     /** @type {Spring} */
-    this.releaseYSpring = hasSpring ? /** @type {Spring} */(ease) : spring.createSpring({
+    this.releaseYSpring = hasSpring ? /** @type {Spring} */(ease) : index.spring({
       mass: values.setValue(parameters.releaseMass, 1),
       stiffness: values.setValue(parameters.releaseStiffness, 80),
       damping: values.setValue(parameters.releaseDamping, 20),
     });
     /** @type {EasingFunction} */
-    this.releaseEase = customEase || eases.eases.outQuint;
+    this.releaseEase = customEase || parser.eases.outQuint;
     /** @type {Boolean} */
     this.hasReleaseSpring = hasSpring;
     /** @type {Callback<this>} */
@@ -753,7 +753,7 @@ class Draggable {
    * @param {EasingParam} [ease]
    * @return {this}
    */
-  scrollInView(duration, gap = 0, ease = eases.eases.inOutQuad) {
+  scrollInView(duration, gap = 0, ease = parser.eases.inOutQuad) {
     this.updateScrollCoords();
     const x = this.destX;
     const y = this.destY;
@@ -796,7 +796,7 @@ class Draggable {
    * @param  {EasingParam} [ease]
    * @return {this}
    */
-  animateInView(duration, gap = 0, ease = eases.eases.inOutQuad) {
+  animateInView(duration, gap = 0, ease = parser.eases.inOutQuad) {
     this.stop();
     this.updateBoundingValues();
     const x = this.x;
@@ -877,7 +877,7 @@ class Draggable {
         cursor: /** @type {DraggableCursorParams} */(this.cursor).onGrab
       });
     }
-    this.scrollInView(100, 0, eases.eases.out(3));
+    this.scrollInView(100, 0, parser.eases.out(3));
     this.onGrab(this);
 
     consts.doc.addEventListener('touchmove', this);
@@ -941,8 +941,8 @@ class Draggable {
       this.$trigger.addEventListener('touchmove', preventDefault, { passive: false });
       this.$trigger.addEventListener('touchend', preventDefault);
 
-
-      if ((!this.disabled[0] && helpers.abs(movedX) > 3) || (!this.disabled[1] && helpers.abs(movedY) > 3)) {
+      // Don't check for a miminim distance move if already dragging
+      if (this.dragged || (!this.disabled[0] && helpers.abs(movedX) > 3) || (!this.disabled[1] && helpers.abs(movedY) > 3)) {
 
         this.updateTicker.resume();
         this.pointer[2] = this.pointer[0];
@@ -1008,8 +1008,8 @@ class Draggable {
       const directionX = dx === cr ? cx > cr ? -1 : 1 : cx < cl ? -1 : 1;
       const distanceX = helpers.round(cx - dx, 0);
       springX.velocity = disabledY && hasReleaseSpring ? distanceX ? (ds * directionX) / helpers.abs(distanceX) : 0 : pv;
-      const { ease, duration, restDuration } = springX;
-      durationX = cx === dx ? 0 : hasReleaseSpring ? duration : duration - (restDuration * globals.globals.timeScale);
+      const { ease, settlingDuration, restDuration } = springX;
+      durationX = cx === dx ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.globals.timeScale);
       if (hasReleaseSpring) easeX = ease;
       if (durationX > longestReleaseDuration) longestReleaseDuration = durationX;
     }
@@ -1018,8 +1018,8 @@ class Draggable {
       const directionY = dy === cb ? cy > cb ? -1 : 1 : cy < ct ? -1 : 1;
       const distanceY = helpers.round(cy - dy, 0);
       springY.velocity = disabledX && hasReleaseSpring ? distanceY ? (ds * directionY) / helpers.abs(distanceY) : 0 : pv;
-      const { ease, duration, restDuration } = springY;
-      durationY = cy === dy ? 0 : hasReleaseSpring ? duration : duration - (restDuration * globals.globals.timeScale);
+      const { ease, settlingDuration, restDuration } = springY;
+      durationY = cy === dy ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.globals.timeScale);
       if (hasReleaseSpring) easeY = ease;
       if (durationY > longestReleaseDuration) longestReleaseDuration = durationY;
     }

package/dist/modules/draggable/draggable.d.ts

@@ -206,7 +206,7 @@ export class Draggable {
 }
 export function createDraggable(target: TargetsParam, parameters?: DraggableParams): Draggable;
 import type { DraggableCursorParams } from '../types/index.js';
-import type { Spring } from '../spring/spring.js';
+import type { Spring } from '../easings/spring/index.js';
 import type { EasingFunction } from '../types/index.js';
 import type { Callback } from '../types/index.js';
 import type { AnimatableObject } from '../types/index.js';

package/dist/modules/draggable/draggable.js

@@ -15,8 +15,8 @@ import { Timer } from '../timer/timer.js';
 import { JSAnimation } from '../animation/animation.js';
 import { removeTargetsFromRenderable } from '../animation/composition.js';
 import { Animatable } from '../animatable/animatable.js';
-import { parseEase, eases } from '../easings/eases.js';
-import { createSpring } from '../spring/spring.js';
+import { parseEase, eases } from '../easings/eases/parser.js';
+import { spring } from '../easings/spring/index.js';
 import { get, set } from '../utils/target.js';
 
 /**
@@ -38,7 +38,7 @@ import { get, set } from '../utils/target.js';
 /**
  * @import {
  *   Spring,
- * } from '../spring/spring.js'
+ * } from '../easings/spring/index.js'
 */
 
 /**
@@ -216,13 +216,13 @@ class Draggable {
     /** @type {Boolean|DraggableCursorParams} */
     this.cursor = false;
     /** @type {Spring} */
-    this.releaseXSpring = hasSpring ? /** @type {Spring} */(ease) : createSpring({
+    this.releaseXSpring = hasSpring ? /** @type {Spring} */(ease) : spring({
       mass: setValue(parameters.releaseMass, 1),
       stiffness: setValue(parameters.releaseStiffness, 80),
       damping: setValue(parameters.releaseDamping, 20),
     });
     /** @type {Spring} */
-    this.releaseYSpring = hasSpring ? /** @type {Spring} */(ease) : createSpring({
+    this.releaseYSpring = hasSpring ? /** @type {Spring} */(ease) : spring({
       mass: setValue(parameters.releaseMass, 1),
       stiffness: setValue(parameters.releaseStiffness, 80),
       damping: setValue(parameters.releaseDamping, 20),
@@ -939,8 +939,8 @@ class Draggable {
       this.$trigger.addEventListener('touchmove', preventDefault, { passive: false });
       this.$trigger.addEventListener('touchend', preventDefault);
 
-
-      if ((!this.disabled[0] && abs(movedX) > 3) || (!this.disabled[1] && abs(movedY) > 3)) {
+      // Don't check for a miminim distance move if already dragging
+      if (this.dragged || (!this.disabled[0] && abs(movedX) > 3) || (!this.disabled[1] && abs(movedY) > 3)) {
 
         this.updateTicker.resume();
         this.pointer[2] = this.pointer[0];
@@ -1006,8 +1006,8 @@ class Draggable {
       const directionX = dx === cr ? cx > cr ? -1 : 1 : cx < cl ? -1 : 1;
       const distanceX = round(cx - dx, 0);
       springX.velocity = disabledY && hasReleaseSpring ? distanceX ? (ds * directionX) / abs(distanceX) : 0 : pv;
-      const { ease, duration, restDuration } = springX;
-      durationX = cx === dx ? 0 : hasReleaseSpring ? duration : duration - (restDuration * globals.timeScale);
+      const { ease, settlingDuration, restDuration } = springX;
+      durationX = cx === dx ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.timeScale);
       if (hasReleaseSpring) easeX = ease;
       if (durationX > longestReleaseDuration) longestReleaseDuration = durationX;
     }
@@ -1016,8 +1016,8 @@ class Draggable {
       const directionY = dy === cb ? cy > cb ? -1 : 1 : cy < ct ? -1 : 1;
       const distanceY = round(cy - dy, 0);
       springY.velocity = disabledX && hasReleaseSpring ? distanceY ? (ds * directionY) / abs(distanceY) : 0 : pv;
-      const { ease, duration, restDuration } = springY;
-      durationY = cy === dy ? 0 : hasReleaseSpring ? duration : duration - (restDuration * globals.timeScale);
+      const { ease, settlingDuration, restDuration } = springY;
+      durationY = cy === dy ? 0 : hasReleaseSpring ? settlingDuration : settlingDuration - (restDuration * globals.timeScale);
       if (hasReleaseSpring) easeY = ease;
       if (durationY > longestReleaseDuration) longestReleaseDuration = durationY;
     }

package/dist/modules/easings/{cubic-bezier.cjs → cubic-bezier/index.cjs}

@@ -7,13 +7,13 @@
 
 'use strict';
 
-var helpers = require('../core/helpers.cjs');
-var none = require('./none.cjs');
+var helpers = require('../../core/helpers.cjs');
+var none = require('../none.cjs');
 
 /**
  * @import {
  *   EasingFunction,
- * } from '../types/index.js'
+ * } from '../../types/index.js'
 */
 
 /**

package/dist/modules/easings/{cubic-bezier.d.ts → cubic-bezier/index.d.ts}

@@ -1,2 +1,2 @@
 export function cubicBezier(mX1?: number, mY1?: number, mX2?: number, mY2?: number): EasingFunction;
-import type { EasingFunction } from '../types/index.js';
+import type { EasingFunction } from '../../types/index.js';

package/dist/modules/easings/{cubic-bezier.js → cubic-bezier/index.js}

@@ -5,13 +5,13 @@
  * @copyright 2025 - Julian Garnier
  */
 
-import { abs } from '../core/helpers.js';
-import { none } from './none.js';
+import { abs } from '../../core/helpers.js';
+import { none } from '../none.js';
 
 /**
  * @import {
  *   EasingFunction,
- * } from '../types/index.js'
+ * } from '../../types/index.js'
 */
 
 /**

package/dist/modules/easings/eases/index.cjs

@@ -0,0 +1,14 @@
+/**
+ * Anime.js - easings - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var parser = require('./parser.cjs');
+
+
+
+exports.eases = parser.eases;

package/dist/modules/easings/eases/index.d.ts

@@ -0,0 +1 @@
+export { eases } from "./parser.js";

package/dist/modules/{spring → easings/eases}/index.js

@@ -1,8 +1,8 @@
 /**
- * Anime.js - spring - ESM
+ * Anime.js - easings - ESM
  * @version v4.2.0
  * @license MIT
  * @copyright 2025 - Julian Garnier
  */
 
-export { Spring, createSpring } from './spring.js';
+export { eases } from './parser.js';

package/dist/modules/easings/{eases.cjs → eases/parser.cjs}

@@ -7,14 +7,9 @@
 
 'use strict';
 
-var consts = require('../core/consts.cjs');
-var helpers = require('../core/helpers.cjs');
-var parser = require('./parser.cjs');
-var none = require('./none.cjs');
-var cubicBezier = require('./cubic-bezier.cjs');
-var steps = require('./steps.cjs');
-var linear = require('./linear.cjs');
-var irregular = require('./irregular.cjs');
+var consts = require('../../core/consts.cjs');
+var helpers = require('../../core/helpers.cjs');
+var none = require('../none.cjs');
 
 /**
  * @import {
@@ -24,9 +19,27 @@ var irregular = require('./irregular.cjs');
  *   BackEasing,
  *   ElasticEasing,
  *   PowerEasing,
- * } from '../types/index.js'
+ * } from '../../types/index.js'
 */
 
+
+/** @type {PowerEasing} */
+const easeInPower = (p = 1.68) => t => helpers.pow(t, +p);
+
+/**
+ * @callback EaseType
+ * @param {EasingFunction} Ease
+ * @return {EasingFunction}
+ */
+
+/** @type {Record<String, EaseType>} */
+const easeTypes = {
+  in: easeIn => t => easeIn(t),
+  out: easeIn => t => 1 - easeIn(1 - t),
+  inOut: easeIn => t => t < .5 ? easeIn(t * 2) / 2 : 1 - easeIn(t * -2 + 2) / 2,
+  outIn: easeIn => t => t < .5 ? (1 - easeIn(1 - t * 2)) / 2 : (easeIn(t * 2 - 1) + 1) / 2,
+};
+
 /**
  * Easing functions adapted and simplified from https://robertpenner.com/easing/
  * (c) 2001 Robert Penner
@@ -37,11 +50,11 @@ const doublePI = helpers.PI * 2;
 
 /** @type {Record<String, EasingFunctionWithParams|EasingFunction>} */
 const easeInFunctions = {
-  [consts.emptyString]: parser.easeInPower,
-  Quad: parser.easeInPower(2),
-  Cubic: parser.easeInPower(3),
-  Quart: parser.easeInPower(4),
-  Quint: parser.easeInPower(5),
+  [consts.emptyString]: easeInPower,
+  Quad: easeInPower(2),
+  Cubic: easeInPower(3),
+  Quart: easeInPower(4),
+  Quint: easeInPower(5),
   /** @type {EasingFunction} */
   Sine: t => 1 - helpers.cos(t * halfPI),
   /** @type {EasingFunction} */
@@ -55,7 +68,7 @@ const easeInFunctions = {
     return 1 / helpers.pow(4, 3 - b) - 7.5625 * helpers.pow((pow2 * 3 - 2) / 22 - t, 2);
   },
   /** @type {BackEasing} */
-  Back: (overshoot = 1.70158) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
+  Back: (overshoot = 1.7) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
   /** @type {ElasticEasing} */
   Elastic: (amplitude = 1, period = .3) => {
     const a = helpers.clamp(+amplitude, 1, 10);
@@ -68,10 +81,8 @@ const easeInFunctions = {
 
 /**
  * @typedef  {Object} EasesFunctions
- * @property {typeof linear} linear
- * @property {typeof irregular} irregular
- * @property {typeof steps} steps
- * @property {typeof cubicBezier} cubicBezier
+ * @property {typeof none} linear
+ * @property {typeof none} none
  * @property {PowerEasing} in
  * @property {PowerEasing} out
  * @property {PowerEasing} inOut
@@ -119,11 +130,11 @@ const easeInFunctions = {
  */
 
 const eases = (/*#__PURE__ */ (() => {
-  const list = { linear: linear.linear, irregular: irregular.irregular, steps: steps.steps, cubicBezier: cubicBezier.cubicBezier };
-  for (let type in parser.easeTypes) {
+  const list = { linear: none.none, none: none.none };
+  for (let type in easeTypes) {
     for (let name in easeInFunctions) {
       const easeIn = easeInFunctions[name];
-      const easeType = parser.easeTypes[type];
+      const easeType = easeTypes[type];
       list[type + name] = /** @type {EasingFunctionWithParams|EasingFunction} */(
         name === consts.emptyString || name === 'Back' || name === 'Elastic' ?
         (a, b) => easeType(/** @type {EasingFunctionWithParams} */(easeIn)(a, b)) :
@@ -135,15 +146,46 @@ const eases = (/*#__PURE__ */ (() => {
 })());
 
 /** @type {Record<String, EasingFunction>} */
-const JSEasesLookups = { linear: none.none };
+const easesLookups = { linear: none.none, none: none.none };
+
+/**
+ * @param  {String} string
+ * @return {EasingFunction}
+ */
+const parseEaseString = (string) => {
+  if (easesLookups[string]) return easesLookups[string];
+  if (string.indexOf('(') <= -1) {
+    const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');
+    const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasingFunctionWithParams} */(eases[string])() : eases[string]);
+    return parsedFn ? easesLookups[string] = parsedFn : none.none;
+  } else {
+    const split = string.slice(0, -1).split('(');
+    const parsedFn = /** @type {EasingFunctionWithParams} */(eases[split[0]]);
+    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none.none;
+  }
+};
+
+const deprecated = ['steps(', 'irregular(', 'linear(', 'cubicBezier('];
 
 /**
  * @param  {EasingParam} ease
  * @return {EasingFunction}
  */
-const parseEase = ease => helpers.isFnc(ease) ? ease :
-  helpers.isStr(ease) ? parser.parseEaseString(/** @type {String} */(ease), eases, JSEasesLookups) :
-  none.none;
+const parseEase = ease => {
+  if (helpers.isStr(ease)) {
+    for (let i = 0, l = deprecated.length; i < l; i++) {
+      if (helpers.stringStartsWith(ease, deprecated[i])) {
+        console.warn(`String syntax for \`ease: "${ease}"\` has been removed from the core and replaced by importing and passing the easing function directly: \`ease: ${ease}\``);
+        return none.none;
+      }
+    }
+  }
+  const easeFunc = helpers.isFnc(ease) ? ease : helpers.isStr(ease) ? parseEaseString(/** @type {String} */(ease)) : none.none;
+  return easeFunc;
+};
 
+exports.easeInPower = easeInPower;
+exports.easeTypes = easeTypes;
 exports.eases = eases;
 exports.parseEase = parseEase;
+exports.parseEaseString = parseEaseString;

package/dist/modules/easings/{eases.d.ts → eases/parser.d.ts}

@@ -1,8 +1,25 @@
+/**
+ * @import {
+ *   EasingFunction,
+ *   EasingFunctionWithParams,
+ *   EasingParam,
+ *   BackEasing,
+ *   ElasticEasing,
+ *   PowerEasing,
+ * } from '../../types/index.js'
+*/
+/** @type {PowerEasing} */
+export const easeInPower: PowerEasing;
+/**
+ * @callback EaseType
+ * @param {EasingFunction} Ease
+ * @return {EasingFunction}
+ */
+/** @type {Record<String, EaseType>} */
+export const easeTypes: Record<string, EaseType>;
 export namespace eases {
-    export let linear: typeof import("./linear.js").linear;
-    export let irregular: typeof import("./irregular.js").irregular;
-    export let steps: typeof import("./steps.js").steps;
-    export let cubicBezier: typeof import("./cubic-bezier.js").cubicBezier;
+    export let linear: typeof import("../none.js").none;
+    export let none: typeof import("../none.js").none;
     let _in: PowerEasing;
     export { _in as in };
     export let out: PowerEasing;
@@ -49,12 +66,12 @@ export namespace eases {
     export let inOutElastic: ElasticEasing;
     export let outInElastic: ElasticEasing;
 }
+export function parseEaseString(string: string): EasingFunction;
 export function parseEase(ease: EasingParam): EasingFunction;
+export type EaseType = (Ease: EasingFunction) => EasingFunction;
 export type EasesFunctions = {
-    linear: typeof linear;
-    irregular: typeof irregular;
-    steps: typeof steps;
-    cubicBezier: typeof cubicBezier;
+    linear: typeof none;
+    none: typeof none;
     in: PowerEasing;
     out: PowerEasing;
     inOut: PowerEasing;
@@ -100,12 +117,9 @@ export type EasesFunctions = {
     inOutElastic: ElasticEasing;
     outInElastic: ElasticEasing;
 };
-import type { PowerEasing } from '../types/index.js';
-import type { EasingFunction } from '../types/index.js';
-import type { BackEasing } from '../types/index.js';
-import type { ElasticEasing } from '../types/index.js';
-import type { EasingParam } from '../types/index.js';
-import { linear as linear_1 } from './linear.js';
-import { irregular as irregular_1 } from './irregular.js';
-import { steps as steps_1 } from './steps.js';
-import { cubicBezier as cubicBezier_1 } from './cubic-bezier.js';
+import type { PowerEasing } from '../../types/index.js';
+import type { EasingFunction } from '../../types/index.js';
+import type { BackEasing } from '../../types/index.js';
+import type { ElasticEasing } from '../../types/index.js';
+import type { EasingParam } from '../../types/index.js';
+import { none as none_1 } from '../none.js';

package/dist/modules/easings/{eases.js → eases/parser.js}

@@ -5,14 +5,9 @@
  * @copyright 2025 - Julian Garnier
  */
 
-import { emptyString, minValue } from '../core/consts.js';
-import { pow, sin, sqrt, cos, isFnc, isStr, clamp, asin, PI } from '../core/helpers.js';
-import { easeTypes, easeInPower, parseEaseString } from './parser.js';
-import { none } from './none.js';
-import { cubicBezier } from './cubic-bezier.js';
-import { steps } from './steps.js';
-import { linear } from './linear.js';
-import { irregular } from './irregular.js';
+import { emptyString, minValue } from '../../core/consts.js';
+import { pow, sin, sqrt, cos, isStr, stringStartsWith, isFnc, clamp, asin, PI } from '../../core/helpers.js';
+import { none } from '../none.js';
 
 /**
  * @import {
@@ -22,9 +17,27 @@ import { irregular } from './irregular.js';
  *   BackEasing,
  *   ElasticEasing,
  *   PowerEasing,
- * } from '../types/index.js'
+ * } from '../../types/index.js'
 */
 
+
+/** @type {PowerEasing} */
+const easeInPower = (p = 1.68) => t => pow(t, +p);
+
+/**
+ * @callback EaseType
+ * @param {EasingFunction} Ease
+ * @return {EasingFunction}
+ */
+
+/** @type {Record<String, EaseType>} */
+const easeTypes = {
+  in: easeIn => t => easeIn(t),
+  out: easeIn => t => 1 - easeIn(1 - t),
+  inOut: easeIn => t => t < .5 ? easeIn(t * 2) / 2 : 1 - easeIn(t * -2 + 2) / 2,
+  outIn: easeIn => t => t < .5 ? (1 - easeIn(1 - t * 2)) / 2 : (easeIn(t * 2 - 1) + 1) / 2,
+};
+
 /**
  * Easing functions adapted and simplified from https://robertpenner.com/easing/
  * (c) 2001 Robert Penner
@@ -53,7 +66,7 @@ const easeInFunctions = {
     return 1 / pow(4, 3 - b) - 7.5625 * pow((pow2 * 3 - 2) / 22 - t, 2);
   },
   /** @type {BackEasing} */
-  Back: (overshoot = 1.70158) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
+  Back: (overshoot = 1.7) => t => (+overshoot + 1) * t * t * t - +overshoot * t * t,
   /** @type {ElasticEasing} */
   Elastic: (amplitude = 1, period = .3) => {
     const a = clamp(+amplitude, 1, 10);
@@ -66,10 +79,8 @@ const easeInFunctions = {
 
 /**
  * @typedef  {Object} EasesFunctions
- * @property {typeof linear} linear
- * @property {typeof irregular} irregular
- * @property {typeof steps} steps
- * @property {typeof cubicBezier} cubicBezier
+ * @property {typeof none} linear
+ * @property {typeof none} none
  * @property {PowerEasing} in
  * @property {PowerEasing} out
  * @property {PowerEasing} inOut
@@ -117,7 +128,7 @@ const easeInFunctions = {
  */
 
 const eases = (/*#__PURE__ */ (() => {
-  const list = { linear, irregular, steps, cubicBezier };
+  const list = { linear: none, none: none };
   for (let type in easeTypes) {
     for (let name in easeInFunctions) {
       const easeIn = easeInFunctions[name];
@@ -133,14 +144,42 @@ const eases = (/*#__PURE__ */ (() => {
 })());
 
 /** @type {Record<String, EasingFunction>} */
-const JSEasesLookups = { linear: none };
+const easesLookups = { linear: none, none: none };
+
+/**
+ * @param  {String} string
+ * @return {EasingFunction}
+ */
+const parseEaseString = (string) => {
+  if (easesLookups[string]) return easesLookups[string];
+  if (string.indexOf('(') <= -1) {
+    const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');
+    const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasingFunctionWithParams} */(eases[string])() : eases[string]);
+    return parsedFn ? easesLookups[string] = parsedFn : none;
+  } else {
+    const split = string.slice(0, -1).split('(');
+    const parsedFn = /** @type {EasingFunctionWithParams} */(eases[split[0]]);
+    return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none;
+  }
+};
+
+const deprecated = ['steps(', 'irregular(', 'linear(', 'cubicBezier('];
 
 /**
  * @param  {EasingParam} ease
  * @return {EasingFunction}
  */
-const parseEase = ease => isFnc(ease) ? ease :
-  isStr(ease) ? parseEaseString(/** @type {String} */(ease), eases, JSEasesLookups) :
-  none;
+const parseEase = ease => {
+  if (isStr(ease)) {
+    for (let i = 0, l = deprecated.length; i < l; i++) {
+      if (stringStartsWith(ease, deprecated[i])) {
+        console.warn(`String syntax for \`ease: "${ease}"\` has been removed from the core and replaced by importing and passing the easing function directly: \`ease: ${ease}\``);
+        return none;
+      }
+    }
+  }
+  const easeFunc = isFnc(ease) ? ease : isStr(ease) ? parseEaseString(/** @type {String} */(ease)) : none;
+  return easeFunc;
+};
 
-export { eases, parseEase };
+export { easeInPower, easeTypes, eases, parseEase, parseEaseString };

package/dist/modules/easings/index.cjs

@@ -7,18 +7,20 @@
 
 'use strict';
 
-var none = require('./none.cjs');
-var cubicBezier = require('./cubic-bezier.cjs');
-var steps = require('./steps.cjs');
-var linear = require('./linear.cjs');
-var irregular = require('./irregular.cjs');
-var eases = require('./eases.cjs');
+var index = require('./cubic-bezier/index.cjs');
+var index$1 = require('./steps/index.cjs');
+var index$2 = require('./linear/index.cjs');
+var index$3 = require('./irregular/index.cjs');
+var index$4 = require('./spring/index.cjs');
+var parser = require('./eases/parser.cjs');
 
 
 
-exports.none = none.none;
-exports.cubicBezier = cubicBezier.cubicBezier;
-exports.steps = steps.steps;
-exports.linear = linear.linear;
-exports.irregular = irregular.irregular;
-exports.eases = eases.eases;
+exports.cubicBezier = index.cubicBezier;
+exports.steps = index$1.steps;
+exports.linear = index$2.linear;
+exports.irregular = index$3.irregular;
+exports.Spring = index$4.Spring;
+exports.createSpring = index$4.createSpring;
+exports.spring = index$4.spring;
+exports.eases = parser.eases;

package/dist/modules/easings/index.d.ts

@@ -1,6 +1,6 @@
-export { none } from "./none.js";
-export { cubicBezier } from "./cubic-bezier.js";
-export { steps } from "./steps.js";
-export { linear } from "./linear.js";
-export { irregular } from "./irregular.js";
-export { eases } from "./eases.js";
+export * from "./cubic-bezier/index.js";
+export * from "./steps/index.js";
+export * from "./linear/index.js";
+export * from "./irregular/index.js";
+export * from "./spring/index.js";
+export * from "./eases/index.js";