@player-ui/pubsub-plugin 0.4.0 → 0.4.1-next.1

package/dist/index.cjs.js

@@ -2,11 +2,99 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var pubsub = require('pubsub-js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var pubsub__default = /*#__PURE__*/_interopDefaultLegacy(pubsub);
+function splitEvent(event) {
+  return event.split(".").reduce((prev, curr, index) => {
+    if (index === 0) {
+      return [curr];
+    }
+    return [...prev, `${prev[index - 1]}.${curr}`];
+  }, []);
+}
+let count = 1;
+class TinyPubSub {
+  constructor() {
+    this.events = new Map();
+    this.tokens = new Map();
+  }
+  publish(event, ...args) {
+    if (typeof event !== "string") {
+      return;
+    }
+    if (event.includes(".")) {
+      const eventKeys = splitEvent(event);
+      eventKeys.forEach((key) => {
+        this.deliver(key, event, ...args);
+      });
+    } else {
+      this.deliver(event, event, ...args);
+    }
+    this.deliver("*", event, ...args);
+  }
+  subscribe(event, handler) {
+    const uuid = `uuid_${++count}`;
+    if (typeof event === "string") {
+      if (!this.events.has(event)) {
+        this.events.set(event, new Map());
+      }
+      const handlers = this.events.get(event);
+      handlers.set(uuid, handler);
+      this.tokens.set(uuid, event);
+    }
+    return uuid;
+  }
+  unsubscribe(value) {
+    if (typeof value === "string" && value.startsWith("uuid")) {
+      const path = this.tokens.get(value);
+      if (typeof path === "undefined") {
+        return;
+      }
+      const innerPath = this.events.get(path);
+      innerPath == null ? void 0 : innerPath.delete(value);
+      this.tokens.delete(value);
+      return;
+    }
+    if (typeof value === "string") {
+      for (const key of this.events.keys()) {
+        if (key.indexOf(value) === 0) {
+          const tokens = this.events.get(key);
+          if (tokens && tokens.size) {
+            for (const token of tokens.keys()) {
+              this.tokens.delete(token);
+            }
+          }
+          this.events.delete(key);
+        }
+      }
+    }
+  }
+  count(event) {
+    let counter = 0;
+    if (typeof event === "undefined") {
+      for (const handlers2 of this.events.values()) {
+        counter += handlers2.size;
+      }
+      return counter;
+    }
+    const handlers = this.events.get(event);
+    if (handlers == null ? void 0 : handlers.size) {
+      return handlers.size;
+    }
+    return counter;
+  }
+  clear() {
+    this.events.clear();
+    this.tokens.clear();
+  }
+  deliver(path, event, ...args) {
+    const handlers = this.events.get(path);
+    if (handlers && handlers.size) {
+      for (const handler of handlers.values()) {
+        handler(event, ...args);
+      }
+    }
+  }
+}
+const pubsub = new TinyPubSub();
 
 const PubSubPluginSymbol = Symbol.for("PubSubPlugin");
 
@@ -16,29 +104,76 @@ const _PubSubPlugin = class {
     this.symbol = _PubSubPlugin.Symbol;
     var _a;
     this.expressionName = (_a = config == null ? void 0 : config.expressionName) != null ? _a : "publish";
+    this.pubsub = pubsub;
   }
   apply(player) {
+    const existing = player.findPlugin(PubSubPluginSymbol);
+    if (existing !== void 0) {
+      this.pubsub = existing.pubsub;
+    }
     player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
-      expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, data) => {
-        if (typeof event === "string") {
-          this.publish(event, data);
-        }
-      });
+      const existingExpression = expEvaluator.operators.expressions.get(this.expressionName);
+      if (existingExpression) {
+        player.logger.warn(`[PubSubPlugin] expression ${this.expressionName} is already registered.`);
+      } else {
+        expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, ...args) => {
+          if (typeof event === "string") {
+            this.publish(event, ...args);
+          }
+        });
+      }
+    });
+    player.hooks.onEnd.tap(this.name, () => {
+      this.clear();
     });
   }
