EventTrigger.ts

  1. import { isObject, isArray, toArray } from "@daybrush/utils";
  2. import { CallbackType, EventParameter } from "./types";
  4. /**
  5. * attach and trigger event handlers.
  6. */
  7. class EventTrigger {
  8.     public events: { [name: string]: CallbackType[] };
  9.     /**
  10.       * @example
  11.   const et = new Scene.EventTrigger();
  12.   const scene = new Scene();
  14.   scene.on("call", e => {
  15.       console.log(e.param);
  16.   });
  17.   et.on("call", e => {
  18.       console.log(e.param);
  19.   });
  20.   scene.trigger("call", {param: 1});
  21.   et.trigger("call", {param: 1});
  22.        */
  23.     constructor() {
  24.         this.events = {};
  25.     }
  26.     public _on(name: string | EventParameter, callback?: CallbackType | CallbackType[], once?: boolean) {
  27.         const events = this.events;
  29.         if (isObject(name)) {
  30.             for (const n in name) {
  31.                 this._on(n, name[n], once);
  32.             }
  33.             return;
  34.         }
  35.         if (!(name in events)) {
  36.             events[name] = [];
  37.         }
  38.         if (!callback) {
  39.             return;
  40.         }
  41.         if (isArray(callback)) {
  42.             callback.forEach(func => this._on(name, func, once));
  43.             return;
  44.         }
  45.         events[name].push(once ? function callback2(...args) {
  46.             callback(...args);
  47.             this.off(name, callback2);
  48.         } : callback);
  49.     }
  50.     /**
  51.       * Attach an event handler function for one or more events to target
  52.       * @param - event's name
  53.       * @param - function to execute when the event is triggered.
  54.       * @return {EventTrigger} An Instance itself.
  55.       * @example
  56.   target.on("animate", function() {
  57.       console.log("animate");
  58.   });
  60.   target.trigger("animate");
  62.     */
  63.     public on(name: string | EventParameter, callback?: CallbackType | CallbackType[]) {
  64.         this._on(name, callback);
  65.         return this;
  66.     }
  67.     /**
  68.       * Dettach an event handler function for one or more events to target
  69.       * @param - event's name
  70.       * @param -  function to execute when the event is triggered.
  71.       * @return {EventTrigger} An Instance itself.
  72.       * @example
  73.   const callback = function() {
  74.       console.log("animate");
  75.   };
  76.   target.on("animate", callback);
  78.   target.off("animate", callback);
  79.   target.off("animate");
  81.       */
  82.     public off(name?: string, callback?: CallbackType) {
  83.         if (!name) {
  84.             this.events = {};
  85.         } else if (!callback) {
  86.             this.events[name] = [];
  87.         } else {
  88.             const callbacks = this.events[name];
  90.             if (!callbacks) {
  91.                 return this;
  92.             }
  93.             const index = callbacks.indexOf(callback);
  95.             if (index !== -1) {
  96.                 callbacks.splice(index, 1);
  97.             }
  98.         }
  99.         return this;
  100.     }
  101.     /**
  102.       * execute event handler
  103.       * @param - event's name
  104.       * @param - event handler's additional parameter
  105.       * @return {EventTrigger} An Instance itself.
  106.       * @example
  107.   target.on("animate", function(a1, a2) {
  108.       console.log("animate", a1, a2);
  109.   });
  111.   target.trigger("animate", [1, 2]); // log => "animate", 1, 2
  113.       */
  114.     public trigger(name: string, ...data: any[]) {
  115.         const events = this.events;
  117.         if (!(name in events)) {
  118.             return this;
  119.         }
  121.         const args = data || [];
  123.         !args[0] && (args[0] = {});
  124.         const event = events[name];
  125.         const target = args[0];
  127.         target.type = name;
  128.         target.currentTarget = this;
  129.         !target.target && (target.target = this);
  130.         toArray(events[name]).forEach(callback => {
  131.             callback.apply(this, data);
  132.         });
  134.         return this;
  135.     }
  136.     public once(name: string | EventParameter, callback?: CallbackType | CallbackType[]) {
  137.         this._on(name, callback, true);
  138.         return this;
  139.     }
  140. }
  141. export default EventTrigger;