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

package/dist/index.cjs.js

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tapable = require('tapable');
+var player = require('@player-ui/player');
+var timm = require('timm');
+
+const BeaconPluginSymbol = Symbol.for("BeaconPlugin");
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const _BeaconPlugin = class {
+  constructor(options) {
+    this.name = "Beacon";
+    this.symbol = _BeaconPlugin.Symbol;
+    this.beaconContext = {
+      view: void 0
+    };
+    this.hooks = {
+      buildBeacon: new tapable.AsyncSeriesWaterfallHook([
+        "beacon",
+        "beaconArguments"
+      ]),
+      cancelBeacon: new tapable.SyncBailHook(["args"]),
+      publishBeacon: new tapable.SyncHook(["beacon"])
+    };
+    if (options == null ? void 0 : options.plugins) {
+      options.plugins.forEach((plugin) => {
+        plugin.apply(this);
+      });
+    }
+    if (options == null ? void 0 : options.callback) {
+      this.hooks.publishBeacon.tap("BeaconCallback", (beacon) => {
+        if (options.callback)
+          options.callback(beacon);
+      });
+    }
+  }
+  apply(player) {
+    this.player = player;
+    this.logger = player.logger;
+    player.hooks.dataController.tap(this.name, (dataController) => {
+      this.dataController = dataController;
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (expressionEvaluator) => {
+      this.expressionEvaluator = expressionEvaluator;
+    });
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.beaconContext = {
+        view: void 0
+      };
+      vc.hooks.view.tap(this.name, (view) => {
+        let beaconedView = false;
+        view.hooks.parser.tap(this.name, (parser) => {
+          parser.hooks.onCreateASTNode.tap(this.name, (obj) => {
+            var _a, _b, _c, _d;
+            if ((obj == null ? void 0 : obj.type) !== "asset" && (obj == null ? void 0 : obj.type) !== "view")
+              return void 0;
+            const propertiesToSkip = (_c = (_b = (_a = obj.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip) != null ? _c : [];
+            if (propertiesToSkip.includes("beacon"))
+              return void 0;
+            obj.plugins = timm.setIn((_d = obj.plugins) != null ? _d : {}, ["stringResolver", "propertiesToSkip"], ["beacon", ...propertiesToSkip]);
+            return obj;
+          });
+        });
+        view.hooks.onUpdate.tap(this.name, (viewUpdate) => {
+          this.beaconContext = {
+            view: viewUpdate
+          };
+          if (!beaconedView) {
+            this.beacon({
+              action: "viewed",
+              element: "view",
+              asset: viewUpdate,
+              view: viewUpdate
+            });
+            beaconedView = true;
+          }
+        });
+      });
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
+      evaluator.addExpressionFunction("beacon", (_ctx, action, data) => {
+        const view = this.beaconContext.view || {};
+        this.beacon({
+          action,
+          data,
+          element: "view",
+          asset: view,
+          view
+        });
+      });
+    });
+  }
+  beacon(event) {
+    const { action, element, asset, view } = event;
+    const { view: currentView } = this.beaconContext;
+    setTimeout(() => __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const data = (event == null ? void 0 : event.data) || ((_b = (_a = event.asset) == null ? void 0 : _a.metaData) == null ? void 0 : _b.beacon);
+      const defaultBeacon = {
+        action,
+        element,
+        data,
+        assetId: asset == null ? void 0 : asset.id,
+        viewId: currentView == null ? void 0 : currentView.id
+      };
+      const state = (_c = this.player) == null ? void 0 : _c.getState();
+      const hookArgs = __spreadProps(__spreadValues({}, event), {
+        data,
+        state,
+        view: view || currentView,
+        logger: this.logger
+      });
+      const beacon = (yield this.hooks.buildBeacon.promise(defaultBeacon, hookArgs)) || defaultBeacon;
+      const shouldCancel = this.hooks.cancelBeacon.call(hookArgs) || false;
+      if (!shouldCancel) {
+        const resolvedBeacon = this.dataController && this.expressionEvaluator ? player.resolveDataRefs(beacon, {
+          model: this.dataController,
+          evaluate: this.expressionEvaluator.evaluate
+        }) : beacon;
+        (_d = this.logger) == null ? void 0 : _d.debug("Sending beacon event", resolvedBeacon);
+        this.hooks.publishBeacon.call(resolvedBeacon);
+      }
+    }), 0);
+  }
+};
+let BeaconPlugin = _BeaconPlugin;
+BeaconPlugin.Symbol = BeaconPluginSymbol;
+
+exports.BeaconPlugin = BeaconPlugin;
+exports.BeaconPluginSymbol = BeaconPluginSymbol;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import { AsyncSeriesWaterfallHook, SyncBailHook, SyncHook } from 'tapable';
+import { PlayerFlowState, PlayerPlugin, Player } from '@player-ui/player';
+import { Asset, View } from '@player-ui/types';
+import { Logger } from '@player-ui/logger';
+
+declare type BeaconDataType = string | Record<string, any>;
+interface BeaconMetaData {
+    /** Additional data to send along with beacons */
+    beacon?: BeaconDataType;
+}
+interface AssetBeaconInfo {
+    /** Additional data about the asset */
+    metaData?: BeaconMetaData;
+}
+declare type AssetBeacon = Asset & AssetBeaconInfo;
+declare type ViewBeacon = View & AssetBeaconInfo;
+interface BeaconPluginPlugin {
+    /** Use this to tap into the beacon plugin hooks */
+    apply: (beaconPlugin: BeaconPlugin) => void;
+}
+interface BeaconPluginOptions {
+    /** Callback when a beacon is published */
+    callback?: (beacon: any) => void;
+    /** A set of plugins to load  */
+    plugins?: BeaconPluginPlugin[];
+}
+interface BeaconArgs {
+    /** The action being performed */
+    action: string;
+    /** The specific element that the beacon originated from */
+    element: string;
+    /** The asset firing the beacon */
+    asset: AssetBeacon;
+    /** The current view */
+    view?: ViewBeacon;
+    /** Any additional data to attach to the event */
+    data?: any;
+}
+interface HookArgs extends BeaconArgs {
+    /** The current player state */
+    state?: PlayerFlowState;
+    /** The beacon plugin logger */
+    logger: Logger;
+}
+/**
+ * A player plugin to manage beacon events.
+ * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.
+ */
+declare class BeaconPlugin implements PlayerPlugin {
+    name: string;
+    static Symbol: symbol;
+    readonly symbol: symbol;
+    private player?;
+    private logger?;
+    private beaconContext;
+    private dataController?;
+    private expressionEvaluator?;
+    hooks: {
+        buildBeacon: AsyncSeriesWaterfallHook<unknown, HookArgs, any>;
+        cancelBeacon: SyncBailHook<HookArgs, boolean, any, any>;
+        publishBeacon: SyncHook<any, any, any>;
+    };
+    constructor(options?: BeaconPluginOptions);
+    apply(player: Player): void;
+    beacon(event: BeaconArgs): void;
+}
+
+declare const BeaconPluginSymbol: unique symbol;
+
+export { AssetBeacon, AssetBeaconInfo, BeaconArgs, BeaconDataType, BeaconMetaData, BeaconPlugin, BeaconPluginOptions, BeaconPluginPlugin, BeaconPluginSymbol, HookArgs, ViewBeacon };

