@player-ui/pubsub-plugin 0.3.1-next.0 → 0.3.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

package/dist/pubsub-plugin.dev.js

@@ -0,0 +1,289 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["PubSubPlugin"] = factory();
+	else
+		root["PubSubPlugin"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./bazel-out/k8-fastbuild/bin/plugins/pubsub/core/dist/index.esm.js");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "./bazel-out/k8-fastbuild/bin/plugins/pubsub/core/dist/index.esm.js":
+/*!**************************************************************************!*\
+  !*** ./bazel-out/k8-fastbuild/bin/plugins/pubsub/core/dist/index.esm.js ***!
+  \**************************************************************************/
+/*! exports provided: PubSubHandlerPlugin, PubSubPlugin, PubSubPluginSymbol */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PubSubHandlerPlugin", function() { return PubSubHandlerPlugin; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PubSubPlugin", function() { return PubSubPlugin; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PubSubPluginSymbol", function() { return PubSubPluginSymbol; });
+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");
+
+const _PubSubPlugin = class {
+  constructor(config) {
+    this.name = "pub-sub";
+    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) => {
+      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, ...args) {
+    this.pubsub.publish(event, ...args);
+  }
+  subscribe(event, handler) {
+    return this.pubsub.subscribe(event, handler);
+  }
+  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`);
+        });
+      });
+    });
+  }
+}
+
+
+//# sourceMappingURL=index.esm.js.map
+
+
+/***/ })
+
+/******/ });
+});

package/dist/pubsub-plugin.prod.js

@@ -0,0 +1 @@
+!function(e,t){"object"===typeof exports&&"object"===typeof module?module.exports=t():"function"===typeof define&&define.amd?define([],t):"object"===typeof exports?exports.PubSubPlugin=t():e.PubSubPlugin=t()}(this,(function(){return function(e){var t={};function s(n){if(t[n])return t[n].exports;var i=t[n]={i:n,l:!1,exports:{}};return e[n].call(i.exports,i,i.exports,s),i.l=!0,i.exports}return s.m=e,s.c=t,s.d=function(e,t,n){s.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},s.r=function(e){"undefined"!==typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},s.t=function(e,t){if(1&t&&(e=s(e)),8&t)return e;if(4&t&&"object"===typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(s.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var i in e)s.d(n,i,function(t){return e[t]}.bind(null,i));return n},s.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return s.d(t,"a",t),t},s.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},s.p="",s(s.s=0)}([function(e,t,s){"use strict";s.r(t),s.d(t,"PubSubHandlerPlugin",(function(){return l})),s.d(t,"PubSubPlugin",(function(){return u})),s.d(t,"PubSubPluginSymbol",(function(){return r}));let n=1;const i=new class{constructor(){this.events=new Map,this.tokens=new Map}publish(e,...t){if("string"===typeof e){if(e.includes(".")){const s=function(e){return e.split(".").reduce(((e,t,s)=>0===s?[t]:[...e,`${e[s-1]}.${t}`]),[])}(e);s.forEach((s=>{this.deliver(s,e,...t)}))}else this.deliver(e,e,...t);this.deliver("*",e,...t)}}subscribe(e,t){const s="uuid_"+ ++n;if("string"===typeof e){this.events.has(e)||this.events.set(e,new Map);this.events.get(e).set(s,t),this.tokens.set(s,e)}return s}unsubscribe(e){if("string"===typeof e&&e.startsWith("uuid")){const t=this.tokens.get(e);if("undefined"===typeof t)return;const s=this.events.get(t);return null==s||s.delete(e),void this.tokens.delete(e)}if("string"===typeof e)for(const t of this.events.keys())if(0===t.indexOf(e)){const e=this.events.get(t);if(e&&e.size)for(const t of e.keys())this.tokens.delete(t);this.events.delete(t)}}count(e){let t=0;if("undefined"===typeof e){for(const e of this.events.values())t+=e.size;return t}const s=this.events.get(e);return(null==s?void 0:s.size)?s.size:t}clear(){this.events.clear(),this.tokens.clear()}deliver(e,t,...s){const n=this.events.get(e);if(n&&n.size)for(const i of n.values())i(t,...s)}},r=Symbol.for("PubSubPlugin"),o=class{constructor(e){var t;this.name="pub-sub",this.symbol=o.Symbol,this.expressionName=null!=(t=null==e?void 0:e.expressionName)?t:"publish",this.pubsub=i}apply(e){const t=e.findPlugin(r);void 0!==t&&(this.pubsub=t.pubsub),e.hooks.expressionEvaluator.tap(this.name,(t=>{t.operators.expressions.get(this.expressionName)?e.logger.warn(`[PubSubPlugin] expression ${this.expressionName} is already registered.`):t.addExpressionFunction(this.expressionName,((e,t,...s)=>{"string"===typeof t&&this.publish(t,...s)}))})),e.hooks.onEnd.tap(this.name,(()=>{this.clear()}))}publish(e,...t){this.pubsub.publish(e,...t)}subscribe(e,t){return this.pubsub.subscribe(e,t)}unsubscribe(e){this.pubsub.unsubscribe(e)}clear(){this.pubsub.clear()}};let u=o;u.Symbol=r;class l{constructor(e){this.name="pubsub-handler",this.subscriptions=e}apply(e){const t=function(e){const t=e.findPlugin(r),s=t||new u;return t||e.registerPlugin(s),s}(e);e.hooks.onStart.tap(this.name,(()=>{this.subscriptions.forEach(((s,n)=>{t.subscribe(n,((t,...i)=>{const r=e.getState();if("in-progress"===r.status)return s(r,...i);e.logger.info(`[PubSubHandlerPlugin] subscriber for ${n} was called when player was not in-progress`)}))}))}))}}}])}));

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@player-ui/pubsub-plugin",
-  "version": "0.3.1-next.0",
+  "version": "0.3.1",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {
-    "@player-ui/player": "0.3.1-next.0"
+    "@player-ui/player": "0.3.1"
   },
   "dependencies": {
-    "tapable-ts": "^0.1.0",
+    "tapable-ts": "^0.2.3",
     "pubsub-js": "^1.9.3",
     "@types/pubsub-js": "^1.8.3",
     "@babel/runtime": "7.15.4"
@@ -55,6 +55,15 @@
     {
       "name": "Kelly Harrop",
       "url": "https://github.com/kharrop"
+    },
+    {
+      "name": "Alejandro Fimbres",
+      "url": "https://github.com/lexfm"
+    },
+    {
+      "name": "Rafael Campos",
+      "url": "https://github.com/rafbcampos"
     }
-  ]
+  ],
+  "bundle": "./dist/pubsub-plugin.prod.js"
 }

package/src/handler.ts

@@ -0,0 +1,41 @@
+import type { Player, PlayerPlugin, InProgressState } from '@player-ui/player';
+import { getPubSubPlugin } from './utils';
+
+export type PubSubHandler<T extends unknown[]> = (
+  context: InProgressState,
+  ...args: T
+) => void;
+
+export type SubscriptionMap = Map<string, PubSubHandler<any>>;
+
+/**
+ * Plugin to easily add subscribers to the PubSubPlugin
+ */
+export class PubSubHandlerPlugin implements PlayerPlugin {
+  name = 'pubsub-handler';
+  private subscriptions: SubscriptionMap;
+
+  constructor(subscriptions: SubscriptionMap) {
+    this.subscriptions = subscriptions;
+  }
+
+  apply(player: 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`
+          );
+        });
+      });
+    });
+  }
+}