-  publish(event, data) {
-    pubsub__default["default"].publishSync(event, data);
+  publish(event, ...args) {
+    this.pubsub.publish(event, ...args);
   }
   subscribe(event, handler) {
-    return pubsub__default["default"].subscribe(event, handler);
+    return this.pubsub.subscribe(event, handler);
   }
   unsubscribe(token) {
-    pubsub__default["default"].unsubscribe(token);
+    this.pubsub.unsubscribe(token);
+  }
+  clear() {
+    this.pubsub.clear();
   }
 };
 let PubSubPlugin = _PubSubPlugin;
 PubSubPlugin.Symbol = PubSubPluginSymbol;
 
+function getPubSubPlugin(player) {
+  const existing = player.findPlugin(PubSubPluginSymbol);
+  const plugin = existing || new PubSubPlugin();
+  if (!existing) {
+    player.registerPlugin(plugin);
+  }
+  return plugin;
+}
+
+class PubSubHandlerPlugin {
+  constructor(subscriptions) {
+    this.name = "pubsub-handler";
+    this.subscriptions = subscriptions;
+  }
+  apply(player) {
+    const pubsub = getPubSubPlugin(player);
+    player.hooks.onStart.tap(this.name, () => {
+      this.subscriptions.forEach((handler, key) => {
+        pubsub.subscribe(key, (_, ...args) => {
+          const state = player.getState();
+          if (state.status === "in-progress") {
+            return handler(state, ...args);
+          }
+          player.logger.info(`[PubSubHandlerPlugin] subscriber for ${key} was called when player was not in-progress`);
+        });
+      });
+    });
+  }
+}
+
+exports.PubSubHandlerPlugin = PubSubHandlerPlugin;
 exports.PubSubPlugin = PubSubPlugin;
 exports.PubSubPluginSymbol = PubSubPluginSymbol;
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -1,11 +1,62 @@
-import { PlayerPlugin, Player } from '@player-ui/player';
+import { PlayerPlugin, Player, InProgressState } from '@player-ui/player';
+
+/**
+ * Based off the pubsub-js library and rewritten to match the same used APIs but modified so that
+ * multiple arguments could be passed into the publish and subscription handlers.
+ */
+declare type SubscribeHandler<T extends string, A extends unknown[]> = (type: T, ...args: A) => void;
+/**
+ * Tiny pubsub maker
+ */
+declare class TinyPubSub {
+    private events;
+    private tokens;
+    constructor();
+    /**
+     * Publish an event with any number of additional arguments
+     */
+    publish(event: string, ...args: unknown[]): void;
+    /**
+     * Subscribe to an event
+     *
+     * Events are also heirarchical when separated by a period. Given the following:
+     *
+     * publish('a.b.c', 'one', 'two', 'three)
+     *
+     * The subscribe event will be called when the event is passed as 'a', 'a.b', or 'a.b.c'.
+     *
+     * @example
+     * // subscribes to the top level 'a' publish
+     * subscribe('a', (event, ...args) => console.log(event, ...args))
+     */
+    subscribe(event: string, handler: SubscribeHandler<any, any>): string;
+    /**
+     * Unsubscribes to a specific subscription given it's symbol or an entire
+     * event when passed as a string.
+     *
+     * When existing subscriptions exist for heirarchical events such as 'a.b.c',
+     * when passing an event 'a' to unsubscribe, all subscriptions for 'a', 'a.b',
+     * & 'a.b.c' will be unsubscribed as well.
+     */
+    unsubscribe(value: string | symbol): void;
+    /**
+     * Get the number of subscriptions for a specific event, or when left blank
+     * will return the overall number of subscriptions for the entire pubsub.
+     */
+    count(event?: string): number;
+    /**
+     * Deletes all existing subscriptions
+     */
+    clear(): void;
+    private deliver;
+}
 
 interface PubSubConfig {
     /** A custom expression name to register  */
     expressionName: string;
 }
 /**
- * The PubSubPlugin is a great way to enable your Content content to publish events back to your app
+ * The PubSubPlugin is a great way to enable your FRF content to publish events back to your app
  * It injects a publish() function into the expression language, and will forward all events back to any subscribers.
  *
  * Published/Subscribed events support a hierarchy:
@@ -17,6 +68,7 @@ declare class PubSubPlugin implements PlayerPlugin {
     name: string;
     static Symbol: symbol;
     readonly symbol: symbol;
+    protected pubsub: TinyPubSub;
     private expressionName;
     constructor(config?: PubSubConfig);
     apply(player: Player): void;
@@ -26,7 +78,7 @@ declare class PubSubPlugin implements PlayerPlugin {
      * @param event - The name of the event to publish. Can take sub-topics like: foo.bar
      * @param data - Any additional data to attach to the event
      */