package/dist/index.esm.js

@@ -0,0 +1,166 @@
+import { AsyncSeriesWaterfallHook, SyncBailHook, SyncHook } from 'tapable';
+import { resolveDataRefs } from '@player-ui/player';
+import { setIn } from 'timm';
+
+const BeaconPluginSymbol = Symbol.for("BeaconPlugin");
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const _BeaconPlugin = class {
+  constructor(options) {
+    this.name = "Beacon";
+    this.symbol = _BeaconPlugin.Symbol;
+    this.beaconContext = {
+      view: void 0
+    };
+    this.hooks = {
+      buildBeacon: new AsyncSeriesWaterfallHook([
+        "beacon",
+        "beaconArguments"
+      ]),
+      cancelBeacon: new SyncBailHook(["args"]),
+      publishBeacon: new SyncHook(["beacon"])
+    };
+    if (options == null ? void 0 : options.plugins) {
+      options.plugins.forEach((plugin) => {
+        plugin.apply(this);
+      });
+    }
+    if (options == null ? void 0 : options.callback) {
+      this.hooks.publishBeacon.tap("BeaconCallback", (beacon) => {
+        if (options.callback)
+          options.callback(beacon);
+      });
+    }
+  }
+  apply(player) {
+    this.player = player;
+    this.logger = player.logger;
+    player.hooks.dataController.tap(this.name, (dataController) => {
+      this.dataController = dataController;
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (expressionEvaluator) => {
+      this.expressionEvaluator = expressionEvaluator;
+    });
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.beaconContext = {
+        view: void 0
+      };
+      vc.hooks.view.tap(this.name, (view) => {
+        let beaconedView = false;
+        view.hooks.parser.tap(this.name, (parser) => {
+          parser.hooks.onCreateASTNode.tap(this.name, (obj) => {
+            var _a, _b, _c, _d;
+            if ((obj == null ? void 0 : obj.type) !== "asset" && (obj == null ? void 0 : obj.type) !== "view")
+              return void 0;
+            const propertiesToSkip = (_c = (_b = (_a = obj.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip) != null ? _c : [];
+            if (propertiesToSkip.includes("beacon"))
+              return void 0;
+            obj.plugins = setIn((_d = obj.plugins) != null ? _d : {}, ["stringResolver", "propertiesToSkip"], ["beacon", ...propertiesToSkip]);
+            return obj;
+          });
+        });
+        view.hooks.onUpdate.tap(this.name, (viewUpdate) => {
+          this.beaconContext = {
+            view: viewUpdate
+          };
+          if (!beaconedView) {
+            this.beacon({
+              action: "viewed",
+              element: "view",
+              asset: viewUpdate,
+              view: viewUpdate
+            });
+            beaconedView = true;
+          }
+        });
+      });
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
+      evaluator.addExpressionFunction("beacon", (_ctx, action, data) => {
+        const view = this.beaconContext.view || {};
+        this.beacon({
+          action,
+          data,
+          element: "view",
+          asset: view,
+          view
+        });
+      });
+    });
+  }
+  beacon(event) {
+    const { action, element, asset, view } = event;
+    const { view: currentView } = this.beaconContext;
+    setTimeout(() => __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const data = (event == null ? void 0 : event.data) || ((_b = (_a = event.asset) == null ? void 0 : _a.metaData) == null ? void 0 : _b.beacon);
+      const defaultBeacon = {
+        action,
+        element,
+        data,
+        assetId: asset == null ? void 0 : asset.id,
+        viewId: currentView == null ? void 0 : currentView.id
+      };
+      const state = (_c = this.player) == null ? void 0 : _c.getState();
+      const hookArgs = __spreadProps(__spreadValues({}, event), {
+        data,
+        state,
+        view: view || currentView,
+        logger: this.logger
+      });
+      const beacon = (yield this.hooks.buildBeacon.promise(defaultBeacon, hookArgs)) || defaultBeacon;
+      const shouldCancel = this.hooks.cancelBeacon.call(hookArgs) || false;
+      if (!shouldCancel) {
+        const resolvedBeacon = this.dataController && this.expressionEvaluator ? resolveDataRefs(beacon, {
+          model: this.dataController,
+          evaluate: this.expressionEvaluator.evaluate
+        }) : beacon;
+        (_d = this.logger) == null ? void 0 : _d.debug("Sending beacon event", resolvedBeacon);
+        this.hooks.publishBeacon.call(resolvedBeacon);
+      }
+    }), 0);
+  }
+};
+let BeaconPlugin = _BeaconPlugin;
+BeaconPlugin.Symbol = BeaconPluginSymbol;
+
+export { BeaconPlugin, BeaconPluginSymbol };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@player-ui/beacon-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",
+    "@player-ui/logger": "0.0.1-next.1",
+    "@player-ui/types": "0.0.1-next.1"
+  },
+  "dependencies": {
+    "tapable": "1.1.3",
+    "timm": "^1.6.2",
+    "@types/tapable": "^1.0.5",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts"
+}

