qarl 1.0.0 → 1.1.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 qarl
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 ThreePixDroid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,16 @@
 # QARL (Quantum Animation Remixable Library) 😎
 
+*Description generated by GPT while we were busy doing more important things.*
+
 QARL is an animation library for my game engine.
 
-New project! 💡 It surely has some bugs, unfinished features, and odd solutions, but I've put a lot of heart and effort into it. Thanks for stopping by — I hope you'll enjoy it! 🙏✨
+⚠️ **Attention!** ⚠️
+
+New project! 💡 It surely has some bugs, unfinished features, and odd solutions, but I've put a lot of heart and effort into it. Thanks for stopping by—I hope you'll enjoy it! 🙏✨
+
+## Why QARL? 🏎️💨
+
+Looking for performance? QARL's FromTo animation computes so fast, it feels like it bends space-time! 💫 No more waiting for slow calculations—just smooth, seamless transitions that keep up with the pace of your game.
 
 ## Installation
 
@@ -10,3 +18,51 @@ Install the library via npm:
 
 ```bash
 npm install qarl
+```
+
+## FromTo example
+
+```js
+const cube3 = new THREE.Mesh(
+  new THREE.BoxGeometry(),
+  new THREE.MeshBasicMaterial({ color: 0x00ffff })
+)
+
+new QARL.FromTo({
+    target: cube3,
+    dynamic: true,
+    loop: true,
+    time: 3000,
+    mode: QARL.modes.pingPong, // bounce, yoyo, pingPong
+    easing: QARL.easings.outQuad,
+    from: { rotation: { x: 1, y: 2 }, position: { x: 2, z: 2 }, scale: { x: .01, y: 1, z: 1 } },
+    to: { rotation: { x: 3, y: -5 }, position: { x: -2, z: -2 }, scale: { x: 3, y: .5, z: .5 } },
+})
+```
+
+## Curve example
+
+```js
+const cube3 = new THREE.Mesh(
+  new THREE.BoxGeometry(),
+  new THREE.MeshBasicMaterial({ color: 0xff00ff })
+)
+
+new QARL.Curve({
+    target: cube3,
+    loop: true,
+    time: 10000,
+    mode: QARL.modes.yoyo,
+    easing: QARL.easings.inOutBack,
+    smoothing: 10,
+    properties: ['position.x', 'position.y', 'position.z', 'scale.x', 'scale.y', 'scale.z'],
+    points: [
+        [-2, -2, 0, .1, .5, .5],
+        [ 2, -2, 0, .5, .2, .2],
+        [ 2,  0, 1, .1, .5, .5],
+        [-2,  0, 1, .5, .2, .2],
+        [-2,  2, 0, .1, .5, .5],
+        [ 2,  2, 0, .5, .2, .2],
+    ],
+})
+```

package/index.js