-    publish(event: string, data: unknown): void;
+    publish(event: string, ...args: unknown[]): void;
     /**
      * Subscribe to an event with the given name. The handler will get called for any published event
      *
@@ -34,15 +86,31 @@ declare class PubSubPlugin implements PlayerPlugin {
      * @param handler - A function to be called when the event is triggered
      * @returns A token to be used to unsubscribe from the event
      */
-    subscribe(event: string, handler: (e: string, data: unknown) => void): string;
+    subscribe<T extends string, A extends unknown[]>(event: T, handler: SubscribeHandler<T, A>): string;
     /**
      * Remove any subscriptions using the given token
      *
      * @param token - A token from a `subscribe` call
      */
     unsubscribe(token: string): void;
+    /**
+     * Remove all subscriptions
+     */
+    clear(): void;
 }
 
 declare const PubSubPluginSymbol: unique symbol;
 
-export { PubSubConfig, PubSubPlugin, PubSubPluginSymbol };
+declare type PubSubHandler<T extends unknown[]> = (context: InProgressState, ...args: T) => void;
+declare type SubscriptionMap = Map<string, PubSubHandler<any>>;
+/**
+ * Plugin to easily add subscribers to the PubSubPlugin
+ */
+declare class PubSubHandlerPlugin implements PlayerPlugin {
+    name: string;
+    private subscriptions;
+    constructor(subscriptions: SubscriptionMap);
+    apply(player: Player): void;
+}
+
+export { PubSubConfig, PubSubHandler, PubSubHandlerPlugin, PubSubPlugin, PubSubPluginSymbol, SubscriptionMap };

package/dist/index.esm.js

@@ -1,4 +1,96 @@
-import pubsub from 'pubsub-js';
+function splitEvent(event) {
+  return event.split(".").reduce((prev, curr, index) => {
+    if (index === 0) {
+      return [curr];
+    }
+    return [...prev, `${prev[index - 1]}.${curr}`];
+  }, []);
+}
+let count = 1;
+class TinyPubSub {
+  constructor() {
+    this.events = new Map();
+    this.tokens = new Map();
+  }
+  publish(event, ...args) {
+    if (typeof event !== "string") {
+      return;
+    }
+    if (event.includes(".")) {
+      const eventKeys = splitEvent(event);
+      eventKeys.forEach((key) => {
+        this.deliver(key, event, ...args);
+      });
+    } else {
+      this.deliver(event, event, ...args);
+    }
+    this.deliver("*", event, ...args);
+  }
+  subscribe(event, handler) {
+    const uuid = `uuid_${++count}`;
+    if (typeof event === "string") {
+      if (!this.events.has(event)) {
+        this.events.set(event, new Map());
+      }
+      const handlers = this.events.get(event);
+      handlers.set(uuid, handler);
+      this.tokens.set(uuid, event);
+    }
+    return uuid;
+  }
+  unsubscribe(value) {
+    if (typeof value === "string" && value.startsWith("uuid")) {
+      const path = this.tokens.get(value);
+      if (typeof path === "undefined") {
+        return;
+      }
+      const innerPath = this.events.get(path);
+      innerPath == null ? void 0 : innerPath.delete(value);
+      this.tokens.delete(value);
+      return;
+    }
+    if (typeof value === "string") {
+      for (const key of this.events.keys()) {
+        if (key.indexOf(value) === 0) {
+          const tokens = this.events.get(key);
+          if (tokens && tokens.size) {
+            for (const token of tokens.keys()) {
+              this.tokens.delete(token);
+            }
+          }
+          this.events.delete(key);
+        }
+      }
+    }
+  }
+  count(event) {
+    let counter = 0;
+    if (typeof event === "undefined") {
+      for (const handlers2 of this.events.values()) {
+        counter += handlers2.size;
+      }
+      return counter;
+    }
+    const handlers = this.events.get(event);
+    if (handlers == null ? void 0 : handlers.size) {
+      return handlers.size;
+    }
+    return counter;
+  }
+  clear() {
+    this.events.clear();
+    this.tokens.clear();
+  }
+  deliver(path, event, ...args) {
+    const handlers = this.events.get(path);
+    if (handlers && handlers.size) {
+      for (const handler of handlers.values()) {
+        handler(event, ...args);
+      }
+    }
+  }
+}
+const pubsub = new TinyPubSub();
 
 const PubSubPluginSymbol = Symbol.for("PubSubPlugin");
 