package/src/beacon.ts

@@ -0,0 +1,225 @@
+import { SyncBailHook, AsyncSeriesWaterfallHook, SyncHook } from 'tapable';
+import type {
+  Player,
+  PlayerPlugin,
+  PlayerFlowState,
+  DataController,
+  ExpressionEvaluator,
+} from '@player-ui/player';
+import { resolveDataRefs } from '@player-ui/player';
+import type { Asset, View } from '@player-ui/types';
+import type { Logger } from '@player-ui/logger';
+import { setIn } from 'timm';
+import { BeaconPluginSymbol } from './symbols';
+
+export type BeaconDataType = string | Record<string, any>;
+
+export interface BeaconMetaData {
+  /** Additional data to send along with beacons */
+  beacon?: BeaconDataType;
+}
+
+export interface AssetBeaconInfo {
+  /** Additional data about the asset */
+  metaData?: BeaconMetaData;
+}
+
+export type AssetBeacon = Asset & AssetBeaconInfo;
+export type ViewBeacon = View & AssetBeaconInfo;
+
+export interface BeaconPluginPlugin {
+  /** Use this to tap into the beacon plugin hooks */
+  apply: (beaconPlugin: BeaconPlugin) => void;
+}
+
+export interface BeaconPluginOptions {
+  /** Callback when a beacon is published */
+  callback?: (beacon: any) => void;
+  /** A set of plugins to load  */
+  plugins?: BeaconPluginPlugin[];
+}
+
+interface BeaconContext {
+  /** The full current view */
+  view?: ViewBeacon;
+}
+
+export interface BeaconArgs {
+  /** The action being performed */
+  action: string;
+  /** The specific element that the beacon originated from */
+  element: string;
+  /** The asset firing the beacon */
+  asset: AssetBeacon;
+  /** The current view */
+  view?: ViewBeacon;
+  /** Any additional data to attach to the event */
+  data?: any;
+}
+
+export interface HookArgs extends BeaconArgs {
+  /** The current player state */
+  state?: PlayerFlowState;
+  /** The beacon plugin logger */
+  logger: Logger;
+}
+
+/**
+ * A player plugin to manage beacon events.
+ * It automatically keeps track of the current user's view, and adds additional metaData to each beacon event.
+ */
+export class BeaconPlugin implements PlayerPlugin {
+  name = 'Beacon';
+
+  static Symbol = BeaconPluginSymbol;
+  public readonly symbol = BeaconPlugin.Symbol;
+
+  private player?: Player;
+  private logger?: Logger;
+
+  private beaconContext: BeaconContext = {
+    view: undefined,
+  };
+
+  private dataController?: DataController;
+  private expressionEvaluator?: ExpressionEvaluator;
+
+  public hooks = {
+    buildBeacon: new AsyncSeriesWaterfallHook<unknown, HookArgs>([
+      'beacon',
+      'beaconArguments',
+    ]),
+    cancelBeacon: new SyncBailHook<HookArgs, boolean>(['args']),
+    publishBeacon: new SyncHook(['beacon']),
+  };
+
+  constructor(options?: BeaconPluginOptions) {
+    if (options?.plugins) {
+      options.plugins.forEach((plugin) => {
+        plugin.apply(this);
+      });
+    }
+
+    if (options?.callback) {
+      this.hooks.publishBeacon.tap('BeaconCallback', (beacon: any) => {
+        if (options.callback) options.callback(beacon);
+      });
+    }
+  }
+
+  apply(player: Player) {
+    this.player = player;
+    this.logger = player.logger;
+
+    player.hooks.dataController.tap(this.name, (dataController) => {
+      this.dataController = dataController;
+    });
+
+    player.hooks.expressionEvaluator.tap(this.name, (expressionEvaluator) => {
+      this.expressionEvaluator = expressionEvaluator;
+    });
+
+    player.hooks.viewController.tap(this.name, (vc) => {
+      this.beaconContext = {
+        view: undefined,
+      };
+
+      vc.hooks.view.tap(this.name, (view) => {
+        let beaconedView = false;
+
+        view.hooks.parser.tap(this.name, (parser) => {
+          /* If there is a 'beacon' property in an asset or view, skip resolving as we
+             are doing this manually when beacon is fired. */
+          parser.hooks.onCreateASTNode.tap(this.name, (obj) => {
+            if (obj?.type !== 'asset' && obj?.type !== 'view') return undefined;
+
+            const propertiesToSkip =
+              obj.plugins?.stringResolver?.propertiesToSkip ?? [];
+
+            if (propertiesToSkip.includes('beacon')) return undefined;
+
+            // eslint-disable-next-line no-param-reassign
+            obj.plugins = setIn(
+              obj.plugins ?? {},
+              ['stringResolver', 'propertiesToSkip'],
+              ['beacon', ...propertiesToSkip]
+            ) as any;
+
+            return obj;
+          });
+        });
+
+        view.hooks.onUpdate.tap(this.name, (viewUpdate: ViewBeacon) => {
+          this.beaconContext = {
+            view: viewUpdate,
+          };
+
+          if (!beaconedView) {
+            this.beacon({
+              action: 'viewed',
+              element: 'view',
+              asset: viewUpdate,
+              view: viewUpdate,
+            });
+
+            beaconedView = true;
+          }
+        });
+      });
+    });
+
+    player.hooks.expressionEvaluator.tap(this.name, (evaluator) => {
+      evaluator.addExpressionFunction('beacon', (_ctx, action, data) => {
+        const view = this.beaconContext.view || ({} as ViewBeacon);
+        this.beacon({
+          action: action as string,
+          data: data as any,
+          element: 'view',
+          asset: view,
+          view,
+        });
+      });
+    });
+  }
+
+  beacon(event: BeaconArgs) {
+    const { action, element, asset, view } = event;
+    const { view: currentView } = this.beaconContext;
+    setTimeout(async () => {
+      const data = event?.data || event.asset?.metaData?.beacon;
+
+      const defaultBeacon = {
+        action,
+        element,
+        data,
+        assetId: asset?.id,
+        viewId: currentView?.id,
+      };
+      const state = this.player?.getState();
+      const hookArgs = {
+        ...event,
+        data,
+        state,
+        view: view || currentView,
+        logger: this.logger as Logger,
+      };
+      const beacon =
+        (await this.hooks.buildBeacon.promise(defaultBeacon, hookArgs)) ||
+        defaultBeacon;
+      const shouldCancel = this.hooks.cancelBeacon.call(hookArgs) || false;
+
+      if (!shouldCancel) {
+        const resolvedBeacon =
+          this.dataController && this.expressionEvaluator
+            ? resolveDataRefs(beacon, {
+                model: this.dataController,
+                evaluate: this.expressionEvaluator.evaluate,
+              })
+            : beacon;
+
+        this.logger?.debug('Sending beacon event', resolvedBeacon);
+        this.hooks.publishBeacon.call(resolvedBeacon);
+      }
+    }, 0);
+  }
+}

package/src/index.ts

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

package/src/symbols.ts

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