@player-ui/external-action-plugin 0.8.0--canary.307.9621 → 0.8.0-next.0

package/dist/ExternalActionPlugin.native.js

@@ -0,0 +1,290 @@
+"use strict";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var ExternalActionPlugin = function() {
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = function(target, all) {
+        for(var name in all)__defProp(target, name, {
+            get: all[name],
+            enumerable: true
+        });
+    };
+    var __copyProps = function(to, from, except, desc) {
+        if (from && typeof from === "object" || typeof from === "function") {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                var _loop = function() {
+                    var key = _step.value;
+                    if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                        get: function() {
+                            return from[key];
+                        },
+                        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                    });
+                };
+                for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        }
+        return to;
+    };
+    var __toCommonJS = function(mod) {
+        return __copyProps(__defProp({}, "__esModule", {
+            value: true
+        }), mod);
+    };
+    // ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts
+    var src_exports = {};
+    __export(src_exports, {
+        ExternalActionPlugin: function() {
+            return ExternalActionPlugin;
+        }
+    });
+    var ExternalActionPlugin = /*#__PURE__*/ function() {
+        function ExternalActionPlugin(handler) {
+            _class_call_check(this, ExternalActionPlugin);
+            this.name = "ExternalActionPlugin";
+            this.handler = handler;
+        }
+        _create_class(ExternalActionPlugin, [
+            {
+                key: "apply",
+                value: function apply(player) {
+                    var _this = this;
+                    player.hooks.flowController.tap(this.name, function(flowController) {
+                        flowController.hooks.flow.tap(_this.name, function(flow) {
+                            flow.hooks.transition.tap(_this.name, function(fromState, toState) {
+                                var state = toState.value;
+                                if (state.state_type === "EXTERNAL") {
+                                    var _this1 = _this;
+                                    setTimeout(/*#__PURE__*/ _async_to_generator(function() {
+                                        var shouldTransition, currentState, transitionValue, latestState, error;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    shouldTransition = function(currentState2) {
+                                                        var _currentState2_controllers_flow_current_currentState, _currentState2_controllers_flow_current;
+                                                        return currentState2.status === "in-progress" && ((_currentState2_controllers_flow_current = currentState2.controllers.flow.current) === null || _currentState2_controllers_flow_current === void 0 ? void 0 : (_currentState2_controllers_flow_current_currentState = _currentState2_controllers_flow_current.currentState) === null || _currentState2_controllers_flow_current_currentState === void 0 ? void 0 : _currentState2_controllers_flow_current_currentState.value) === state;
+                                                    };
+                                                    currentState = player.getState();
+                                                    if (!shouldTransition(currentState)) return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        3,
+                                                        ,
+                                                        4
+                                                    ]);
+                                                    return [
+                                                        4,
+                                                        _this1.handler(state, currentState.controllers)
+                                                    ];
+                                                case 2:
+                                                    transitionValue = _state.sent();
+                                                    if (transitionValue !== void 0) {
+                                                        latestState = player.getState();
+                                                        if (shouldTransition(latestState)) {
+                                                            latestState.controllers.flow.transition(transitionValue);
+                                                        } else {
+                                                            player.logger.warn("External state resolved with [".concat(transitionValue, "], but Player already navigated away from [").concat(toState.name, "]"));
+                                                        }
+                                                    }
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 3:
+                                                    error = _state.sent();
+                                                    if (_instanceof(error, Error)) {
+                                                        currentState.fail(error);
+                                                    }
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                case 4:
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    }), 0);
+                                }
+                            });
+                        });
+                    });
+                }
+            }
+        ]);
+        return ExternalActionPlugin;
+    }();
+    return __toCommonJS(src_exports);
+}();
+//# sourceMappingURL=index.global.js.map