@@ -8,28 +100,74 @@ const _PubSubPlugin = class {
     this.symbol = _PubSubPlugin.Symbol;
     var _a;
     this.expressionName = (_a = config == null ? void 0 : config.expressionName) != null ? _a : "publish";
+    this.pubsub = pubsub;
   }
   apply(player) {
+    const existing = player.findPlugin(PubSubPluginSymbol);
+    if (existing !== void 0) {
+      this.pubsub = existing.pubsub;
+    }
     player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
-      expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, data) => {
-        if (typeof event === "string") {
-          this.publish(event, data);
-        }
-      });
+      const existingExpression = expEvaluator.operators.expressions.get(this.expressionName);
+      if (existingExpression) {
+        player.logger.warn(`[PubSubPlugin] expression ${this.expressionName} is already registered.`);
+      } else {
+        expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, ...args) => {
+          if (typeof event === "string") {
+            this.publish(event, ...args);
+          }
+        });
+      }
+    });
+    player.hooks.onEnd.tap(this.name, () => {
+      this.clear();
     });
   }
-  publish(event, data) {
-    pubsub.publishSync(event, data);
+  publish(event, ...args) {
+    this.pubsub.publish(event, ...args);
   }
   subscribe(event, handler) {
-    return pubsub.subscribe(event, handler);
+    return this.pubsub.subscribe(event, handler);
   }
   unsubscribe(token) {
-    pubsub.unsubscribe(token);
+    this.pubsub.unsubscribe(token);
+  }
+  clear() {
+    this.pubsub.clear();
   }
 };
 let PubSubPlugin = _PubSubPlugin;
 PubSubPlugin.Symbol = PubSubPluginSymbol;
 
-export { PubSubPlugin, PubSubPluginSymbol };
+function getPubSubPlugin(player) {
+  const existing = player.findPlugin(PubSubPluginSymbol);
+  const plugin = existing || new PubSubPlugin();
+  if (!existing) {
+    player.registerPlugin(plugin);
+  }
+  return plugin;
+}
+
+class PubSubHandlerPlugin {
+  constructor(subscriptions) {
+    this.name = "pubsub-handler";
+    this.subscriptions = subscriptions;
+  }
+  apply(player) {
+    const pubsub = getPubSubPlugin(player);
+    player.hooks.onStart.tap(this.name, () => {
+      this.subscriptions.forEach((handler, key) => {
+        pubsub.subscribe(key, (_, ...args) => {
+          const state = player.getState();
+          if (state.status === "in-progress") {
+            return handler(state, ...args);
+          }
+          player.logger.info(`[PubSubHandlerPlugin] subscriber for ${key} was called when player was not in-progress`);
+        });
+      });
+    });
+  }
+}
+
+export { PubSubHandlerPlugin, PubSubPlugin, PubSubPluginSymbol };
 //# sourceMappingURL=index.esm.js.map