package/src/index.ts

@@ -1,2 +1,3 @@
-export * from './pubsub';
+export * from './plugin';
 export * from './symbols';
+export * from './handler';

package/src/plugin.ts

@@ -0,0 +1,112 @@
+import type {
+  Player,
+  PlayerPlugin,
+  ExpressionContext,
+} from '@player-ui/player';
+import type { SubscribeHandler, TinyPubSub } from './pubsub';
+import { pubsub } from './pubsub';
+import { PubSubPluginSymbol } from './symbols';
+
+export interface PubSubConfig {
+  /** A custom expression name to register  */
+  expressionName: string;
+}
+
+/**
+ * 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:
+ * - publish('foo', 'data') -- will trigger any listeners for 'foo'
+ * - publish('foo.bar', 'data') -- will trigger any listeners for 'foo' or 'foo.bar'
+ *
+ */
+export class PubSubPlugin implements PlayerPlugin {
+  name = 'pub-sub';
+
+  static Symbol = PubSubPluginSymbol;
+  public readonly symbol = PubSubPlugin.Symbol;
+
+  protected pubsub: TinyPubSub;
+
+  private expressionName: string;
+
+  constructor(config?: PubSubConfig) {
+    this.expressionName = config?.expressionName ?? 'publish';
+    this.pubsub = pubsub;
+  }
+
+  apply(player: Player) {
+    // if there is already a pubsub plugin, reuse its pubsub instance
+    // to maintain the singleton across bundles for iOS/Android
+    const existing = player.findPlugin<PubSubPlugin>(PubSubPluginSymbol);
+    if (existing !== undefined) {
+      this.pubsub = existing.pubsub;
+    }
+
+    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
+      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: ExpressionContext, event: unknown, ...args: unknown[]) => {
+            if (typeof event === 'string') {
+              this.publish(event, ...args);
+            }
+          }
+        );
+      }
+    });
+
+    player.hooks.onEnd.tap(this.name, () => {
+      this.clear();
+    });
+  }
+
+  /**
+   * A way of publishing an event, notifying any listeners
+   *
+   * @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, ...args: unknown[]) {
+    this.pubsub.publish(event, ...args);
+  }
+
+  /**
+   * Subscribe to an event with the given name. The handler will get called for any published event
+   *
+   * @param event - The name of the event to subscribe to
+   * @param handler - A function to be called when the event is triggered
+   * @returns A token to be used to unsubscribe from the event
+   */
+  subscribe<T extends string, A extends unknown[]>(
+    event: T,
+    handler: SubscribeHandler<T, A>
+  ) {
+    return this.pubsub.subscribe(event, handler);
+  }
+
+  /**
+   * Remove any subscriptions using the given token
+   *
+   * @param token - A token from a `subscribe` call
+   */
+  unsubscribe(token: string) {
+    this.pubsub.unsubscribe(token);
+  }
+
+  /**
+   * Remove all subscriptions
+   */
+  clear() {
+    this.pubsub.clear();
+  }
+}

