@player-ui/pubsub-plugin 0.8.0--canary.307.9645 → 0.8.0-next.2

package/src/__test__/pubsub.test.ts

@@ -0,0 +1,309 @@
+import { describe, test, it, beforeEach, expect, vitest } from "vitest";
+import { pubsub } from "../pubsub";
+
+describe("pubsub", () => {
+  beforeEach(() => {
+    pubsub.clear();
+  });
+
+  it("should call subscriber with single argument", () => {
+    const type = "test";
+    const message = "this is a test message";
+    const spy = vitest.fn();
+
+    pubsub.subscribe(type, spy);
+    pubsub.publish(type, message);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(type, message);
+  });
+
+  it("should increment uuid with each subscribe", () => {
+    const type = "test";
+    const message = "this is a test message";
+    const spy = vitest.fn();
+
+    const sub1 = pubsub.subscribe(type, spy);
+    const sub2 = pubsub.subscribe(type, spy);
+    const sub3 = pubsub.subscribe(type, spy);
+    pubsub.publish(type, message);
+
+    expect(sub1).not.toStrictEqual(sub2);
+    expect(sub1).not.toStrictEqual(sub3);
+    expect(sub2).not.toStrictEqual(sub3);
+  });
+
+  it("should call subscriber with multiple argument", () => {
+    const type = "test";
+    const spy = vitest.fn();
+
+    pubsub.subscribe(type, spy);
+    pubsub.publish(type, 1, "two", "three");
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(type, 1, "two", "three");
+  });
+
+  it("should handle different argument types", () => {
+    const type = "test";
+    const spy = vitest.fn();
+
+    pubsub.subscribe(type, spy);
+    pubsub.publish(type, "one", 2, undefined, null, true, false);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+    expect(spy).toHaveBeenCalledWith(
+      type,
+      "one",
+      2,
+      undefined,
+      null,
+      true,
+      false,
+    );
+  });
+
+  it("should call all subscribers only once", () => {
+    const type = "test";
+    const message = "this is a test message";
+    const first = vitest.fn();
+    const second = vitest.fn();
+
+    pubsub.subscribe(type, first);
+    pubsub.subscribe(type, second);
+
+    pubsub.publish(type, message);
+
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(first).toHaveBeenCalledWith(type, message);
+    expect(second).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledWith(type, message);
+  });
+
+  it("should call only subscribers of event", () => {
+    const message = "this is a test message";
+    const first = vitest.fn();
+    const second = vitest.fn();
+
+    pubsub.subscribe("first", first);
+    pubsub.subscribe("second", second);
+
+    pubsub.publish("first", message);
+
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(first).toHaveBeenCalledWith("first", message);
+    expect(second).not.toHaveBeenCalled();
+  });
+
+  it("should call subscriber for all publish types", () => {
+    const spy = vitest.fn();
+
+    pubsub.subscribe("*", spy);
+
+    pubsub.publish("one", "one");
+    pubsub.publish("two", "two");
+    pubsub.publish("three", "three");
+
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy).toHaveBeenNthCalledWith(1, "one", "one");
+    expect(spy).toHaveBeenNthCalledWith(2, "two", "two");
+    expect(spy).toHaveBeenNthCalledWith(3, "three", "three");
+  });
+
+  it("should call all levels of subscribers only once", () => {
+    const level1 = vitest.fn();
+    const level2 = vitest.fn();
+    const level3 = vitest.fn();
+
+    pubsub.subscribe("foo", level1);
+    pubsub.subscribe("foo.bar", level2);
+    pubsub.subscribe("foo.bar.baz", level3);
+
+    pubsub.publish("foo.bar.baz", "one", "two", "three");
+
+    expect(level1).toHaveBeenCalledTimes(1);
+    expect(level2).toHaveBeenCalledTimes(1);
+    expect(level3).toHaveBeenCalledTimes(1);
+    expect(level1).toHaveBeenCalledWith("foo.bar.baz", "one", "two", "three");
+    expect(level2).toHaveBeenCalledWith("foo.bar.baz", "one", "two", "three");
+    expect(level3).toHaveBeenCalledWith("foo.bar.baz", "one", "two", "three");
+  });
+
+  it("should return unique symbols for each subscribe", () => {
+    const spy = vitest.fn();
+    const spy2 = vitest.fn();
+
+    const token1 = pubsub.subscribe("test", spy);
+    const token2 = pubsub.subscribe("test", spy);
+    const token3 = pubsub.subscribe("test", spy2);
+
+    const symbols = new Set([token1, token2, token3]);
+    expect(symbols.size).toBe(3);
+  });
+
+  it(`shouldn't error if subscribing to non string value`, () => {
+    const spy = vitest.fn();
+    pubsub.subscribe(true as any, spy);
+    pubsub.publish(true as any, "test");
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it("should remove handler with token", () => {
+    const type = "test";
+    const spy = vitest.fn();
+    const token = pubsub.subscribe(type, spy);
+
+    expect(pubsub.count()).toBe(1);
+    expect(pubsub.count(type)).toBe(1);
+
+    pubsub.unsubscribe(token);
+
+    expect(pubsub.count()).toBe(0);
+    expect(pubsub.count(type)).toBe(0);
+  });
+
+  it("should only remove handler with passed token", () => {
+    const type = "test";
+    const spy1 = vitest.fn();
+    const spy2 = vitest.fn();
+    const token1 = pubsub.subscribe(type, spy1);
+    const token2 = pubsub.subscribe(type, spy2);
+
+    expect(pubsub.count()).toBe(2);
+    expect(pubsub.count(type)).toBe(2);
+
+    pubsub.unsubscribe(token1);
+
+    expect(pubsub.count()).toBe(1);
+    expect(pubsub.count(type)).toBe(1);
+
+    pubsub.unsubscribe(token2);
+
+    expect(pubsub.count()).toBe(0);
+    expect(pubsub.count(type)).toBe(0);
+  });
+
+  it("should remove all handlers for type", () => {
+    const type = "test";
+    const spy1 = vitest.fn();
+    const spy2 = vitest.fn();
+    pubsub.subscribe(type, spy1);
+    pubsub.subscribe(type, spy2);
+
+    expect(pubsub.count()).toBe(2);
+    expect(pubsub.count(type)).toBe(2);
+
+    expect(pubsub.tokens.size).toBe(2);
+
+    pubsub.unsubscribe(type);
+
+    expect(pubsub.count()).toBe(0);
+    expect(pubsub.count(type)).toBe(0);
+
+    expect(pubsub.tokens.size).toBe(0);
+  });
+
+  it("should remove all nested handlers for type", () => {
+    const spy1 = vitest.fn();
+    const spy2 = vitest.fn();
+    const spy3 = vitest.fn();
+    pubsub.subscribe("foo", spy1);
+    pubsub.subscribe("foo.bar", spy2);
+    pubsub.subscribe("foo.bar.baz", spy3);
+
+    expect(pubsub.count()).toBe(3);
+    expect(pubsub.count("foo")).toBe(1);
+    expect(pubsub.count("foo.bar")).toBe(1);
+    expect(pubsub.count("foo.bar.baz")).toBe(1);
+
+    expect(pubsub.tokens.size).toBe(3);
+
+    pubsub.unsubscribe("foo");
+
+    expect(pubsub.count()).toBe(0);
+    expect(pubsub.count("foo")).toBe(0);
+    expect(pubsub.count("foo.bar")).toBe(0);
+    expect(pubsub.count("foo.bar.baz")).toBe(0);
+
+    expect(pubsub.tokens.size).toBe(0);
+  });
+
+  it("should keep top layer for type", () => {
+    const spy1 = vitest.fn();
+    const spy2 = vitest.fn();
+    const spy3 = vitest.fn();
+    pubsub.subscribe("foo", spy1);
+    pubsub.subscribe("foo.bar", spy2);
+    pubsub.subscribe("foo.bar.baz", spy3);
+
+    expect(pubsub.count()).toBe(3);
+    expect(pubsub.count("foo")).toBe(1);
+    expect(pubsub.count("foo.bar")).toBe(1);
+    expect(pubsub.count("foo.bar.baz")).toBe(1);
+
+    expect(pubsub.tokens.size).toBe(3);
+
+    pubsub.unsubscribe("foo.bar");
+
+    expect(pubsub.count()).toBe(1);
+    expect(pubsub.count("foo")).toBe(1);
+    expect(pubsub.count("foo.bar")).toBe(0);
+    expect(pubsub.count("foo.bar.baz")).toBe(0);
+
+    expect(pubsub.tokens.size).toBe(1);
+  });
+
+  it("should only delete deeply nested type", () => {
+    const spy1 = vitest.fn();
+    const spy2 = vitest.fn();
+    const spy3 = vitest.fn();
+    pubsub.subscribe("foo", spy1);
+    pubsub.subscribe("foo.bar", spy2);
+    pubsub.subscribe("foo.bar.baz", spy3);
+
+    expect(pubsub.count()).toBe(3);
+    expect(pubsub.count("foo")).toBe(1);
+    expect(pubsub.count("foo.bar")).toBe(1);
+    expect(pubsub.count("foo.bar.baz")).toBe(1);
+
+    expect(pubsub.tokens.size).toBe(3);
+
+    pubsub.unsubscribe("foo.bar.baz");
+
+    expect(pubsub.count()).toBe(2);
+    expect(pubsub.count("foo")).toBe(1);
+    expect(pubsub.count("foo.bar")).toBe(1);
+    expect(pubsub.count("foo.bar.baz")).toBe(0);
+
+    expect(pubsub.tokens.size).toBe(2);
+  });
+
+  it(`should gracefully handle when token doesn't exist anymore`, () => {
+    const spy = vitest.fn();
+
+    const token = pubsub.subscribe("foo", spy);
+    expect(pubsub.count()).toBe(1);
+
+    pubsub.clear();
+    expect(pubsub.count()).toBe(0);
+
+    pubsub.unsubscribe(token);
+
+    expect(pubsub.tokens.size).toBe(0);
+  });
+
+  it(`should gracefully handle when unsubscribe isn't string or symbol`, () => {
+    const spy = vitest.fn();
+
+    pubsub.subscribe("foo", spy);
+    expect(pubsub.count()).toBe(1);
+
+    pubsub.clear();
+    expect(pubsub.count()).toBe(0);
+
+    pubsub.unsubscribe(false as any);
+
+    expect(pubsub.tokens.size).toBe(0);
+  });
+});

package/src/handler.ts

@@ -1,5 +1,5 @@
-import type { Player, PlayerPlugin, InProgressState } from '@player-ui/player';
-import { getPubSubPlugin } from './utils';
+import type { Player, PlayerPlugin, InProgressState } from "@player-ui/player";
+import { getPubSubPlugin } from "./utils";
 
 export type PubSubHandler<T extends unknown[]> = (
   context: InProgressState,
@@ -12,7 +12,7 @@ export type SubscriptionMap = Map<string, PubSubHandler<any>>;
  * Plugin to easily add subscribers to the PubSubPlugin
  */
 export class PubSubHandlerPlugin implements PlayerPlugin {
-  name = 'pubsub-handler';
+  name = "pubsub-handler";
   private subscriptions: SubscriptionMap;
 
   constructor(subscriptions: SubscriptionMap) {
@@ -27,12 +27,12 @@ export class PubSubHandlerPlugin implements PlayerPlugin {
         pubsub.subscribe(key, (_, ...args) => {
           const state = player.getState();
 
-          if (state.status === 'in-progress') {
+          if (state.status === "in-progress") {
             return handler(state, ...args);
           }
 
           player.logger.info(
-            `[PubSubHandlerPlugin] subscriber for ${key} was called when player was not in-progress`
+            `[PubSubHandlerPlugin] subscriber for ${key} was called when player was not in-progress`,
           );
         });
       });

package/src/index.ts

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

package/src/plugin.ts

@@ -2,10 +2,10 @@ import type {
   Player,
   PlayerPlugin,
   ExpressionContext,
-} from '@player-ui/player';
-import type { SubscribeHandler, TinyPubSub } from './pubsub';
-import { pubsub } from './pubsub';
-import { PubSubPluginSymbol } from './symbols';
+} 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  */
@@ -22,7 +22,7 @@ export interface PubSubConfig {
  *
  */
 export class PubSubPlugin implements PlayerPlugin {
-  name = 'pub-sub';
+  name = "pub-sub";
 
   static Symbol = PubSubPluginSymbol;
   public readonly symbol = PubSubPlugin.Symbol;
@@ -32,7 +32,7 @@ export class PubSubPlugin implements PlayerPlugin {
   private expressionName: string;
 
   constructor(config?: PubSubConfig) {
-    this.expressionName = config?.expressionName ?? 'publish';
+    this.expressionName = config?.expressionName ?? "publish";
     this.pubsub = pubsub;
   }
 
@@ -46,21 +46,21 @@ export class PubSubPlugin implements PlayerPlugin {
 
     player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
       const existingExpression = expEvaluator.operators.expressions.get(
-        this.expressionName
+        this.expressionName,
       );
 
       if (existingExpression) {
         player.logger.warn(
-          `[PubSubPlugin] expression ${this.expressionName} is already registered.`
+          `[PubSubPlugin] expression ${this.expressionName} is already registered.`,
         );
       } else {
         expEvaluator.addExpressionFunction(
           this.expressionName,
           (_ctx: ExpressionContext, event: unknown, ...args: unknown[]) => {
-            if (typeof event === 'string') {
+            if (typeof event === "string") {
               this.publish(event, ...args);
             }
-          }
+          },
         );
       }
     });
@@ -89,7 +89,7 @@ export class PubSubPlugin implements PlayerPlugin {
    */
   subscribe<T extends string, A extends unknown[]>(
     event: T,
-    handler: SubscribeHandler<T, A>
+    handler: SubscribeHandler<T, A>,
   ) {
     return this.pubsub.subscribe(event, handler);
   }

package/src/pubsub.ts

@@ -14,7 +14,7 @@ export type PubSubUUID = `uuid_${number}`;
  * Split a string into an array of event layers
  */
 function splitEvent(event: string) {
-  return event.split('.').reduce<string[]>((prev, curr, index) => {
+  return event.split(".").reduce<string[]>((prev, curr, index) => {
     if (index === 0) {
       return [curr];
     }
@@ -41,11 +41,11 @@ export class TinyPubSub {
    * Publish an event with any number of additional arguments
    */
   publish(event: string, ...args: unknown[]) {
-    if (typeof event !== 'string') {
+    if (typeof event !== "string") {
       return;
     }
 
-    if (event.includes('.')) {
+    if (event.includes(".")) {
       const eventKeys = splitEvent(event);
 
       eventKeys.forEach((key) => {
@@ -55,7 +55,7 @@ export class TinyPubSub {
       this.deliver(event, event, ...args);
     }
 
-    this.deliver('*', event, ...args);
+    this.deliver("*", event, ...args);
   }
 
   /**
@@ -74,7 +74,7 @@ export class TinyPubSub {
   subscribe(event: string, handler: SubscribeHandler<any, any>) {
     const uuid = `uuid_${++count}`;
 
-    if (typeof event === 'string') {
+    if (typeof event === "string") {
       if (!this.events.has(event)) {
         this.events.set(event, new Map());
       }
@@ -96,10 +96,10 @@ export class TinyPubSub {
    * & 'a.b.c' will be unsubscribed as well.
    */
   unsubscribe(value: string | symbol) {
-    if (typeof value === 'string' && value.startsWith('uuid')) {
+    if (typeof value === "string" && value.startsWith("uuid")) {
       const path = this.tokens.get(value as PubSubUUID);
 
-      if (typeof path === 'undefined') {
+      if (typeof path === "undefined") {
         return;
       }
 
@@ -109,7 +109,7 @@ export class TinyPubSub {
       return;
     }
 
-    if (typeof value === 'string') {
+    if (typeof value === "string") {
       for (const key of this.events.keys()) {
         if (key.indexOf(value) === 0) {
           const tokens = this.events.get(key);
@@ -134,7 +134,7 @@ export class TinyPubSub {
   count(event?: string) {
     let counter = 0;
 
-    if (typeof event === 'undefined') {
+    if (typeof event === "undefined") {
       for (const handlers of this.events.values()) {
         counter += handlers.size;
       }

package/src/symbols.ts

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

package/src/utils.ts

@@ -1,6 +1,6 @@
-import type { Player } from '@player-ui/player';
-import { PubSubPlugin } from './plugin';
-import { PubSubPluginSymbol } from './symbols';
+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

package/types/handler.d.ts

@@ -0,0 +1,13 @@
+import type { Player, PlayerPlugin, InProgressState } from "@player-ui/player";
+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 declare class PubSubHandlerPlugin implements PlayerPlugin {
+    name: string;
+    private subscriptions;
+    constructor(subscriptions: SubscriptionMap);
+    apply(player: Player): void;
+}
+//# sourceMappingURL=handler.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./plugin";
+export * from "./symbols";
+export * from "./handler";
+//# sourceMappingURL=index.d.ts.map

package/types/plugin.d.ts

@@ -0,0 +1,50 @@
+import type { Player, PlayerPlugin } from "@player-ui/player";
+import type { SubscribeHandler, TinyPubSub } from "./pubsub";
+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 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;
+    /**
+     * 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[]): 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<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;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/types/pubsub.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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}`;
+/**
+ * Tiny pubsub maker
+ */
+export 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;
+}
+export declare const pubsub: TinyPubSub;
+//# sourceMappingURL=pubsub.d.ts.map

package/types/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const PubSubPluginSymbol: unique symbol;
+//# sourceMappingURL=symbols.d.ts.map

package/types/utils.d.ts

@@ -0,0 +1,7 @@
+import type { Player } from "@player-ui/player";
+import { PubSubPlugin } from "./plugin";
+/**
+ * Returns the existing PubSubPlugin or creates and registers a new plugin
+ */
+export declare function getPubSubPlugin(player: Player): PubSubPlugin;
+//# sourceMappingURL=utils.d.ts.map