@@ -1,7 +1,8 @@
-export { Core } from './core/Core'
-export { EVENTS } from './core/events'
-export { DEFAULTS } from './core/defaults'
-export { Notifier } from './emitter/Notifier'
-export { FromTo } from './controllers/FromTo'
-export { easings } from './behaviors/easings'
-export { modes } from './behaviors/modes'
+export { Core } from './src/core/Core'
+export { Curve } from './src/controllers/Curve'
+export { FromTo } from './src/controllers/FromTo'
+export { Notifier } from './src/emitter/Notifier'
+export { DEFAULTS } from './src/core/defaults'
+export { easings } from './src/behaviors/easings'
+export { EVENTS } from './src/core/events'
+export { modes } from './src/behaviors/modes'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qarl",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "simple animation library",
   "main": "index.js",
   "scripts": {

package/src/controllers/Curve.js

@@ -0,0 +1,123 @@
+import { Core } from "../core/Core"
+
+export class Curve extends Core {
+    static DEFAULTS = {
+        ...Core.DEFAULTS,
+        properties: [],
+        points: [],
+        smoothing: 20,
+        // useLerp: true,
+        // path: [],
+        // speed: 1,
+    };
+
+    _preparePropertySetters() {
+        this.propertySetters = this.settings.properties.map(property => {
+            const keys = property.split('.')
+            const lastKey = keys.pop()
+
+            return (value) => {
+                let obj = this.target
+                for (let i = 0; i < keys.length; i++) {
+                    obj = obj[keys[i]]
+                }
+                obj[lastKey] = value
+            }
+        })
+    }
+
+    _generatePath() {
+        const points = this.settings.points
+        const smoothing = Math.max(this.settings.smoothing, 1)
+
+        const result = []
+        this.totalLength = 0
+
+        function interpolate(p0, p1, p2, p3, t) {
+            const t2 = t * t
+            const t3 = t2 * t
+
+            return p0.map((_, i) =>
+                0.5 * (
+                    (2 * p1[i]) +
+                    (-p0[i] + p2[i]) * t +
+                    (2 * p0[i] - 5 * p1[i] + 4 * p2[i] - p3[i]) * t2 +
+                    (-p0[i] + 3 * p1[i] - 3 * p2[i] + p3[i]) * t3
+                )
+            )
+        }
+
+        for (let i = 0; i < points.length - 1; i++) {
+            const p0 = points[i === 0 ? i : i - 1]
+            const p1 = points[i]
+            const p2 = points[i + 1]
+            const p3 = points[i + 2 < points.length ? i + 2 : i + 1]
+
+            for (let t = 0; t < smoothing; t++) {
+                const pt = interpolate(p0, p1, p2, p3, t / smoothing)
+                result.push(pt)
+
+                if (result.length > 1) {
+                    this.totalLength += this._calculateDistance(result[result.length - 2], pt)
+                }
+            }
+        }
+
+        result.push(points[points.length - 1])
+
+        return result
+    }
+
+    _calculateDistance(p1, p2) {
+        return Math.sqrt(p1.reduce((acc, _, i) => acc + Math.pow(p2[i] - p1[i], 2), 0))
+    }
+
+    _refreshDynamicProps() {
+        super._refreshDynamicProps()
+        this.path = this._generatePath()
+
+        if (!this.target || this.path.length === 0 || this.settings.properties.length === 0) {
+            this._setTargetProperties = Core._noop
+        } else {
+            this._preparePropertySetters()
+        }
+    }
+
+    _setTargetProperties(values) {
+        for (let i = 0; i < this.propertySetters.length; i++) {
+            this.propertySetters[i](values[i])
+        }
+    }
+
+    _clamp(value, min, max) {
+        return Math.max(min, Math.min(value, max))
+    }
+
+    _lerp(a, b, t) {
+        return a + (b - a) * t
+    }
+
+    _getInterpolatedPosition() {
+        const maxIndex = this.path.length - 1
+        const exactIndex = this.easeValue * maxIndex
+        const clampedExactIndex = this._clamp(exactIndex, 0, maxIndex)
+
+        // Determine the indices of the two neighboring points
+        const lowerIndex = clampedExactIndex >= maxIndex ? maxIndex - 1 : Math.floor(clampedExactIndex)
+        const upperIndex = Math.min(lowerIndex + 1, maxIndex)
+
+        const interpolationFactor = exactIndex - lowerIndex
+
+        const lowerPoint = this.path[lowerIndex]
+        const upperPoint = this.path[upperIndex]
+
+        return lowerPoint.map((coord, i) =>
+            this._lerp(coord, upperPoint[i], interpolationFactor)
+        )
+    }
+
+    _update() {
+        super._update()
+        this._setTargetProperties(this._getInterpolatedPosition())
+    }
+}

package/{controllers → src/controllers}/FromTo.js

@@ -5,7 +5,6 @@ export class FromTo extends Core {
   static DEFAULTS = {
     ...Core.DEFAULTS,
     dynamic: false, // в динамическом состоянии можно обновлять значения from и to во время анимации
-    target: null,
     from: null,
     to: null
   }
@@ -16,23 +15,24 @@ export class FromTo extends Core {
   }
 
   _processFromTo() {
-    this.target = this.settings.target
-
-    this._from = this.settings.from || this._createState(this.settings.to || {}, this.target)
-    this._to = this.settings.to || this._createState(this.settings.from || {}, this.target)
-
     if (!this.target) {
       this._updateFromTo = Core._noop
-    } else if (this.settings.dynamic) {
-      this._updateFromTo = this._updateDynamic.bind(this)
+      this._from = {}
+      this._to = {}
     } else {
-      this._lerps = []
-      this._createLerps(this.target, this._from, this._to)
-      this._updateFromTo = this._updateBaked.bind(this)
+      this._from = this.settings.from || this._createState(this.settings.to || {}, this.target)
+      this._to = this.settings.to || this._createState(this.settings.from || {}, this.target)
+      
+      if (this.settings.dynamic) {
+        this._updateFromTo = this._updateDynamic.bind(this)
+      } else {
+        this._lerps = []
+        this._createLerps(this.target, this._from, this._to)
+        this._updateFromTo = this._updateStatic.bind(this)
+      }
     }
   }
 
-
   _createState(origPattern = {}, origSource = {}, origTarget = {}) {
     const _copyProperty = (pattern, source, target) => {
       for (const key in pattern) {
@@ -67,7 +67,7 @@ export class FromTo extends Core {
     this._updateFromTo()
   }
 
-  _updateBaked() {
+  _updateStatic() {
     this._lerps.forEach(lerpStep => lerpStep(this.easeValue))
   }
 
@@ -103,6 +103,4 @@ export class FromTo extends Core {
 
     return this
   }
-
 }
-

package/src/core/Core.js

@@ -0,0 +1,372 @@
+import { Notifier } from "../emitter/Notifier"
+import { DEFAULTS } from "./defaults"
+import { EVENTS } from "./events"
+
+/**
+ * Core - Main class for managing animations.
+ * 
+ * @class Core
+ * @param {Object} [overrides={}] - Object for overriding default settings.
+ * @param {Object} [EmitterClass=null] - Class for managing animation events.
+ * 
+ * @example
+ * const animation = new Core({ time: 1000, easing: easings.inOutQuad });
+ * animation.play();
+ * 
+ * @property {Object} DEFAULTS - Default settings.
+ * @property {number} DEFAULTS.time - Animation duration.
+ * @property {boolean} DEFAULTS.loop - Flag for infinite looping.
+ * @property {function} DEFAULTS.easing - Function for controlling the animation effect.
+ * @property {boolean} DEFAULTS.reversed - Flag for playing the animation in reverse.
+ * @property {number} DEFAULTS.repeat - Number of animation repetitions.
+ * @property {number} DEFAULTS.delay - Delay before the animation starts.
+ * 
+ * @property {Object} settings - Current animation settings.
+ * @property {number} progress - Current animation progress.
+ * @property {boolean} reversed - Indicates if the animation is played in reverse.
+ */
+export class Core {
+    static DEFAULTS = DEFAULTS
+
+    static _noop() { }
+
+    static mergeConfigs(target, source) {
+        for (let key in source) {
+            if (typeof source[key] === 'object' && source[key] !== null) {
+                if (!target[key] || typeof target[key] !== 'object') {
+                    target[key] = {}
+                }
+                Core.mergeConfigs(target[key], source[key])
+            } else {
+                target[key] = source[key]
+            }
+        }
+    }
+
+    constructor(overrides = {}, EmitterClass = Notifier) {
+        this.settings = {}
+        this._emitter = EmitterClass ? new EmitterClass() : null
+        this.reset(overrides)
+    }
+
+    /**
+     * Sets internal animation states.
+     * @private
+     */
+    _processState() {
+        this.step = Core._noop
+        this.progress = 0
+        this.easeValue = 0
+        this.elapsedTime = 0
+        this.promise = null
+        this._resolve = Core._noop
+        this._refreshDynamicProps()
+    }
+
+    /**
+     * Updates dynamic animation states.
+     * @private
+     */
+    _refreshDynamicProps() {
+        this.target = this.settings.target
+        
+        this.time = Math.max(this.settings.time, 0)
+        this.repeat = this.settings.repeat > 0 ? this.settings.repeat : this.settings.loop ? Infinity : 0
+        this.reversed = this.settings.reversed
+        this.remainingDelay = this.settings.delay
+
+        this._emitEvent = this._emitEvent || Core._noop
+        this._emitUpdate = this._emitUpdate || Core._noop
+
+        this._processEasing()
+    }
+
+    /**
+     * Sets the easing function for the animation.
+     * @private
+     */
+    _processEasing() {
+        this._easing = this.reversed ? this._reversedEasing : this.settings.easing
+        this._calculateEasing = this.settings.mode ? this.settings.mode.bind(this) : this._easing
+    }
+
+    /**
+     * Calculates the reversed easing value.
+     * @param {number} t - Progress time.
+     * @returns {number} - Easing result for the reversed direction.
+     * @private
+     */
+    _reversedEasing(t) {
+        return this.settings.easing(1 - t)
+    }
+
+    /**
+     * Updates animation progress and triggers the update event.
+     * @private
+     */
+    _update() {
+        this.progress = this.elapsedTime / this.time
+        this.easeValue = this._calculateEasing(this.progress)
+        this._emitUpdate(EVENTS.UPDATE, { progress: this.progress, ease: this.easeValue })
+    }
+
+    /**
+     * Handles the delay before the animation starts.
+     * @param {number} deltaTime - Time passed since the last step.
+     * @private
+     */
+    _stepDelay(deltaTime) {
+        this.remainingDelay -= deltaTime
+
+        if (this.remainingDelay > 0) return
+
+        this.step = this._stepTime
+        this.step(Math.abs(this.remainingDelay))
+
+        this.remainingDelay = this.settings.delay
+    }
+
+    /**
+     * Handles animation time.
+     * @param {number} [deltaTime=0] - Time passed since the last step.
+     * @private
+     */
+    _stepTime(deltaTime = 0) {
+        this.elapsedTime += deltaTime
+
+        if (this.elapsedTime >= this.time) {
+            this.elapsedTime = this.time
+            this._update()
+            this._complete()
+        } else {
+            this._update()
+        }
+    }
+
+    /**
+     * Called when the animation is complete.
+     * @private
+     */
+    _complete() {
+        if (this.repeat-- > 0) {
+            this._repeat()
+        } else {
+            this._resolve()
+            this.stop(false)
+            this._emitEvent(EVENTS.COMPLETE)
+        }
+    }
+
+    /**
+     * Repeats the animation if repetitions are set.
+     * @param {boolean} [withEvent=true] - Flag for triggering the repeat event.
+     * @private
+     */
+    _repeat(withEvent = true) {
+        this.remainingDelay = this.settings.repeatDelay
+        this.elapsedTime = 0
+
+        if (this.remainingDelay > 0) {
+            this.step = this._stepDelay
+        }
+
+        this._update()
+        withEvent && this._emitEvent(EVENTS.REPEAT)
+    }
+
+    /**
+     * Logs a warning if the event emitter is not defined.
+     * @returns {Core} The current instance for chaining.
+     * @private
+     */
+    _noEmitter() {
+        console.warn('Event emitter is not defined')
+        return this
+    }
+
+    /**
+     * Subscribes a handler to the specified event.
+     * @param {string} event - Event name.
+     * @param {function} handler - Event handler.
+     * @param {boolean} [once=false] - Flag for one-time subscription.
+     * @returns {Core} The current instance for chaining.
+     */
+    on(event, handler, once = false) {
+        if (!this._emitter) return this._noEmitter()
+
+        if (event === EVENTS.UPDATE) {
+            this._emitUpdate = this._emitter.emit(event, handler)
+        } else {
+            this._emit = this._emitter.emit(event, handler)
+        }
+
+        once
+            ? this._emitter.once(event, handler)
+            : this._emitter.on(event, handler)
+
+        return this
+    }
+
+    /**
+     * Subscribes a handler to the specified event once.
+     * @param {string} event - Event name.
+     * @param {function} handler - Event handler.
+     * @returns {Core} The current instance for chaining.
+     */
+    once(event, handler) {
+        return this.on(event, handler, true)
+    }
+
+    /**
+     * Unsubscribes a handler from the specified event.
+     * @param {string} event - Event name.
+     * @param {function} handler - Event handler.
+     * @returns {Core} The current instance for chaining.
+     */
+    off(event, handler) {
+        if (!this._emitter) return this._noEmitter()
+
+        this._emitter.off(event, handler)
+        return this
+    }
+
+    /**
+     * Removes all handlers for the specified event.
+     * @param {string} event - Event name.
+     * @returns {Core} The current instance for chaining.
+     */
+    removeEvents(event) {
+        if (!this._emitter) return this._noEmitter()
+
+        this._emitEvent = Core._noop
+        this._emitUpdate = Core._noop
+
+        this._emitter.removeAllListeners(event)
+        return this
+    }
+
+    /**
+     * Resets settings to default values.
+     * @param {Object} [newSettings=Core.DEFAULTS] - New settings.
+     * @returns {Core} The current instance for chaining.
+     */
+    reset(newSettings = this.constructor.DEFAULTS) {
+        this.settings = { ...this.constructor.DEFAULTS, ...newSettings }
+        this._processState()
+        return this
+    }
+
+    /**
+     * Modifies the current animation settings.
+     * @param {Object} [newSettings={}] - New settings.
+     * @returns {Core} The current instance for chaining.
+     */
+    tweak(newSettings = {}) {
+        Core.mergeConfigs(this.settings, newSettings)
+        this._refreshDynamicProps()
+        return this
+    }
+
+    /**
+     * Sets the animation time.
+     * @param {number} [time=0] - Time to set.
+     * @returns {Core} The current instance for chaining.
+     */
+    seek(time = 0, callUpdate = true) {
+        this.elapsedTime = Math.min(Math.max(time, 0), this.settings.time)
+        callUpdate && this._update()
+        return this
+    }
+
+    /**
+     * Sets the animation progress.
+     * @param {number} [progress=0] - Animation progress (from 0 to 1).
+     * @returns {Core} The current instance for chaining.
+     */
+    setProgress(progress = 0, callUpdate = true) {
+        this.seek(this.settings.time * progress, callUpdate)
+        return this
+    }
+
+    /**
+     * Toggles the animation direction (forward/reverse).
+     * @returns {Core} The current instance for chaining.
+     */
+    reverse(callUpdate = false) {
+        this.reversed = !this.reversed
+        this.seek(this.settings.time - this.elapsedTime, callUpdate)
+        this._processEasing()
+
+        return this
+    }
+
+    /**
+     * Starts the animation.
+     * @param {boolean} [withEvent=true] - Flag for triggering the play event.
+     * @returns {Core} The current instance for chaining.
+     */
+    play(withEvent = true) {
+        if (this.isPlaying) return this
+
+        withEvent && this._emitEvent(EVENTS.PLAY)
+        if (this.remainingDelay > 0) {
+            this.step = this._stepDelay
+        } else {
+            this.step = this._stepTime
+            this._emitEvent(EVENTS.BEGIN)
+        }
+
+        return this
+    }
+
+    /**
+     * Starts the animation and returns a Promise.
+     * @param {Promise} [promise=this.promise] - Promise object to resolve on completion.
+     * @returns {Promise} - A promise that resolves when the animation is complete.
+     */
+    playPromise(promise = this.promise) {
+        this.play()
+        this.promise = promise || new Promise(resolve => this._resolve = resolve)
+        return this.promise
+    }
+
+    /**
+     * Stops the animation.
+     * @param {boolean} [withEvent=true] - Flag for triggering the stop event.
+     * @returns {Core} The current instance for chaining.
+     */
+    stop(withEvent = true) {
+        this._processState()
+        withEvent && this._emitEvent(EVENTS.STOP)
+        return this
+    }
+
+    /**
+     * Pauses the animation.
+     * @returns {Core} The current instance for chaining.
+     */
+    pause() {
+        this.step = Core._noop
+        this._emitEvent(EVENTS.PAUSE)
+        return this
+    }
+
+    /**
+     * Restarts the animation from the beginning.
+     * @param {boolean} [withEvent=true] - Flag for triggering the replay event.
+     * @returns {Core} The current instance for chaining.
+     */
+    replay(withEvent = true) {
+        this.stop(withEvent)
+        this.play(withEvent)
+        return this
+    }
+
+    /**
+     * Returns whether the animation is currently playing.
+     * @returns {boolean} - true if the animation is playing, otherwise false.
+     */
+    get isPlaying() {
+        return this.step !== Core._noop
+    }
+}

package/{core → src/core}/defaults.js

@@ -6,6 +6,7 @@ export const DEFAULTS = {
   mode: null,
   delay: 0,
   repeat: 0,
+  target: null,
   easing: easings.linear,
   reversed: false,
   repeatDelay: 0,

package/src/emitter/Notifier.js

@@ -0,0 +1,97 @@
+export class Notifier {
+    constructor() {
+        this.events = {}
+    }
+
+    /**
+     * Subscribe to an event
+     * @param {string} eventName - Name of the event
+     * @param {function} listener - Event handler function
+     */
+    on(eventName, listener) {
+        if (!this.events[eventName]) {
+            this.events[eventName] = []
+        }
+        this.events[eventName].push(listener)
+    }
+
+    /**
+     * Unsubscribe from an event
+     * @param {string} eventName - Name of the event
+     * @param {function} listener - Event handler function
+     */
+    off(eventName, listener) {
+        if (!this.events[eventName]) return
+        this.events[eventName] = this.events[eventName].filter(l => l !== listener)
+    }
+
+    /**
+     * Emit an event
+     * @param {string} eventName - Name of the event
+     * @param  {...any} args - Arguments passed to the event handler
+     */
+    emit(eventName, ...args) {
+        if (!this.events[eventName]) return
+        this.events[eventName].forEach(listener => listener(...args))
+    }
+
+    /**
+     * Subscribe to an event once
+     * @param {string} eventName - Name of the event
+     * @param {function} listener - Event handler function
+     */
+    once(eventName, listener) {
+        const onceListener = (...args) => {
+            this.off(eventName, onceListener)
+            listener(...args)
+        }
+        this.on(eventName, onceListener)
+    }
+
+    /**
+     * Get the list of event listeners
+     * @param {string} eventName - Name of the event
+     * @returns {function[]} List of event handlers
+     */
+    getListeners(eventName) {
+        return this.events[eventName] || []
+    }
+
+    /**
+     * Get the number of event listeners
+     * @param {string} eventName - Name of the event
+     * @returns {number} Number of event listeners
+     */
+    getListenerCount(eventName) {
+        return this.events[eventName] ? this.events[eventName].length : 0
+    }
+
+    /**
+     * Remove all listeners or listeners of a specific event type
+     * @param {string} [eventName] - Name of the event (optional)
+     */
+    removeAllListeners(eventName) {
+        if (eventName) {
+            delete this.events[eventName]
+        } else {
+            this.events = {}
+        }
+    }
+
+    /**
+     * Get the list of all event names
+     * @returns {string[]} List of event names
+     */
+    getEventNames() {
+        return Object.keys(this.events)
+    }
+
+    /**
+     * Check if there are any listeners for an event
+     * @param {string} eventName - Name of the event
+     * @returns {boolean} True if there are listeners, otherwise False
+     */
+    hasListeners(eventName) {
+        return this.getListenerCount(eventName) > 0
+    }
+}

package/core/Core.js

@@ -1,371 +0,0 @@
-import { Notifier } from "../emitter/Notifier"
-import { DEFAULTS } from "../core/defaults"
-import { EVENTS } from "../core/events"
-
-
-/**
- * Core - Основной класс для управления анимациями.
- * 
- * @class Core
- * @param {Object} [overrides={}] - Объект для переопределения настроек по умолчанию.
- * @param {Object} [EmitterClass=null] - Класс для управления событиями анимации.
- * 
- * @example
- * const animation = new Core({ time: 1000, easing: easings.inOutQuad });
- * animation.play();
- * 
- * @property {Object} DEFAULTS - Настройки по умолчанию.
- * @property {number} DEFAULTS.time - Время анимации.
- * @property {boolean} DEFAULTS.loop - Флаг бесконечного повторения анимации.
- * @property {function} DEFAULTS.easing - Функция для управления эффектом анимации.
- * @property {boolean} DEFAULTS.reversed - Флаг обратного проигрывания анимации.
- * @property {number} DEFAULTS.repeat - Количество повторений анимации.
- * @property {number} DEFAULTS.delay - Задержка перед началом анимации.
- * 
- * @property {Object} settings - Текущие настройки анимации.
- * @property {number} progress - Текущий прогресс анимации.
- * @property {boolean} reversed - Указывает, проигрывается ли анимация в обратном направлении.
- */
-export class Core {
-  static DEFAULTS = DEFAULTS
-
-  static _noop() { }
-
-  static mergeConfigs(target, source) {
-      for (let key in source) {
-          if (typeof source[key] === 'object' && source[key] !== null) {
-              if (!target[key] || typeof target[key] !== 'object') {
-                  target[key] = {}
-              }
-              Core.mergeConfigs(target[key], source[key])
-          } else {
-              target[key] = source[key]
-          }
-      }
-  }
-
-  constructor(overrides = {}, EmitterClass = Notifier) {
-      this.settings = {}
-      this._emitter = EmitterClass ? new EmitterClass() : null
-      this.reset(overrides)
-  }
-
-  /**
-   * Устанавливает внутренние состояния анимации.
-   * @private
-   */
-  _processState() {
-      this.step = Core._noop
-      this.progress = 0
-      this.easeValue = 0
-      this.elapsedTime = 0
-      this.promise = null
-      this._resolve = Core._noop
-      this._refreshDynamicProps()
-  }
-
-  /**
-   * Обновляет динамические состояния анимации.
-   * @private
-   */
-  _refreshDynamicProps() {
-      this.time = Math.max(this.settings.time, 0)
-      this.repeat = this.settings.repeat > 0 ? this.settings.repeat : this.settings.loop ? Infinity : 0
-      this.reversed = this.settings.reversed
-      this.remainingDelay = this.settings.delay
-
-      this._emitEvent = this._emitEvent || Core._noop
-      this._emitUpdate = this._emitUpdate || Core._noop
-
-      this._processEasing()
-  }
-
-  /**
-   * Устанавливает функцию easing для анимации.
-   * @private
-   */
-  _processEasing() {
-      this._easing = this.reversed ? this._reversedEasing : this.settings.easing
-      this._calculateEasing = this.settings.mode ? this.settings.mode.bind(this) : this._easing
-  }
-
-  /**
-   * Рассчитывает обратное значение easing.
-   * @param {number} t - Время прогресса.
-   * @returns {number} - Результат функции easing для обратного направления.
-   * @private
-   */
-  _reversedEasing(t) {
-      return this.settings.easing(1 - t)
-  }
-
-  /**
-   * Обновляет прогресс анимации и вызывает событие обновления.
-   * @private
-   */
-  _update() {
-      this.progress = this.elapsedTime / this.time
-      this.easeValue = this._calculateEasing(this.progress)
-      this._emitUpdate(EVENTS.UPDATE, { progress: this.progress, ease: this.easeValue })
-  }
-
-  /**
-   * Обрабатывает задержку перед началом анимации.
-   * @param {number} deltaTime - Время, прошедшее с предыдущего шага.
-   * @private
-   */
-  _stepDelay(deltaTime) {
-      this.remainingDelay -= deltaTime
-
-      if (this.remainingDelay > 0) return
-
-      this.step = this._stepTime
-      this.step(Math.abs(this.remainingDelay))
-
-      this.remainingDelay = this.settings.delay
-  }
-
-  /**
-   * Обрабатывает время анимации.
-   * @param {number} [deltaTime=0] - Время, прошедшее с предыдущего шага.
-   * @private
-   */
-  _stepTime(deltaTime = 0) {
-      this.elapsedTime += deltaTime
-
-      if (this.elapsedTime >= this.time) {
-          this.elapsedTime = this.time
-          this._update()
-          this._complete()
-      } else {
-          this._update()
-      }
-  }
-
-  /**
-   * Вызывается при завершении анимации.
-   * @private
-   */
-  _complete() {
-      if (this.repeat-- > 0) {
-          this._repeat()
-      } else {
-          this._resolve()
-          this.stop(false)
-          this._emitEvent(EVENTS.COMPLETE)
-      }
-  }
-
-  /**
-   * Повторяет анимацию, если установлены повторения.
-   * @param {boolean} [withEvent=true] - Флаг для вызова события повторения.
-   * @private
-   */
-  _repeat(withEvent = true) {
-      this.remainingDelay = this.settings.repeatDelay
-      this.elapsedTime = 0
-
-      if (this.remainingDelay > 0) {
-          this.step = this._stepDelay
-      }
-
-      this._update()
-      withEvent && this._emitEvent(EVENTS.REPEAT)
-  }
-
-  /**
-   * Логирует предупреждение, если эмиттер событий не определен.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   * @private
-   */
-  _noEmitter() {
-      console.warn('Event emitter is not defined')
-      return this
-  }
-
-  /**
-   * Подписывает обработчик на указанное событие.
-   * @param {string} event - Имя события.
-   * @param {function} handler - Обработчик события.
-   * @param {boolean} [once=false] - Флаг для одноразовой подписки.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  on(event, handler, once = false) {
-      if (!this._emitter) return this._noEmitter()
-
-      if (event === EVENTS.UPDATE) {
-          this._emitUpdate = this._emitter.emit(event, handler)
-      } else {
-          this._emit = this._emitter.emit(event, handler)
-      }
-
-      once
-          ? this._emitter.once(event, handler)
-          : this._emitter.on(event, handler)
-
-      return this
-  }
-
-  /**
-   * Подписывает одноразовый обработчик на указанное событие.
-   * @param {string} event - Имя события.
-   * @param {function} handler - Обработчик события.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  once(event, handler) {
-      return this.on(event, handler, true)
-  }
-
-  /**
-   * Отписывает обработчик от указанного события.
-   * @param {string} event - Имя события.
-   * @param {function} handler - Обработчик события.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  off(event, handler) {
-      if (!this._emitter) return this._noEmitter()
-
-      this._emitter.off(event, handler)
-      return this
-  }
-
-  /**
-   * Удаляет все обработчики для указанного события.
-   * @param {string} event - Имя события.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  removeEvents(event) {
-      if (!this._emitter) return this._noEmitter()
-
-      this._emitEvent = Core._noop
-      this._emitUpdate = Core._noop
-
-      this._emitter.removeAllListeners(event)
-      return this
-  }
-
-  /**
-   * Сбрасывает настройки к значениям по умолчанию.
-   * @param {Object} [newSettings=Core.DEFAULTS] - Новые настройки.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  reset(newSettings = this.constructor.DEFAULTS) {
-      this.settings = { ...this.constructor.DEFAULTS, ...newSettings }
-      this._processState()
-      return this
-  }
-
-  /**
-   * Изменяет текущие настройки анимации.
-   * @param {Object} [newSettings={}] - Новые настройки.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  tweak(newSettings = {}) {
-      Core.mergeConfigs(this.settings, newSettings)
-      this._refreshDynamicProps()
-      return this
-  }
-
-  /**
-   * Устанавливает время анимации.
-   * @param {number} [time=0] - Время для установки.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  seek(time = 0, callUpdate = true) {
-      this.elapsedTime = Math.min(Math.max(time, 0), this.settings.time)
-      callUpdate && this._update()
-      return this
-  }
-
-  /**
-   * Устанавливает прогресс анимации.
-   * @param {number} [progress=0] - Прогресс анимации (от 0 до 1).
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  setProgress(progress = 0, callUpdate = true) {
-      this.seek(this.settings.time * progress, callUpdate)
-      return this
-  }
-
-  /**
-   * Меняет направление анимации (прямое/обратное).
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  reverse(callUpdate = false) {
-      this.reversed = !this.reversed
-      this.seek(this.settings.time - this.elapsedTime, callUpdate)
-      this._processEasing()
-
-      return this
-  }
-
-  /**
-   * Запускает анимацию.
-   * @param {boolean} [withEvent=true] - Флаг для вызова события при запуске.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  play(withEvent = true) {
-      if (this.isPlaying) return this
-
-      withEvent && this._emitEvent(EVENTS.PLAY)
-      if (this.remainingDelay > 0) {
-          this.step = this._stepDelay
-      } else {
-          this.step = this._stepTime
-          this._emitEvent(EVENTS.BEGIN)
-      }
-
-      return this
-  }
-
-  /**
-   * Запускает анимацию с возвращением Promise.
-   * @param {Promise} [promise=this.promise] - Объект Promise для разрешения по завершению.
-   * @returns {Promise} - Promise, который разрешится при завершении анимации.
-   */
-  playPromise(promise = this.promise) {
-      this.play()
-      this.promise = promise || new Promise(resolve => this._resolve = resolve)
-      return this.promise
-  }
-
-  /**
-   * Останавливает анимацию.
-   * @param {boolean} [withEvent=true] - Флаг для вызова события при остановке.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  stop(withEvent = true) {
-      this._processState()
-      withEvent && this._emitEvent(EVENTS.STOP)
-      return this
-  }
-
-  /**
-   * Приостанавливает анимацию.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  pause() {
-      this.step = Core._noop
-      this._emitEvent(EVENTS.PAUSE)
-      return this
-  }
-
-  /**
-   * Повторно запускает анимацию с начального состояния.
-   * @param {boolean} [withEvent=true] - Флаг для вызова события при перезапуске.
-   * @returns {Core} Текущий экземпляр для цепочек вызовов.
-   */
-  replay(withEvent = true) {
-      this.stop(withEvent)
-      this.play(withEvent)
-      return this
-  }
-
-  /**
-   * Возвращает, активна ли анимация.
-   * @returns {boolean} - true, если анимация воспроизводится, иначе false.
-   */
-  get isPlaying() {
-      return this.step !== Core._noop
-  }
-}

package/emitter/Notifier.js

@@ -1,97 +0,0 @@
-export class Notifier {
-  constructor() {
-      this.events = {}
-  }
-
-  /**
-   * Подписка на событие
-   * @param {string} eventName - Название события
-   * @param {function} listener - Функция обработчик события
-   */
-  on(eventName, listener) {
-      if (!this.events[eventName]) {
-          this.events[eventName] = []
-      }
-      this.events[eventName].push(listener)
-  }
-
-  /**
-   * Отписка от события
-   * @param {string} eventName - Название события
-   * @param {function} listener - Функция обработчик события
-   */
-  off(eventName, listener) {
-      if (!this.events[eventName]) return
-      this.events[eventName] = this.events[eventName].filter(l => l !== listener)
-  }
-
-  /**
-   * Генерация события
-   * @param {string} eventName - Название события
-   * @param  {...any} args - Аргументы, передаваемые обработчику события
-   */
-  emit(eventName, ...args) {
-      if (!this.events[eventName]) return
-      this.events[eventName].forEach(listener => listener(...args))
-  }
-
-  /**
-   * Разовая подписка на событие
-   * @param {string} eventName - Название события
-   * @param {function} listener - Функция обработчик события
-   */
-  once(eventName, listener) {
-      const onceListener = (...args) => {
-          this.off(eventName, onceListener)
-          listener(...args)
-      }
-      this.on(eventName, onceListener)
-  }
-
-  /**
-   * Получить список обработчиков события
-   * @param {string} eventName - Название события
-   * @returns {function[]} Список обработчиков
-   */
-  getListeners(eventName) {
-      return this.events[eventName] || []
-  }
-
-  /**
-   * Получить количество обработчиков события
-   * @param {string} eventName - Название события
-   * @returns {number} Количество обработчиков
-   */
-  getListenerCount(eventName) {
-      return this.events[eventName] ? this.events[eventName].length : 0
-  }
-
-  /**
-   * Удаление всех подписок или подписок определенного типа
-   * @param {string} [eventName] - Название события (опционально)
-   */
-  removeAllListeners(eventName) {
-      if (eventName) {
-          delete this.events[eventName]
-      } else {
-          this.events = {}
-      }
-  }
-
-  /**
-   * Получить список всех событий
-   * @returns {string[]} Список названий событий
-   */
-  getEventNames() {
-      return Object.keys(this.events)
-  }
-
-  /**
-   * Проверить наличие подписчиков на событие
-   * @param {string} eventName - Название события
-   * @returns {boolean} True, если есть подписчики, иначе False
-   */
-  hasListeners(eventName) {
-      return this.getListenerCount(eventName) > 0
-  }
-}