package/src/pubsub.ts

@@ -1,77 +1,173 @@
-import pubsub from 'pubsub-js';
-import type {
-  Player,
-  PlayerPlugin,
-  ExpressionContext,
-} from '@player-ui/player';
-import { PubSubPluginSymbol } from './symbols';
-
-export interface PubSubConfig {
-  /** A custom expression name to register  */
-  expressionName: string;
-}
+/**
+ * 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.
+ */
+
+export type SubscribeHandler<T extends string, A extends unknown[]> = (
+  type: T,
+  ...args: A
+) => void;
+
+export type PubSubUUID = `uuid_${number}`;
 
 /**
- * The PubSubPlugin is a great way to enable your Content 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:
- * - publish('foo', 'data') -- will trigger any listeners for 'foo'
- * - publish('foo.bar', 'data') -- will trigger any listeners for 'foo' or 'foo.bar'
- *
+ * Split a string into an array of event layers
  */
-export class PubSubPlugin implements PlayerPlugin {
-  name = 'pub-sub';
+function splitEvent(event: string) {
+  return event.split('.').reduce<string[]>((prev, curr, index) => {
+    if (index === 0) {
+      return [curr];
+    }
 
-  static Symbol = PubSubPluginSymbol;
-  public readonly symbol = PubSubPlugin.Symbol;
+    return [...prev, `${prev[index - 1]}.${curr}`];
+  }, []);
+}
 
-  private expressionName: string;
+let count = 1;
 
-  constructor(config?: PubSubConfig) {
-    this.expressionName = config?.expressionName ?? 'publish';
+/**
+ * Tiny pubsub maker
+ */
+export class TinyPubSub {
+  private events: Map<string, Map<PubSubUUID, SubscribeHandler<any, any>>>;
+  private tokens: Map<PubSubUUID, string>;
+
+  constructor() {
+    this.events = new Map();
+    this.tokens = new Map();
   }
 
-  apply(player: Player) {
-    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
-      expEvaluator.addExpressionFunction(
-        this.expressionName,
-        (_ctx: ExpressionContext, event: unknown, data: unknown) => {
-          if (typeof event === 'string') {
-            this.publish(event, data);
-          }
-        }
-      );
-    });
+  /**
+   * Publish an event with any number of additional arguments
+   */
+  publish(event: string, ...args: unknown[]) {
+    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);
   }
 
   /**
-   * A way of publishing an event, notifying any listeners
+   * Subscribe to an event
+   *
+   * Events are also heirarchical when separated by a period. Given the following:
    *
-   * @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('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))
    */
-  publish(event: string, data: unknown) {
-    pubsub.publishSync(event, data);
+  subscribe(event: string, handler: SubscribeHandler<any, any>) {
+    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 as PubSubUUID, handler);
+      this.tokens.set(uuid as PubSubUUID, event);
+    }
+
+    return uuid;
   }
 
   /**
-   * Subscribe to an event with the given name. The handler will get called for any published event
+   * Unsubscribes to a specific subscription given it's symbol or an entire
+   * event when passed as a string.
    *
-   * @param event - The name of the event to subscribe to
-   * @param handler - A function to be called when the event is triggered
-   * @returns A token to be used to unsubscribe from the event
+   * 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.
    */