package/dist/ExternalActionPlugin.native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts"],"names":["currentState"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAgBO,MAAM,uBAAN,MAAmD;AAAA,IAIxD,YAAY,SAA+B;AAH3C,kBAAO;AAIL,WAAK,UAAU;AAAA,IACjB;AAAA,IAEA,MAAM,QAAgB;AACpB,aAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,uBAAe,MAAM,KAAK,IAAI,KAAK,MAAM,CAAC,SAAS;AACjD,eAAK,MAAM,WAAW,IAAI,KAAK,MAAM,CAAC,WAAW,YAAY;AAC3D,kBAAM,EAAE,OAAO,MAAM,IAAI;AACzB,gBAAI,MAAM,eAAe,YAAY;AACnC,yBAAW,YAAY;AAErB,sBAAM,mBAAmB,CACvBA,kBAEAA,cAAa,WAAW,iBACxBA,cAAa,YAAY,KAAK,SAAS,cAAc,UACnD;AAEJ,sBAAM,eAAe,OAAO,SAAS;AACrC,oBAAI,iBAAiB,YAAY,GAAG;AAClC,sBAAI;AACF,0BAAM,kBAAkB,MAAM,KAAK;AAAA,sBACjC;AAAA,sBACA,aAAa;AAAA,oBACf;AAEA,wBAAI,oBAAoB,QAAW;AAEjC,4BAAM,cAAc,OAAO,SAAS;AACpC,0BAAI,iBAAiB,WAAW,GAAG;AACjC,oCAAY,YAAY,KAAK,WAAW,eAAe;AAAA,sBACzD,OAAO;AACL,+BAAO,OAAO;AAAA,0BACZ,iCAAiC,eAAe,8CAA8C,QAAQ,IAAI;AAAA,wBAC5G;AAAA,sBACF;AAAA,oBACF;AAAA,kBACF,SAAS,OAAO;AACd,wBAAI,iBAAiB,OAAO;AAC1B,mCAAa,KAAK,KAAK;AAAA,oBACzB;AAAA,kBACF;AAAA,gBACF;AAAA,cACF,GAAG,CAAC;AAAA,YACN;AAAA,UACF,CAAC;AAAA,QACH,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF","sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  InProgressState,\n  PlayerFlowState,\n  NavigationFlowExternalState,\n} from \"@player-ui/player\";\n\nexport type ExternalStateHandler = (\n  state: NavigationFlowExternalState,\n  options: InProgressState[\"controllers\"],\n) => string | undefined | Promise<string | undefined>;\n\n/**\n * A plugin to handle external actions states\n */\nexport class ExternalActionPlugin implements PlayerPlugin {\n  name = \"ExternalActionPlugin\";\n  private handler: ExternalStateHandler;\n\n  constructor(handler: ExternalStateHandler) {\n    this.handler = handler;\n  }\n\n  apply(player: Player) {\n    player.hooks.flowController.tap(this.name, (flowController) => {\n      flowController.hooks.flow.tap(this.name, (flow) => {\n        flow.hooks.transition.tap(this.name, (fromState, toState) => {\n          const { value: state } = toState;\n          if (state.state_type === \"EXTERNAL\") {\n            setTimeout(async () => {\n              /** Helper for ensuring state is still current relative to external state this is handling */\n              const shouldTransition = (\n                currentState: PlayerFlowState,\n              ): currentState is InProgressState =>\n                currentState.status === \"in-progress\" &&\n                currentState.controllers.flow.current?.currentState?.value ===\n                  state;\n\n              const currentState = player.getState();\n              if (shouldTransition(currentState)) {\n                try {\n                  const transitionValue = await this.handler(\n                    state,\n                    currentState.controllers,\n                  );\n\n                  if (transitionValue !== undefined) {\n                    // Ensure the Player is still in the same state after waiting for transitionValue\n                    const latestState = player.getState();\n                    if (shouldTransition(latestState)) {\n                      latestState.controllers.flow.transition(transitionValue);\n                    } else {\n                      player.logger.warn(\n                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`,\n                      );\n                    }\n                  }\n                } catch (error) {\n                  if (error instanceof Error) {\n                    currentState.fail(error);\n                  }\n                }\n              }\n            }, 0);\n          }\n        });\n      });\n    });\n  }\n}\n"]}

