@player-ui/pubsub-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,44 @@
+'use strict';
+
+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);
+
+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";
+  }
+  apply(player) {
+    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
+      expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, data) => {
+        if (typeof event === "string") {
+          this.publish(event, data);
+        }
+      });
+    });
+  }
+  publish(event, data) {
+    pubsub__default["default"].publishSync(event, data);
+  }
+  subscribe(event, handler) {
+    return pubsub__default["default"].subscribe(event, handler);
+  }
+  unsubscribe(token) {
+    pubsub__default["default"].unsubscribe(token);
+  }
+};
+let PubSubPlugin = _PubSubPlugin;
+PubSubPlugin.Symbol = PubSubPluginSymbol;
+
+exports.PubSubPlugin = PubSubPlugin;
+exports.PubSubPluginSymbol = PubSubPluginSymbol;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import { PlayerPlugin, Player } from '@player-ui/player';
+
+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
+ * 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'
+ *
+ */
+declare class PubSubPlugin implements PlayerPlugin {
+    name: string;
+    static Symbol: symbol;
+    readonly symbol: symbol;
+    private expressionName;
+    constructor(config?: PubSubConfig);
+    apply(player: Player): void;
+    /**
+     * 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, data: unknown): void;
+    /**
+     * 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(event: string, handler: (e: string, data: unknown) => void): string;
+    /**
+     * Remove any subscriptions using the given token
+     *
+     * @param token - A token from a `subscribe` call
+     */
+    unsubscribe(token: string): void;
+}
+
+declare const PubSubPluginSymbol: unique symbol;
+
+export { PubSubConfig, PubSubPlugin, PubSubPluginSymbol };

package/dist/index.esm.js

@@ -0,0 +1,35 @@
+import pubsub from 'pubsub-js';
+
+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";
+  }
+  apply(player) {
+    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
+      expEvaluator.addExpressionFunction(this.expressionName, (_ctx, event, data) => {
+        if (typeof event === "string") {
+          this.publish(event, data);
+        }
+      });
+    });
+  }
+  publish(event, data) {
+    pubsub.publishSync(event, data);
+  }
+  subscribe(event, handler) {
+    return pubsub.subscribe(event, handler);
+  }
+  unsubscribe(token) {
+    pubsub.unsubscribe(token);
+  }
+};
+let PubSubPlugin = _PubSubPlugin;
+PubSubPlugin.Symbol = PubSubPluginSymbol;
+
+export { PubSubPlugin, PubSubPluginSymbol };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@player-ui/pubsub-plugin",
+  "version": "0.0.1-next.1",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "@player-ui/binding-grammar": "0.0.1-next.1"
+  },
+  "dependencies": {
+    "tapable": "1.1.3",
+    "@types/tapable": "^1.0.5",
+    "pubsub-js": "^1.9.3",
+    "@types/pubsub-js": "^1.8.3",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './pubsub';
+export * from './symbols';

package/src/pubsub.ts

@@ -0,0 +1,74 @@
+import pubsub from 'pubsub-js';
+import type { Player, PlayerPlugin } from '@player-ui/player';
+import type { ExpressionContext } from '@player-ui/expressions';
+import { PubSubPluginSymbol } from './symbols';
+
+export 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
+ * 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;
+
+  private expressionName: string;
+
+  constructor(config?: PubSubConfig) {
+    this.expressionName = config?.expressionName ?? 'publish';
+  }
+
+  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);
+          }
+        }
+      );
+    });
+  }
+
+  /**
+   * 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, data: unknown) {
+    pubsub.publishSync(event, data);
+  }
+
+  /**
+   * 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(event: string, handler: (e: string, data: unknown) => void) {
+    return pubsub.subscribe(event, handler);
+  }
+
+  /**
+   * Remove any subscriptions using the given token
+   *
+   * @param token - A token from a `subscribe` call
+   */
+  unsubscribe(token: string) {
+    pubsub.unsubscribe(token);
+  }
+}

package/src/symbols.ts

@@ -0,0 +1 @@
+export const PubSubPluginSymbol = Symbol.for('PubSubPlugin');