bard-legends-framework 0.12.1 → 1.0.0-rc1

package/dist/lib/animator/index.js

@@ -1,24 +0,0 @@
-var __createBinding =
-  (this && this.__createBinding) ||
-  (Object.create
-    ? (o, m, k, k2) => {
-        if (k2 === undefined) k2 = k;
-        var desc = Object.getOwnPropertyDescriptor(m, k);
-        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-          desc = { enumerable: true, get: () => m[k] };
-        }
-        Object.defineProperty(o, k2, desc);
-      }
-    : (o, m, k, k2) => {
-        if (k2 === undefined) k2 = k;
-        o[k2] = m[k];
-      });
-var __exportStar =
-  (this && this.__exportStar) ||
-  ((m, exports) => {
-    for (var p in m) if (p !== 'default' && !Object.hasOwn(exports, p)) __createBinding(exports, m, p);
-  });
-Object.defineProperty(exports, '__esModule', { value: true });
-__exportStar(require('./animator'), exports);
-__exportStar(require('./animations'), exports);
-//# sourceMappingURL=index.js.map

package/dist/lib/libraries/animator/animations.d.ts

@@ -1,25 +0,0 @@
-export interface AnimatorAnimation {
-  start(): void;
-  multiplierFunction(t: number): number;
-}
-export declare class AnimationLineer implements AnimatorAnimation {
-  start(): void;
-  multiplierFunction(t: number): number;
-}
-export declare class AnimationEaseInOut implements AnimatorAnimation {
-  start(): void;
-  multiplierFunction(t: number): number;
-}
-export declare class AnimationEaseIn implements AnimatorAnimation {
-  start(): void;
-  multiplierFunction(t: number): number;
-}
-export declare class AnimationEaseOut implements AnimatorAnimation {
-  start(): void;
-  multiplierFunction(t: number): number;
-}
-export declare class AnimationFlicker implements AnimatorAnimation {
-  private timeGrid;
-  start(): void;
-  multiplierFunction(t: number): number;
-}

package/dist/lib/libraries/animator/animations.js

@@ -1,61 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.AnimationFlicker =
-  exports.AnimationEaseOut =
-  exports.AnimationEaseIn =
-  exports.AnimationEaseInOut =
-  exports.AnimationLineer =
-    void 0;
-const helpers_lib_1 = require('helpers-lib');
-class AnimationLineer {
-  start() {}
-  multiplierFunction(t) {
-    return t;
-  }
-}
-exports.AnimationLineer = AnimationLineer;
-class AnimationEaseInOut {
-  start() {}
-  multiplierFunction(t) {
-    if ((t *= 2) < 1) {
-      return 0.5 * t * t;
-    } else {
-      return -0.5 * (--t * (t - 2) - 1);
-    }
-  }
-}
-exports.AnimationEaseInOut = AnimationEaseInOut;
-class AnimationEaseIn {
-  start() {}
-  multiplierFunction(t) {
-    return t ** 2;
-  }
-}
-exports.AnimationEaseIn = AnimationEaseIn;
-class AnimationEaseOut {
-  start() {}
-  multiplierFunction(t) {
-    return 1 - (1 - t) ** 2;
-  }
-}
-exports.AnimationEaseOut = AnimationEaseOut;
-class AnimationFlicker {
-  start() {
-    this.timeGrid = new Array(10).fill(0);
-    helpers_lib_1.Random.randomIntegerBetween(0, 9);
-    this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-    if (Math.random() < 0.3) {
-      helpers_lib_1.Random.randomIntegerBetween(0, 9);
-      this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-    }
-    if (Math.random() < 0.2) {
-      helpers_lib_1.Random.randomIntegerBetween(0, 9);
-      this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-    }
-  }
-  multiplierFunction(t) {
-    const index = Math.floor(t * 10);
-    return this.timeGrid[index];
-  }
-}
-exports.AnimationFlicker = AnimationFlicker;
-//# sourceMappingURL=animations.js.map

package/dist/lib/libraries/animator/animator.d.ts