package/dist/cjs/index.cjs

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ExternalActionPlugin: () => ExternalActionPlugin
+});
+module.exports = __toCommonJS(src_exports);
+var ExternalActionPlugin = class {
+  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 () => {
+              const shouldTransition = (currentState2) => currentState2.status === "in-progress" && currentState2.controllers.flow.current?.currentState?.value === state;
+              const currentState = player.getState();
+              if (shouldTransition(currentState)) {
+                try {
+                  const transitionValue = await this.handler(
+                    state,
+                    currentState.controllers
+                  );
+                  if (transitionValue !== void 0) {
+                    const latestState = player.getState();
+                    if (shouldTransition(latestState)) {
+                      latestState.controllers.flow.transition(transitionValue);
+                    } else {
+                      player.logger.warn(
+                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`
+                      );
+                    }
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }, 0);
+          }
+        });
+      });
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExternalActionPlugin
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts"],"sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  InProgressState,\n  PlayerFlowState,\n  NavigationFlowExternalState,\n} from \"@player-ui/player\";\n\nexport type ExternalStateHandler = (\n  state: NavigationFlowExternalState,\n  options: InProgressState[\"controllers\"],\n) => string | undefined | Promise<string | undefined>;\n\n/**\n * A plugin to handle external actions states\n */\nexport class ExternalActionPlugin implements PlayerPlugin {\n  name = \"ExternalActionPlugin\";\n  private handler: ExternalStateHandler;\n\n  constructor(handler: ExternalStateHandler) {\n    this.handler = handler;\n  }\n\n  apply(player: Player) {\n    player.hooks.flowController.tap(this.name, (flowController) => {\n      flowController.hooks.flow.tap(this.name, (flow) => {\n        flow.hooks.transition.tap(this.name, (fromState, toState) => {\n          const { value: state } = toState;\n          if (state.state_type === \"EXTERNAL\") {\n            setTimeout(async () => {\n              /** Helper for ensuring state is still current relative to external state this is handling */\n              const shouldTransition = (\n                currentState: PlayerFlowState,\n              ): currentState is InProgressState =>\n                currentState.status === \"in-progress\" &&\n                currentState.controllers.flow.current?.currentState?.value ===\n                  state;\n\n              const currentState = player.getState();\n              if (shouldTransition(currentState)) {\n                try {\n                  const transitionValue = await this.handler(\n                    state,\n                    currentState.controllers,\n                  );\n\n                  if (transitionValue !== undefined) {\n                    // Ensure the Player is still in the same state after waiting for transitionValue\n                    const latestState = player.getState();\n                    if (shouldTransition(latestState)) {\n                      latestState.controllers.flow.transition(transitionValue);\n                    } else {\n                      player.logger.warn(\n                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`,\n                      );\n                    }\n                  }\n                } catch (error) {\n                  if (error instanceof Error) {\n                    currentState.fail(error);\n                  }\n                }\n              }\n            }, 0);\n          }\n        });\n      });\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,IAAM,uBAAN,MAAmD;AAAA,EAIxD,YAAY,SAA+B;AAH3C,gBAAO;AAIL,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,MAAM,QAAgB;AACpB,WAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,qBAAe,MAAM,KAAK,IAAI,KAAK,MAAM,CAAC,SAAS;AACjD,aAAK,MAAM,WAAW,IAAI,KAAK,MAAM,CAAC,WAAW,YAAY;AAC3D,gBAAM,EAAE,OAAO,MAAM,IAAI;AACzB,cAAI,MAAM,eAAe,YAAY;AACnC,uBAAW,YAAY;AAErB,oBAAM,mBAAmB,CACvBA,kBAEAA,cAAa,WAAW,iBACxBA,cAAa,YAAY,KAAK,SAAS,cAAc,UACnD;AAEJ,oBAAM,eAAe,OAAO,SAAS;AACrC,kBAAI,iBAAiB,YAAY,GAAG;AAClC,oBAAI;AACF,wBAAM,kBAAkB,MAAM,KAAK;AAAA,oBACjC;AAAA,oBACA,aAAa;AAAA,kBACf;AAEA,sBAAI,oBAAoB,QAAW;AAEjC,0BAAM,cAAc,OAAO,SAAS;AACpC,wBAAI,iBAAiB,WAAW,GAAG;AACjC,kCAAY,YAAY,KAAK,WAAW,eAAe;AAAA,oBACzD,OAAO;AACL,6BAAO,OAAO;AAAA,wBACZ,iCAAiC,eAAe,8CAA8C,QAAQ,IAAI;AAAA,sBAC5G;AAAA,oBACF;AAAA,kBACF;AAAA,gBACF,SAAS,OAAO;AACd,sBAAI,iBAAiB,OAAO;AAC1B,iCAAa,KAAK,KAAK;AAAA,kBACzB;AAAA,gBACF;AAAA,cACF;AAAA,YACF,GAAG,CAAC;AAAA,UACN;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;","names":["currentState"]}

