qarl 1.0.0

package/LICENSE

@@ -0,0 +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.

package/README.md

@@ -0,0 +1,12 @@
+# QARL (Quantum Animation Remixable Library) 😎
+
+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! 🙏✨
+
+## Installation
+
+Install the library via npm:
+
+```bash
+npm install qarl

package/behaviors/easings.js

@@ -0,0 +1,72 @@
+
+    // created by chatGPT
+    const PI2 = Math.PI * 2
+
+    export const easings = {
+        reverse: (t) => 1 - t,
+        linear: (t) => t,
+        yoyo: (t) => 1 - Math.abs(1 - t * 2),
+
+        inQuad: (t) => t * t,
+        outQuad: (t) => t * (2 - t),
+        inOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+
+        inCubic: (t) => t * t * t,
+        outCubic: (t) => (--t) * t * t + 1,
+        inOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1,
+
+        inQuart: (t) => t * t * t * t,
+        outQuart: (t) => 1 - (--t) * t * t * t,
+        inOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * (--t) * t * t * t,
+
+        inQuint: (t) => t * t * t * t * t,
+        outQuint: (t) => 1 + (--t) * t * t * t * t,
+        inOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * (--t) * t * t * t * t,
+
+        inSine: (t) => 1 - Math.cos((t * Math.PI) / 2),
+        outSine: (t) => Math.sin((t * Math.PI) / 2),
+        inOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+
+        inBack: (t, s = 1.70158) => t * t * ((s + 1) * t - s),
+        outBack: (t, s = 1.70158) => ((t -= 1) * t * ((s + 1) * t + s) + 1),
+        inOutBack: (t, s = 1.70158) =>
+            (t *= 2) < 1
+                ? 0.5 * (t * t * ((s * 1.525 + 1) * t - s * 1.525))
+                : 0.5 * ((t -= 2) * t * ((s * 1.525 + 1) * t + s * 1.525) + 2),
+
+        inExpo: (t) => (t === 0 ? 0 : Math.pow(2, 10 * (t - 1))),
+        outExpo: (t) => (t === 1 ? 1 : 1 - Math.pow(2, -10 * t)),
+        inOutExpo: (t) => (
+            t === 0
+                ? 0
+                : t === 1
+                    ? 1
+                    : t < 0.5
+                        ? 0.5 * Math.pow(2, 20 * t - 10)
+                        : 1 - 0.5 * Math.pow(2, -20 * t + 10)
+        ),
+
+        inElastic: (t, a = 1, p = 0.5) => (
+            t === 0
+                ? 0
+                : t === 1
+                    ? 1
+                    : -a * Math.pow(2, 10 * (t - 1)) * Math.sin(((t - 1 - p / PI2 * Math.asin(1 / a)) * PI2) / p)
+        ),
+        outElastic: (t, a = 1, p = 0.5) => (
+            t === 0
+                ? 0
+                : t === 1
+                    ? 1
+                    : a * Math.pow(2, -10 * t) * Math.sin(((t - p / PI2 * Math.asin(1 / a)) * PI2) / p) + 1
+        ),
+        inOutElastic: (t, a = 1, p = 0.5) => (
+            t === 0
+                ? 0
+                : t === 1
+                    ? 1
+                    : t < 0.5
+                        ? -0.5 * a * Math.pow(2, 20 * t - 10) * Math.sin(((20 * t - 11.125) * PI2) / p)
+                        : 0.5 * a * Math.pow(2, -20 * t + 10) * Math.sin(((20 * t - 11.125) * PI2) / p) + 1
+        )
+    }

package/behaviors/modes.js

@@ -0,0 +1,47 @@
+import { easings } from "./easings"
+
+/**
+     * Объект, содержащий модификаторы анимации.
+     * @namespace
+     * @property {function} pingPong - Реализует пинг-понг эффект для анимации.
+     * @property {function} yoyo - Реализует эффект зеркального отражения анимации.
+     * @property {function} bounce - Реализует эффект отскока для анимации.
+     * @example
+     * const animation = new Core({ time: 1000, mode: modes.pingPong })
+     * animation.play()
+     * @see {@link Core}
+     * @see {@link easings}
+     */
+export const modes = {
+  /**
+   * Реализует пинг-понг эффект для анимации.
+   * @private
+   * @param {number} t - Текущее время анимации.
+   * @returns {number} Измененное значение времени для эффекта пинг-понг.
+   */
+  pingPong: function (t) {
+      return t <= 0.5
+          ? this._easing(t * 2)
+          : 1 - this._easing((t - 0.5) * 2)
+  },
+  
+  /**
+   * Реализует эффект зеркального отражения анимации.
+   * @private
+   * @param {number} t - Текущее время анимации.
+   * @returns {number} Измененное значение времени для эффекта зеркального отражения.
+   */
+  yoyo: function (t) {
+      return this._easing(easings.yoyo(t))
+  },
+
+  /**
+   * Реализует эффект отскока для анимации.
+   * @private
+   * @param {number} t - Текущее время анимации.
+   * @returns {number} Измененное значение времени для эффекта отскока.
+   */
+  bounce: function (t) {
+      return easings.yoyo(this._easing(t))
+  },
+}

package/controllers/FromTo.js

@@ -0,0 +1,108 @@
+import { Core } from "../core/Core"
+
+export class FromTo extends Core {
+
+  static DEFAULTS = {
+    ...Core.DEFAULTS,
+    dynamic: false, // в динамическом состоянии можно обновлять значения from и to во время анимации
+    target: null,
+    from: null,
+    to: null
+  }
+
+  _refreshDynamicProps() {
+    super._refreshDynamicProps()
+    this._processFromTo()
+  }
+
+  _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)
+    } else {
+      this._lerps = []
+      this._createLerps(this.target, this._from, this._to)
+      this._updateFromTo = this._updateBaked.bind(this)
+    }
+  }
+
+
+  _createState(origPattern = {}, origSource = {}, origTarget = {}) {
+    const _copyProperty = (pattern, source, target) => {
+      for (const key in pattern) {
+        typeof pattern[key] === 'object'
+          ? target[key] = {} && _copyProperty(pattern[key], source[key], target[key])
+          : target[key] = source[key]
+      }
+    }
+
+    _copyProperty(origPattern, origSource, origTarget)
+    return origTarget
+  }
+
+  _createLerpStep(target, objFrom, objTo, propName) {
+    const staticDelta = objTo[propName] - objFrom[propName]
+
+    return (easeValue) => {
+      target[propName] = objFrom[propName] + staticDelta * easeValue
+    }
+  }
+
+  _createLerps(target, from, to) {
+    for (const key in to) {
+      typeof to[key] === 'object'
+        ? this._createLerps(target[key], from[key], to[key])
+        : this._lerps.push(this._createLerpStep(target, from, to, key))
+    }
+  }
+
+  _update() {
+    super._update()
+    this._updateFromTo()
+  }
+
+  _updateBaked() {
+    this._lerps.forEach(lerpStep => lerpStep(this.easeValue))
+  }
+
+  _updateDynamic(target = this.target, from = this._from, to = this._to) {
+    for (const key in to) {
+      typeof to[key] === 'object'
+        ? this._updateDynamic(target[key], from[key], to[key])
+        : target[key] = from[key] + (to[key] - from[key]) * this.easeValue
+    }
+  }
+
+  from(newFrom = {}) {
+    this.tweak({ from: newFrom })
+    this._processFromTo()
+    return this
+  }
+
+  to(newTo = {}) {
+    this.tweak({ to: newTo })
+    this._processFromTo()
+    return this
+  }
+
+  swap() {
+    const temp = this._from
+    this._from = this._to
+    this._to = temp
+
+    if (!this.settings.dynamic) {
+      this._lerps = []
+      this._createLerps(this.target, this._from, this._to)
+    }
+
+    return this
+  }
+
+}
+

package/core/Core.js

@@ -0,0 +1,371 @@
+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/core/defaults.js

@@ -0,0 +1,12 @@
+import { easings } from '../behaviors/easings'
+
+export const DEFAULTS = {
+  time: 0,
+  loop: false,
+  mode: null,
+  delay: 0,
+  repeat: 0,
+  easing: easings.linear,
+  reversed: false,
+  repeatDelay: 0,
+}

package/core/events.js

@@ -0,0 +1,30 @@
+/**
+ * Объект, содержащий события анимации.
+ * @namespace
+ * @property {string} PLAY - Событие начала анимации.
+ * @property {string} STOP - Событие остановки анимации.
+ * @property {string} BEGIN - Событие паузы анимации.
+ * @property {string} PAUSE - Событие паузы анимации.
+ * @property {string} UPDATE - Событие обновления анимации.
+ * @property {string} REPEAT - Событие повторения анимации.
+ * @property {string} REVERSE - Событие повторения анимации.
+ * @property {string} COMPLETE - Событие завершения анимации.
+ * @property {string} INTERRUPT - Событие завершения анимации.
+ * @example
+ * 
+ * animation.on(EVENTS.complete, () => console.log('Анимация завершена'))
+ * animation.once(EVENTS.complete, () => console.log('Анимация завершена'))
+ * 
+ * @see {@link Core}
+ */
+export const EVENTS = {
+  PLAY: 'play',
+  STOP: 'stop',
+  BEGIN: 'begin',
+  PAUSE: 'pause',
+  UPDATE: 'update',
+  REPEAT: 'repeat',
+  REVERSE: 'reverse',
+  COMPLETE: 'complete',
+  INTERRUPT: 'interrupt',
+}

package/emitter/Notifier.js

@@ -0,0 +1,97 @@
+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
+  }
+}

package/index.js

@@ -0,0 +1,7 @@
+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'

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "qarl",
+  "version": "1.0.0",
+  "description": "simple animation library",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ThreePixDroid/qarl.git"
+  },
+  "author": "threepixdroid",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ThreePixDroid/qarl/issues"
+  },
+  "homepage": "https://github.com/ThreePixDroid/qarl#readme"
+}