@@ -1,52 +0,0 @@
-import { AnimatorAnimation } from './animations';
-export interface AnimationState {
-  duration: number;
-  elapsedTime: number;
-  startingValue: number;
-  targetValue: number;
-  loop: boolean;
-  completeAnimationsHandling: CompleteAnimationsHandlingType;
-}
-export declare enum ReAnimateHandlingType {
-  throwError = 'throwError',
-  ignore = 'ignore'
-}
-export declare enum CompleteAnimationsHandlingType {
-  returnToOriginal = 'returnToOriginal',
-  stayInCurrentState = 'stayInCurrentState',
-  jumpToEnd = 'jumpToEnd'
-}
-export interface AnimationOptions<T> {
-  duration?: number;
-  animation?: AnimatorAnimation;
-  loop?: boolean;
-  reAnimateHandling?: ReAnimateHandlingType;
-  completeAnimationsHandling?: CompleteAnimationsHandlingType;
-}
-export declare class Animator<T> {
-  private static animatedObjects;
-  readonly targetObject: T;
-  private effectOn;
-  private defaultDuration;
-  private defaultAnimation;
-  private defaultLoop;
-  private defaultReAnimateHandling;
-  private defaultCompleteAnimationsHandling;
-  private onChangeCallback?;
-  private running;
-  private propertyStates;
-  private updateCycleSubscription;
-  constructor(target: T, effectOn: string | string[], options?: AnimationOptions<T>);
-  get isAnimating(): boolean;
-  getAnimationStateOfKey(key: string): AnimationState | undefined;
-  onChange(callback: (target: T) => void): Animator<T>;
-  pauseAnimations(): void;
-  resumeAnimations(): void;
-  completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
-  set(values: Record<string, any>): void;
-  animate(values: Record<string, any>, options?: AnimationOptions<T>): Promise<void>;
-  private startAnimate;
-  private update;
-  private subscribeUpdateCycle;
-  private checkPropertyValidity;
-}

package/dist/lib/libraries/animator/animator.js