package/dist/index.legacy-esm.js

@@ -0,0 +1,48 @@
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts
+var ExternalActionPlugin = class {
+  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 () => {
+              const shouldTransition = (currentState2) => currentState2.status === "in-progress" && currentState2.controllers.flow.current?.currentState?.value === state;
+              const currentState = player.getState();
+              if (shouldTransition(currentState)) {
+                try {
+                  const transitionValue = await this.handler(
+                    state,
+                    currentState.controllers
+                  );
+                  if (transitionValue !== void 0) {
+                    const latestState = player.getState();
+                    if (shouldTransition(latestState)) {
+                      latestState.controllers.flow.transition(transitionValue);
+                    } else {
+                      player.logger.warn(
+                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`
+                      );
+                    }
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }, 0);
+          }
+        });
+      });
+    });
+  }
+};
+export {
+  ExternalActionPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs

@@ -0,0 +1,48 @@
+// ../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts
+var ExternalActionPlugin = class {
+  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 () => {
+              const shouldTransition = (currentState2) => currentState2.status === "in-progress" && currentState2.controllers.flow.current?.currentState?.value === state;
+              const currentState = player.getState();
+              if (shouldTransition(currentState)) {
+                try {
+                  const transitionValue = await this.handler(
+                    state,
+                    currentState.controllers
+                  );
+                  if (transitionValue !== void 0) {
+                    const latestState = player.getState();
+                    if (shouldTransition(latestState)) {
+                      latestState.controllers.flow.transition(transitionValue);
+                    } else {
+                      player.logger.warn(
+                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`
+                      );
+                    }
+                  }
+                } catch (error) {
+                  if (error instanceof Error) {
+                    currentState.fail(error);
+                  }
+                }
+              }
+            }, 0);
+          }
+        });
+      });
+    });
+  }
+};
+export {
+  ExternalActionPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/plugins/external-action/core/src/index.ts"],"sourcesContent":["import type {\n  Player,\n  PlayerPlugin,\n  InProgressState,\n  PlayerFlowState,\n  NavigationFlowExternalState,\n} from \"@player-ui/player\";\n\nexport type ExternalStateHandler = (\n  state: NavigationFlowExternalState,\n  options: InProgressState[\"controllers\"],\n) => string | undefined | Promise<string | undefined>;\n\n/**\n * A plugin to handle external actions states\n */\nexport class ExternalActionPlugin implements PlayerPlugin {\n  name = \"ExternalActionPlugin\";\n  private handler: ExternalStateHandler;\n\n  constructor(handler: ExternalStateHandler) {\n    this.handler = handler;\n  }\n\n  apply(player: Player) {\n    player.hooks.flowController.tap(this.name, (flowController) => {\n      flowController.hooks.flow.tap(this.name, (flow) => {\n        flow.hooks.transition.tap(this.name, (fromState, toState) => {\n          const { value: state } = toState;\n          if (state.state_type === \"EXTERNAL\") {\n            setTimeout(async () => {\n              /** Helper for ensuring state is still current relative to external state this is handling */\n              const shouldTransition = (\n                currentState: PlayerFlowState,\n              ): currentState is InProgressState =>\n                currentState.status === \"in-progress\" &&\n                currentState.controllers.flow.current?.currentState?.value ===\n                  state;\n\n              const currentState = player.getState();\n              if (shouldTransition(currentState)) {\n                try {\n                  const transitionValue = await this.handler(\n                    state,\n                    currentState.controllers,\n                  );\n\n                  if (transitionValue !== undefined) {\n                    // Ensure the Player is still in the same state after waiting for transitionValue\n                    const latestState = player.getState();\n                    if (shouldTransition(latestState)) {\n                      latestState.controllers.flow.transition(transitionValue);\n                    } else {\n                      player.logger.warn(\n                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`,\n                      );\n                    }\n                  }\n                } catch (error) {\n                  if (error instanceof Error) {\n                    currentState.fail(error);\n                  }\n                }\n              }\n            }, 0);\n          }\n        });\n      });\n    });\n  }\n}\n"],"mappings":";AAgBO,IAAM,uBAAN,MAAmD;AAAA,EAIxD,YAAY,SAA+B;AAH3C,gBAAO;AAIL,SAAK,UAAU;AAAA,EACjB;AAAA,EAEA,MAAM,QAAgB;AACpB,WAAO,MAAM,eAAe,IAAI,KAAK,MAAM,CAAC,mBAAmB;AAC7D,qBAAe,MAAM,KAAK,IAAI,KAAK,MAAM,CAAC,SAAS;AACjD,aAAK,MAAM,WAAW,IAAI,KAAK,MAAM,CAAC,WAAW,YAAY;AAC3D,gBAAM,EAAE,OAAO,MAAM,IAAI;AACzB,cAAI,MAAM,eAAe,YAAY;AACnC,uBAAW,YAAY;AAErB,oBAAM,mBAAmB,CACvBA,kBAEAA,cAAa,WAAW,iBACxBA,cAAa,YAAY,KAAK,SAAS,cAAc,UACnD;AAEJ,oBAAM,eAAe,OAAO,SAAS;AACrC,kBAAI,iBAAiB,YAAY,GAAG;AAClC,oBAAI;AACF,wBAAM,kBAAkB,MAAM,KAAK;AAAA,oBACjC;AAAA,oBACA,aAAa;AAAA,kBACf;AAEA,sBAAI,oBAAoB,QAAW;AAEjC,0BAAM,cAAc,OAAO,SAAS;AACpC,wBAAI,iBAAiB,WAAW,GAAG;AACjC,kCAAY,YAAY,KAAK,WAAW,eAAe;AAAA,oBACzD,OAAO;AACL,6BAAO,OAAO;AAAA,wBACZ,iCAAiC,eAAe,8CAA8C,QAAQ,IAAI;AAAA,sBAC5G;AAAA,oBACF;AAAA,kBACF;AAAA,gBACF,SAAS,OAAO;AACd,sBAAI,iBAAiB,OAAO;AAC1B,iCAAa,KAAK,KAAK;AAAA,kBACzB;AAAA,gBACF;AAAA,cACF;AAAA,YACF,GAAG,CAAC;AAAA,UACN;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AACF;","names":["currentState"]}