-  subscribe(event: string, handler: (e: string, data: unknown) => void) {
-    return pubsub.subscribe(event, handler);
+  unsubscribe(value: string | symbol) {
+    if (typeof value === 'string' && value.startsWith('uuid')) {
+      const path = this.tokens.get(value as PubSubUUID);
+
+      if (typeof path === 'undefined') {
+        return;
+      }
+
+      const innerPath = this.events.get(path);
+      innerPath?.delete(value as PubSubUUID);
+      this.tokens.delete(value as PubSubUUID);
+      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) {
+            // eslint-disable-next-line max-depth
+            for (const token of tokens.keys()) {
+              this.tokens.delete(token);
+            }
+          }
+
+          this.events.delete(key);
+        }
+      }
+    }
   }
 
   /**
-   * Remove any subscriptions using the given token
-   *
-   * @param token - A token from a `subscribe` call
+   * Get the number of subscriptions for a specific event, or when left blank
+   * will return the overall number of subscriptions for the entire pubsub.
    */
-  unsubscribe(token: string) {
-    pubsub.unsubscribe(token);
+  count(event?: string) {
+    let counter = 0;
+
+    if (typeof event === 'undefined') {
+      for (const handlers of this.events.values()) {
+        counter += handlers.size;
+      }
+
+      return counter;
+    }
+
+    const handlers = this.events.get(event);
+
+    if (handlers?.size) {
+      return handlers.size;
+    }
+
+    return counter;
+  }
+
+  /**
+   * Deletes all existing subscriptions
+   */
+  clear() {
+    this.events.clear();
+    this.tokens.clear();
+  }
+
+  private deliver(path: string, event: string, ...args: unknown[]) {
+    const handlers = this.events.get(path);
+
+    if (handlers && handlers.size) {
+      for (const handler of handlers.values()) {
+        handler(event, ...args);
+      }
+    }
   }
 }
+
+export const pubsub = new TinyPubSub();

package/src/utils.ts

@@ -0,0 +1,17 @@
+import type { Player } from '@player-ui/player';
+import { PubSubPlugin } from './plugin';
+import { PubSubPluginSymbol } from './symbols';
+
+/**
+ * Returns the existing PubSubPlugin or creates and registers a new plugin
+ */
+export function getPubSubPlugin(player: Player) {
+  const existing = player.findPlugin<PubSubPlugin>(PubSubPluginSymbol);
+  const plugin = existing || new PubSubPlugin();
+
+  if (!existing) {
+    player.registerPlugin(plugin);
+  }
+
+  return plugin;
+}