@player-ui/async-node-plugin 0.8.0--canary.307.9621 → 0.8.0-next.0

package/dist/index.esm.js

@@ -1,94 +0,0 @@
-import { NodeType, getNodeID } from '@player-ui/player';
-import { AsyncParallelBailHook } from 'tapable-ts';
-import queueMicrotask from 'queue-microtask';
-import { omit } from 'timm';
-
-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 AsyncNodePlugin {
-  constructor() {
-    this.hooks = {
-      onAsyncNode: new AsyncParallelBailHook()
-    };
-    this.name = "AsyncNode";
-    this.resolvedMapping = new Map();
-  }
-  isAsync(node) {
-    return (node == null ? void 0 : node.type) === NodeType.Async;
-  }
-  apply(player) {
-    player.hooks.viewController.tap(this.name, (viewController) => {
-      viewController.hooks.view.tap(this.name, (view) => {
-        view.hooks.parser.tap(this.name, (parser) => {
-          parser.hooks.determineNodeType.tap(this.name, (obj) => {
-            if (Object.prototype.hasOwnProperty.call(obj, "async")) {
-              return NodeType.Async;
-            }
-          });
-          parser.hooks.parseNode.tap(this.name, (obj, nodeType, options, determinedNodeType) => {
-            if (determinedNodeType === NodeType.Async) {
-              const parsedAsync = parser.parseObject(omit(obj, "async"), nodeType, options);
-              const parsedNodeId = getNodeID(parsedAsync);
-              if (parsedAsync !== null && parsedNodeId) {
-                return parser.createASTNode({
-                  id: parsedNodeId,
-                  type: NodeType.Async,
-                  value: parsedAsync
-                }, obj);
-              }
-              return null;
-            }
-          });
-        });
-        view.hooks.resolver.tap(this.name, (resolver) => {
-          resolver.hooks.beforeResolve.tap(this.name, (node, options) => {
-            let resolvedNode;
-            if (this.isAsync(node)) {
-              const mappedValue = this.resolvedMapping.get(node.id);
-              if (mappedValue) {
-                resolvedNode = mappedValue;
-              }
-            } else {
-              resolvedNode = null;
-            }
-            const newNode = resolvedNode || node;
-            if (!resolvedNode && (node == null ? void 0 : node.type) === NodeType.Async) {
-              queueMicrotask(() => __async(this, null, function* () {
-                var _a;
-                const result = yield this.hooks.onAsyncNode.call(node);
-                const parsedNode = options.parseNode ? options.parseNode(result) : void 0;
-                if (parsedNode) {
-                  this.resolvedMapping.set(node.id, parsedNode);
-                  (_a = viewController.currentView) == null ? void 0 : _a.updateAsync();
-                }
-              }));
-              return node;
-            }
-            return newNode;
-          });
-        });
-      });
-    });
-  }
-}
-
-export { AsyncNodePlugin };
-//# sourceMappingURL=index.esm.js.map