package/package.json

@@ -1,66 +1,29 @@
 {
   "name": "@player-ui/external-action-plugin",
-  "version": "0.8.0--canary.307.9621",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
+  "version": "0.8.0-next.0",
+  "main": "dist/cjs/index.cjs",
   "peerDependencies": {
-    "@player-ui/player": "0.8.0--canary.307.9621"
-  },
-  "dependencies": {
-    "@babel/runtime": "7.15.4"
+    "@player-ui/player": "0.8.0-next.0"
   },
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.esm.js",
-  "typings": "dist/index.d.ts",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
+  "bundle": "dist/ExternalActionPlugin.native.js",
   "sideEffects": false,
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/player-ui/player-ui"
-  },
-  "bugs": {
-    "url": "https://github.com/player-ui/player-ui/issues"
-  },
-  "homepage": "https://player-ui.github.io",
-  "contributors": [
-    {
-      "name": "Adam Dierkens",
-      "url": "https://github.com/adierkens"
-    },
-    {
-      "name": "Spencer Hamm",
-      "url": "https://github.com/spentacular"
-    },
-    {
-      "name": "Harris Borawski",
-      "url": "https://github.com/hborawski"
-    },
-    {
-      "name": "Jeremiah Zucker",
-      "url": "https://github.com/sugarmanz"
-    },
-    {
-      "name": "Ketan Reddy",
-      "url": "https://github.com/KetanReddy"
-    },
-    {
-      "name": "Brocollie08",
-      "url": "https://github.com/brocollie08"
-    },
-    {
-      "name": "Kelly Harrop",
-      "url": "https://github.com/kharrop"
-    },
-    {
-      "name": "Alejandro Fimbres",
-      "url": "https://github.com/lexfm"
-    },
-    {
-      "name": "Rafael Campos",
-      "url": "https://github.com/rafbcampos"
+  "exports": {
+    "./package.json": "./package.json",
+    "./dist/index.css": "./dist/index.css",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
     }
+  },
+  "files": [
+    "dist",
+    "src",
+    "types"
   ],
-  "bundle": "./dist/external-action-plugin.prod.js"
+  "dependencies": {
+    "tslib": "^2.6.2"
+  }
 }

package/src/__tests__/index.test.ts

