@player-ui/external-action-plugin 0.0.1-next.1

package/dist/index.cjs.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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());
+  });
+};
+class ExternalActionPlugin {
+  constructor(handler) {
+    this.name = "ExternalActionPlugin";
+    this.handler = handler;
+  }
+  apply(player) {
+    player.hooks.flowController.tap(this.name, (flowController) => {
+      flowController.hooks.flow.tap(this.name, (flow) => {
+        flow.hooks.transition.tap(this.name, (fromState, toState) => {
+          const { value: state } = toState;
+          if (state.state_type === "EXTERNAL") {
+            setTimeout(() => __async(this, null, function* () {
+              var _a, _b;
+              const currentState = player.getState();
+              if (currentState.status === "in-progress" && ((_b = (_a = currentState.controllers.flow.current) == null ? void 0 : _a.currentState) == null ? void 0 : _b.value) === state) {
+                try {
+                  const transitionValue = yield this.handler(state, currentState.controllers);
+                  if (transitionValue !== void 0) {
+                    currentState.controllers.flow.transition(transitionValue);
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }), 0);
+          }
+        });
+      });
+    });
+  }
+}
+
+exports.ExternalActionPlugin = ExternalActionPlugin;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { InProgressState, PlayerPlugin, Player } from '@player-ui/player';
+import { NavigationFlowExternalState } from '@player-ui/types';
+
+declare type ExternalStateHandler = (state: NavigationFlowExternalState, options: InProgressState['controllers']) => string | undefined | Promise<string | undefined>;
+/**
+ * A plugin to handle external actions states
+ */
+declare class ExternalActionPlugin implements PlayerPlugin {
+    name: string;
+    private handler;
+    constructor(handler: ExternalStateHandler);
+    apply(player: Player): void;
+}
+
+export { ExternalActionPlugin, ExternalStateHandler };

package/dist/index.esm.js

@@ -0,0 +1,56 @@
+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());
+  });
+};
+class ExternalActionPlugin {
+  constructor(handler) {
+    this.name = "ExternalActionPlugin";
+    this.handler = handler;
+  }
+  apply(player) {
+    player.hooks.flowController.tap(this.name, (flowController) => {
+      flowController.hooks.flow.tap(this.name, (flow) => {
+        flow.hooks.transition.tap(this.name, (fromState, toState) => {
+          const { value: state } = toState;
+          if (state.state_type === "EXTERNAL") {
+            setTimeout(() => __async(this, null, function* () {
+              var _a, _b;
+              const currentState = player.getState();
+              if (currentState.status === "in-progress" && ((_b = (_a = currentState.controllers.flow.current) == null ? void 0 : _a.currentState) == null ? void 0 : _b.value) === state) {
+                try {
+                  const transitionValue = yield this.handler(state, currentState.controllers);
+                  if (transitionValue !== void 0) {
+                    currentState.controllers.flow.transition(transitionValue);
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }), 0);
+          }
+        });
+      });
+    });
+  }
+}
+
+export { ExternalActionPlugin };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@player-ui/external-action-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": {
+    "@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,56 @@
+import type { Player, PlayerPlugin, InProgressState } from '@player-ui/player';
+import type { NavigationFlowExternalState } from '@player-ui/types';
+
+export type ExternalStateHandler = (
+  state: NavigationFlowExternalState,
+  options: InProgressState['controllers']
+) => string | undefined | Promise<string | undefined>;
+
+/**
+ * A plugin to handle external actions states
+ */
+export class ExternalActionPlugin implements PlayerPlugin {
+  name = 'ExternalActionPlugin';
+  private handler: ExternalStateHandler;
+
+  constructor(handler: ExternalStateHandler) {
+    this.handler = handler;
+  }
+
+  apply(player: Player) {
+    player.hooks.flowController.tap(this.name, (flowController) => {
+      flowController.hooks.flow.tap(this.name, (flow) => {
+        flow.hooks.transition.tap(this.name, (fromState, toState) => {
+          const { value: state } = toState;
+
+          if (state.state_type === 'EXTERNAL') {
+            setTimeout(async () => {
+              const currentState = player.getState();
+
+              if (
+                currentState.status === 'in-progress' &&
+                currentState.controllers.flow.current?.currentState?.value ===
+                  state
+              ) {
+                try {
+                  const transitionValue = await this.handler(
+                    state,
+                    currentState.controllers
+                  );
+
+                  if (transitionValue !== undefined) {
+                    currentState.controllers.flow.transition(transitionValue);
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }, 0);
+          }
+        });
+      });
+    });
+  }
+}