@@ -1,219 +0,0 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
-const helpers_lib_1 = require('helpers-lib');
-const update_loop_1 = require('../../../game-entities/update-loop');
-const animations_1 = require('./animations');
-var ReAnimateHandlingType;
-(ReAnimateHandlingType => {
-  ReAnimateHandlingType['throwError'] = 'throwError';
-  ReAnimateHandlingType['ignore'] = 'ignore';
-  // TODO: blendIn
-})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
-var CompleteAnimationsHandlingType;
-(CompleteAnimationsHandlingType => {
-  CompleteAnimationsHandlingType['returnToOriginal'] = 'returnToOriginal';
-  CompleteAnimationsHandlingType['stayInCurrentState'] = 'stayInCurrentState';
-  CompleteAnimationsHandlingType['jumpToEnd'] = 'jumpToEnd';
-})(CompleteAnimationsHandlingType || (exports.CompleteAnimationsHandlingType = CompleteAnimationsHandlingType = {}));
-const DEFAULT_DURATION = 200;
-const DEFAULT_ANIMATION = new animations_1.AnimationLineer();
-const DEFAULT_LOOP = false;
-const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
-const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
-class Animator {
-  static {
-    Animator.animatedObjects = new Set();
-  }
-  constructor(target, effectOn, options = {}) {
-    this.effectOn = new Set();
-    this.running = true;
-    this.propertyStates = new Map();
-    if (!helpers_lib_1.Comparator.isObject(target)) {
-      throw new Error(`Animator: target is not an object! Target: '${target}'`);
-    } else if (Animator.animatedObjects.has(target)) {
-      throw new Error(`Animator: target is already animated! Target: '${target}'`);
-    } else {
-      Animator.animatedObjects.add(target);
-    }
-    this.targetObject = target;
-    this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
-    this.defaultDuration = options.duration || DEFAULT_DURATION;
-    this.defaultAnimation = options.animation || DEFAULT_ANIMATION;
-    this.defaultLoop = options.loop || DEFAULT_LOOP;
-    this.defaultReAnimateHandling = options.reAnimateHandling || DEFAULT_RE_ANIMATE_HANDLING;
-    this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling || DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
-    this.effectOn.forEach(key => {
-      if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
-        throw new Error(`Animator: target does not have target property. Target property: '${key}'`);
-      } else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
-        throw new Error(`Animator: target property is not a number. Target property: '${key}'`);
-      }
-    });
-  }
-  get isAnimating() {
-    return this.propertyStates.size > 0;
-  }
-  getAnimationStateOfKey(key) {
-    const propertyState = this.propertyStates.get(key);
-    if (propertyState) {
-      return {
-        duration: propertyState.duration,
-        elapsedTime: propertyState.elapsedTime,
-        startingValue: propertyState.startingValue,
-        targetValue: propertyState.targetValue,
-        loop: propertyState.loop,
-        completeAnimationsHandling: propertyState.completeAnimationsHandling
-      };
-    }
-  }
-  onChange(callback) {
-    if (this.onChangeCallback) {
-      throw new Error('Animator: onChangeCallback is already set!');
-    }
-    this.onChangeCallback = callback;
-    return this;
-  }
-  pauseAnimations() {
-    this.running = false;
-  }
-  resumeAnimations() {
-    this.running = true;
-  }
-  completeAnimations(completeAnimationsHandling) {
-    const triggerOnChange = this.isAnimating;
-    this.propertyStates.forEach((value, key) => {
-      const completeAnimationsHandlingFinal = completeAnimationsHandling || value.completeAnimationsHandling;
-      if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
-        this.targetObject[key] = value.startingValue;
-      } else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
-        this.targetObject[key] = value.targetValue;
-      }
-      value.completionCallback();
-      this.propertyStates.delete(key);
-    });
-    triggerOnChange && this.onChangeCallback?.(this.targetObject);
-  }
-  set(values) {
-    Object.keys(values).forEach(key => {
-      this.checkPropertyValidity(key);
-      if (this.propertyStates.get(key)) {
-        throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-      }
-    });
-    let triggerOnChange = false;
-    Object.keys(values).forEach(key => {
-      triggerOnChange = triggerOnChange || this.targetObject[key] !== values[key];
-      this.targetObject[key] = values[key];
-    });
-    triggerOnChange && this.onChangeCallback?.(this.targetObject);
-  }
-  async animate(values, options = {}) {
-    const valueKeys = Object.keys(values);
-    valueKeys.forEach(key => {
-      this.checkPropertyValidity(key);
-    });
-    return this.startAnimate(values, options);
-  }
-  startAnimate(values, options = {}) {
-    const reAnimateHandling = options.reAnimateHandling || this.defaultReAnimateHandling;
-    Object.keys(values).forEach(key => {
-      const previousState = this.propertyStates.get(key);
-      if (previousState) {
-        if (reAnimateHandling === ReAnimateHandlingType.throwError) {
-          throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-        } else if (reAnimateHandling === ReAnimateHandlingType.ignore) {
-          delete values[key];
-        }
-      }
-    });
-    return new Promise(resolveAll => {
-      Promise.all(
-        Object.keys(values).map(
-          key =>
-            new Promise(resolve => {
-              const duration = options.duration || this.defaultDuration;
-              const animation = options.animation || this.defaultAnimation;
-              const loop = options.loop || this.defaultLoop;
-              const completeAnimationsHandling = options.completeAnimationsHandling || this.defaultCompleteAnimationsHandling;
-              animation.start();
-              try {
-                this.propertyStates.set(key, {
-                  duration,
-                  animation,
-                  elapsedTime: 0,
-                  startingValue: this.targetObject[key],
-                  targetValue: values[key],
-                  loop,
-                  completeAnimationsHandling,
-                  completionCallback: () => {
-                    resolve(undefined);
-                  }
-                });
-              } catch (e) {
-                resolveAll();
-              }
-            })
-        )
-      ).then(() => {
-        resolveAll();
-      });
-      this.subscribeUpdateCycle();
-    });
-  }
-  update(delta) {
-    if (this.running) {
-      const triggerOnChange = this.propertyStates.size;
-      this.propertyStates.forEach((value, key) => {
-        value.elapsedTime += delta;
-        let animationIsCompete = value.elapsedTime >= value.duration;
-        if (animationIsCompete) {
-          if (value.loop) {
-            value.animation.start();
-            value.elapsedTime -= value.duration;
-            animationIsCompete = false;
-          } else {
-            if (value.completeAnimationsHandling === CompleteAnimationsHandlingType.returnToOriginal) {
-              this.targetObject[key] = value.startingValue;
-            } else {
-              this.targetObject[key] = value.targetValue;
-            }
-            value.completionCallback();
-            this.propertyStates.delete(key);
-          }
-        }
-        if (!animationIsCompete) {
-          const multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
-          const relativeTarget = value.targetValue - value.startingValue;
-          this.targetObject[key] = relativeTarget * multiplier + value.startingValue;
-        }
-      });
-      triggerOnChange && this.onChangeCallback?.(this.targetObject);
-      if (this.propertyStates.size <= 0) {
-        this.updateCycleSubscription?.unsubscribe();
-      }
-    }
-  }
-  subscribeUpdateCycle() {
-    this.updateCycleSubscription?.unsubscribe();
-    this.updateCycleSubscription = update_loop_1.UpdateCycle.updateAction
-      .subscribe(update => {
-        try {
-          this.update(update.delta);
-        } catch (e) {
-          this.propertyStates.forEach(value => {
-            value.completionCallback();
-          });
-          this.propertyStates = new Map();
-          this.updateCycleSubscription?.unsubscribe();
-        }
-      })
-      .skipAttachCheck();
-  }
-  checkPropertyValidity(key) {
-    if (!this.effectOn.has(key)) {
-      throw new Error(`Animator: not effected property is tried to update. Key: '${key}', EffectOn: '${this.effectOn}'`);
-    }
-  }
-}
-exports.Animator = Animator;
-//# sourceMappingURL=animator.js.map

package/dist/lib/libraries/animator/animator.spec.d.ts

@@ -1 +0,0 @@
-export {};