@@ -0,0 +1,198 @@
+import { expect, test } from "vitest";
+import type { Flow, InProgressState } from "@player-ui/player";
+import { Player } from "@player-ui/player";
+import { ExternalActionPlugin } from "..";
+
+const externalFlow = {
+  id: "test-flow",
+  data: {
+    transitionValue: "Next",
+  },
+  navigation: {
+    BEGIN: "FLOW_1",
+    FLOW_1: {
+      startState: "EXT_1",
+      EXT_1: {
+        state_type: "EXTERNAL",
+        ref: "test-1",
+        transitions: {
+          Next: "END_FWD",
+          Prev: "END_BCK",
+        },
+      },
+      END_FWD: {
+        state_type: "END",
+        outcome: "FWD",
+      },
+      END_BCK: {
+        state_type: "END",
+        outcome: "BCK",
+      },
+    },
+  },
+};
+
+test("handles the external state", async () => {
+  const player = new Player({
+    plugins: [
+      new ExternalActionPlugin((state, options) => {
+        return options.data.get("transitionValue");
+      }),
+    ],
+  });
+
+  const completed = await player.start(externalFlow as Flow);
+
+  expect(completed.endState.outcome).toBe("FWD");
+});
+
+test("thrown errors will fail player", async () => {
+  const player = new Player({
+    plugins: [
+      new ExternalActionPlugin((state, options) => {
+        throw new Error("Bad Code");
+      }),
+    ],
+  });
+
+  await expect(player.start(externalFlow as Flow)).rejects.toThrow();
+
+  expect(player.getState().status).toBe("error");
+});
+
+test("works async", async () => {
+  const player = new Player({
+    plugins: [
+      new ExternalActionPlugin(() => {
+        return Promise.resolve("Prev");
+      }),
+    ],
+  });
+
+  const completed = await player.start(externalFlow as Flow);
+
+  expect(completed.endState.outcome).toBe("BCK");
+});
+
+test("allows multiple plugins", async () => {
+  const player = new Player({
+    plugins: [
+      new ExternalActionPlugin(() => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve("Next");
+          }, 100);
+        });
+      }),
+      new ExternalActionPlugin(() => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve("Prev");
+          }, 50);
+        });
+      }),
+      new ExternalActionPlugin(() => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve(undefined);
+          }, 10);
+        });
+      }),
+    ],
+  });
+
+  const completed = await player.start(externalFlow as Flow);
+
+  // Prev should win
+  expect(completed.endState.outcome).toBe("BCK");
+});
+
+test("only transitions if player still on this external state", async () => {
+  let resolver: (() => void) | undefined;
+  const player = new Player({
+    plugins: [
+      new ExternalActionPlugin((state, options) => {
+        return new Promise((res) => {
+          // Only save resolver for first external action
+          if (!resolver) {
+            resolver = () => {
+              res(options.data.get("transitionValue"));
+            };
+          }
+        });
+      }),
+    ],
+  });
+
+  player.start({
+    id: "test-flow",
+    data: {
+      transitionValue: "Next",
+    },
+    navigation: {
+      BEGIN: "FLOW_1",
+      FLOW_1: {
+        startState: "EXT_1",
+        EXT_1: {
+          state_type: "EXTERNAL",
+          ref: "test-1",
+          transitions: {
+            Next: "EXT_2",
+            Prev: "END_BCK",
+          },
+        },
+        EXT_2: {
+          state_type: "EXTERNAL",
+          ref: "test-2",
+          transitions: {
+            Next: "END_FWD",
+            Prev: "END_BCK",
+          },
+        },
+        END_FWD: {
+          state_type: "END",
+          outcome: "FWD",
+        },
+        END_BCK: {
+          state_type: "END",
+          outcome: "BCK",
+        },
+      },
+    },
+  } as Flow);
+
+  let state = player.getState();
+  expect(state.status).toBe("in-progress");
+  expect(
+    (state as InProgressState).controllers.flow.current?.currentState?.name,
+  ).toBe("EXT_1");
+
+  // probably dumb way to wait for async stuff to resolve
+  await new Promise<void>((res) => {
+    /**
+     *
+     */
+    function waitForResolver() {
+      if (resolver) res();
+      else setTimeout(waitForResolver, 50);
+    }
+
+    waitForResolver();
+  });
+
+  (state as InProgressState).controllers.flow.transition("Next");
+
+  state = player.getState();
+  expect(
+    (state as InProgressState).controllers.flow.current?.currentState?.name,
+  ).toBe("EXT_2");
+
+  // Attempt to resolve _after_ Player has transitioned
+  resolver?.();
+
+  // Should be same as prev
+  state = player.getState();
+  expect(
+    (state as InProgressState).controllers.flow.current?.currentState?.name,
+  ).toBe("EXT_2");
+});

package/src/index.ts

@@ -3,19 +3,19 @@ import type {
   PlayerPlugin,
   InProgressState,
   PlayerFlowState,
-} from '@player-ui/player';
-import type { NavigationFlowExternalState } from '@player-ui/types';
+  NavigationFlowExternalState,
+} from "@player-ui/player";
 
 export type ExternalStateHandler = (
   state: NavigationFlowExternalState,
-  options: InProgressState['controllers']
+  options: InProgressState["controllers"],
 ) => string | undefined | Promise<string | undefined>;
 
 /**
  * A plugin to handle external actions states
  */
 export class ExternalActionPlugin implements PlayerPlugin {
-  name = 'ExternalActionPlugin';
+  name = "ExternalActionPlugin";
   private handler: ExternalStateHandler;
 
   constructor(handler: ExternalStateHandler) {
@@ -27,13 +27,13 @@ export class ExternalActionPlugin implements PlayerPlugin {
       flowController.hooks.flow.tap(this.name, (flow) => {
         flow.hooks.transition.tap(this.name, (fromState, toState) => {
           const { value: state } = toState;
-          if (state.state_type === 'EXTERNAL') {
+          if (state.state_type === "EXTERNAL") {
             setTimeout(async () => {
               /** Helper for ensuring state is still current relative to external state this is handling */
               const shouldTransition = (
-                currentState: PlayerFlowState
+                currentState: PlayerFlowState,
               ): currentState is InProgressState =>
-                currentState.status === 'in-progress' &&
+                currentState.status === "in-progress" &&
                 currentState.controllers.flow.current?.currentState?.value ===
                   state;
 
@@ -42,7 +42,7 @@ export class ExternalActionPlugin implements PlayerPlugin {
                 try {
                   const transitionValue = await this.handler(
                     state,
-                    currentState.controllers
+                    currentState.controllers,
                   );
 
                   if (transitionValue !== undefined) {
@@ -52,7 +52,7 @@ export class ExternalActionPlugin implements PlayerPlugin {
                       latestState.controllers.flow.transition(transitionValue);
                     } else {
                       player.logger.warn(
-                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`
+                        `External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`,
                       );
                     }
                   }

package/types/index.d.ts

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

package/dist/external-action-plugin.dev.js

@@ -1,178 +0,0 @@
-(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["ExternalActionPlugin"] = factory();
-	else
-		root["ExternalActionPlugin"] = 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/external-action/core/dist/index.esm.js");
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ "./bazel-out/k8-fastbuild/bin/plugins/external-action/core/dist/index.esm.js":
-/*!***********************************************************************************!*\
-  !*** ./bazel-out/k8-fastbuild/bin/plugins/external-action/core/dist/index.esm.js ***!
-  \***********************************************************************************/
-/*! exports provided: ExternalActionPlugin */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ExternalActionPlugin", function() { return ExternalActionPlugin; });
-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* () {
-              const shouldTransition = (currentState2) => {
-                var _a, _b;
-                return currentState2.status === "in-progress" && ((_b = (_a = currentState2.controllers.flow.current) == null ? void 0 : _a.currentState) == null ? void 0 : _b.value) === state;
-              };
-              const currentState = player.getState();
-              if (shouldTransition(currentState)) {
-                try {
-                  const transitionValue = yield this.handler(state, currentState.controllers);
-                  if (transitionValue !== void 0) {
-                    const latestState = player.getState();
-                    if (shouldTransition(latestState)) {
-                      latestState.controllers.flow.transition(transitionValue);
-                    } else {
-                      player.logger.warn(`External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`);
-                    }
-                  }
-                } catch (error) {
-                  if (error instanceof Error) {
-                    currentState.fail(error);
-                  }
-                }
-              }
-            }), 0);
-          }
-        });
-      });
-    });
-  }
-}
-
-
-//# sourceMappingURL=index.esm.js.map
-
-
-/***/ })
-
-/******/ });
-});

package/dist/external-action-plugin.prod.js

@@ -1 +0,0 @@
-!function(t,e){"object"===typeof exports&&"object"===typeof module?module.exports=e():"function"===typeof define&&define.amd?define([],e):"object"===typeof exports?exports.ExternalActionPlugin=e():t.ExternalActionPlugin=e()}(this,(function(){return function(t){var e={};function n(r){if(e[r])return e[r].exports;var o=e[r]={i:r,l:!1,exports:{}};return t[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:r})},n.r=function(t){"undefined"!==typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,e){if(1&e&&(t=n(t)),8&e)return t;if(4&e&&"object"===typeof t&&t&&t.__esModule)return t;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)n.d(r,o,function(e){return t[e]}.bind(null,o));return r},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=0)}([function(t,e,n){"use strict";n.r(e),n.d(e,"ExternalActionPlugin",(function(){return r}));class r{constructor(t){this.name="ExternalActionPlugin",this.handler=t}apply(t){t.hooks.flowController.tap(this.name,(e=>{e.hooks.flow.tap(this.name,(e=>{e.hooks.transition.tap(this.name,((e,n)=>{const{value:r}=n;"EXTERNAL"===r.state_type&&setTimeout((()=>{return e=this,o=null,i=function*(){const e=t=>{var e,n;return"in-progress"===t.status&&(null==(n=null==(e=t.controllers.flow.current)?void 0:e.currentState)?void 0:n.value)===r},o=t.getState();if(e(o))try{const i=yield this.handler(r,o.controllers);if(void 0!==i){const r=t.getState();e(r)?r.controllers.flow.transition(i):t.logger.warn(`External state resolved with [${i}], but Player already navigated away from [${n.name}]`)}}catch(i){i instanceof Error&&o.fail(i)}},new Promise(((t,n)=>{var r=t=>{try{a(i.next(t))}catch(e){n(e)}},l=t=>{try{a(i.throw(t))}catch(e){n(e)}},a=e=>e.done?t(e.value):Promise.resolve(e.value).then(r,l);a((i=i.apply(e,o)).next())}));var e,o,i}),0)}))}))}))}}}])}));

package/dist/index.cjs.js

@@ -1,68 +0,0 @@
-'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* () {
-              const shouldTransition = (currentState2) => {
-                var _a, _b;
-                return currentState2.status === "in-progress" && ((_b = (_a = currentState2.controllers.flow.current) == null ? void 0 : _a.currentState) == null ? void 0 : _b.value) === state;
-              };
-              const currentState = player.getState();
-              if (shouldTransition(currentState)) {
-                try {
-                  const transitionValue = yield this.handler(state, currentState.controllers);
-                  if (transitionValue !== void 0) {
-                    const latestState = player.getState();
-                    if (shouldTransition(latestState)) {
-                      latestState.controllers.flow.transition(transitionValue);
-                    } else {
-                      player.logger.warn(`External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`);
-                    }
-                  }
-                } catch (error) {
-                  if (error instanceof Error) {
-                    currentState.fail(error);
-                  }
-                }
-              }
-            }), 0);
-          }
-        });
-      });
-    });
-  }
-}
-
-exports.ExternalActionPlugin = ExternalActionPlugin;
-//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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* () {
-              const shouldTransition = (currentState2) => {
-                var _a, _b;
-                return currentState2.status === "in-progress" && ((_b = (_a = currentState2.controllers.flow.current) == null ? void 0 : _a.currentState) == null ? void 0 : _b.value) === state;
-              };
-              const currentState = player.getState();
-              if (shouldTransition(currentState)) {
-                try {
-                  const transitionValue = yield this.handler(state, currentState.controllers);
-                  if (transitionValue !== void 0) {
-                    const latestState = player.getState();
-                    if (shouldTransition(latestState)) {
-                      latestState.controllers.flow.transition(transitionValue);
-                    } else {
-                      player.logger.warn(`External state resolved with [${transitionValue}], but Player already navigated away from [${toState.name}]`);
-                    }
-                  }
-                } catch (error) {
-                  if (error instanceof Error) {
-                    currentState.fail(error);
-                  }
-                }
-              }
-            }), 0);
-          }
-        });
-      });
-    });
-  }
-}
-
-export { ExternalActionPlugin };
-//# sourceMappingURL=index.esm.js.map