@player-ui/async-node-plugin 0.15.4--canary.881.37421 → 0.15.4--canary.884.37483

package/types/index.d.ts

@@ -1,9 +1,25 @@
-import type { Player, PlayerPlugin, Node, ViewInstance, Parser, ViewPlugin, Resolver } from "@player-ui/player";
+import type { Player, PlayerPlugin, Node, ViewInstance, Parser, ViewPlugin, Resolver, ViewController } from "@player-ui/player";
 import { AsyncSeriesBailHook, SyncBailHook } from "tapable-ts";
-import { AsyncPluginContext } from "./internal-types";
 export * from "./types";
 export * from "./transform";
 export * from "./createAsyncTransform";
+/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
+ * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
+ */
+type AsyncPluginContext = {
+    /** Map of async node id to resolved content */
+    nodeResolveCache: Map<string, Node.Node>;
+    /** The view instance this context is attached to. */
+    view: ViewInstance;
+    /** The view controller this context is attached to. */
+    viewController: ViewController;
+    /** Map of async node id to promises being used to resolve them */
+    inProgressNodes: Set<string>;
+    /** Map of async node ids to the original node they represent.
+     * In some cases, async nodes are transformed into from other node types so the original reference is needed in order to trigger an update on the view when the async node changes.
+     */
+    originalNodeCache: Map<string, Set<Node.Node>>;
+};
 export interface AsyncNodePluginOptions {
     /** A set of plugins to load  */
     plugins?: AsyncNodeViewPlugin[];
@@ -64,7 +80,6 @@ export declare class AsyncNodePluginPlugin implements AsyncNodeViewPlugin {
      */
     private handleAsyncUpdate;
     private hasValidMapping;
-    private getOrCreateAsyncNodeCacheEntry;
     /**
      * Handles the asynchronous API integration for resolving nodes.
      * This method sets up a hook on the resolver's `beforeResolve` event to process async nodes.

package/types/utils/index.d.ts

@@ -2,6 +2,4 @@ export * from "./extractNodeFromPath";
 export * from "./traverseAndReplace";
 export * from "./unwrapAsset";
 export * from "./requiresAssetWrapper";
-export * from "./isAsyncPlayerError";
-export * from "./getNodeFromError";
 //# sourceMappingURL=index.d.ts.map

package/src/AsyncNodeError.ts

@@ -1,30 +0,0 @@
-import {
-  ErrorSeverity,
-  type Node,
-  type PlayerErrorMetadata,
-} from "@player-ui/player";
-
-export const ASYNC_ERROR_TYPE = "ASYNC-PLUGIN";
-export type AsyncErrorMetadata = {
-  node: Node.Async;
-};
-export class AsyncNodeError
-  extends Error
-  implements PlayerErrorMetadata<AsyncErrorMetadata>
-{
-  readonly type: string = ASYNC_ERROR_TYPE;
-  readonly severity: ErrorSeverity = ErrorSeverity.ERROR;
-  readonly metadata: AsyncErrorMetadata;
-
-  constructor(
-    node: Node.Async,
-    message?: string,
-    public readonly cause?: Error | undefined,
-  ) {
-    super(message);
-
-    this.metadata = {
-      node,
-    };
-  }
-}

package/src/internal-types.ts

@@ -1,30 +0,0 @@
-import type { Node, ViewController, ViewInstance } from "@player-ui/player";
-
-export type AsyncNodeInfo = {
-  /** The async node */
-  asyncNode: Node.Async;
-  /** All nodes that need to be updated when the async content changes. This could be the async node itself, or a node that created it (i.e. an asset node that transformed into an async node). */
-  updateNodes: Set<Node.Node>;
-  /** The resolved content for this async node */
-  resolvedContent?: Node.Node;
-};
-
-/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
- * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
- */
-export type AsyncPluginContext = {
-  /** The view instance this context is attached to. */
-  view: ViewInstance;
-  /** The view controller this context is attached to. */
-  viewController: ViewController;
-  /** Set of async node ids that are currently being managed by an incomplete promise. */
-  inProgressNodes: Set<string>;
-  /** Map of async node ids to related info for that node. */
-  asyncNodeCache: Map<string, AsyncNodeInfo>;
-  /** Maps asset ids to its original node. Used to then search for what if could be generated by. */
-  assetIdCache: Map<string, Node.Node>;
-  /** Maps nodes to the async id that generated them. */
-  generatedByMap: Map<Node.Node, string>;
-  /** Map to track the original parent of nodes that were flattened into another. This is needed to track which async nodes actually generated these nodes. */
-  originalParentMap: Map<Node.Node, Node.Node>;
-};

package/src/utils/__tests__/getNodeFromError.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { getNodeFromError } from "../getNodeFromError";
-import { isAsyncPlayerError } from "../isAsyncPlayerError";
-import {
-  ErrorMetadata,
-  ErrorSeverity,
-  ErrorTypes,
-  NodeType,
-  PlayerError,
-  PlayerErrorMetadata,
-} from "@player-ui/player";
-import { AsyncNodeInfo, AsyncPluginContext } from "../../internal-types";
-import { ASYNC_ERROR_TYPE, AsyncNodeError } from "../../AsyncNodeError";
-
-vi.mock("../isAsyncPlayerError");
-
-/** Test class to create an error with any additional properties */
-class ErrorWithProps extends Error implements PlayerErrorMetadata {
-  constructor(
-    message: string,
-    public type: string,
-    public severity?: ErrorSeverity,
-    public metadata?: ErrorMetadata,
-  ) {
-    super(message);
-  }
-}
-
-const createPlayerError = (
-  errorType: string,
-  metadata?: ErrorMetadata,
-): PlayerError =>
-  new ErrorWithProps("Error", errorType, ErrorSeverity.ERROR, metadata);
-
-const createContext = (
-  baseContext?: Partial<AsyncPluginContext>,
-): AsyncPluginContext => ({
-  assetIdCache: new Map(),
-  asyncNodeCache: new Map(),
-  generatedByMap: new Map(),
-  inProgressNodes: new Set(),
-  originalParentMap: new Map(),
-  view: {} as any,
-  viewController: {} as any,
-  ...baseContext,
-});
-
-describe("getNodeFromError", () => {
-  beforeEach(() => {
-    vi.mocked(isAsyncPlayerError).mockReturnValue(false);
-  });
-  describe("render errors", () => {
-    it("should be undefined when no string assetId is in the error metadata", () => {
-      const result = getNodeFromError(
-        createPlayerError(ErrorTypes.RENDER, {}),
-        createContext(),
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    it("should be undefined the assetId is not in the context cache", () => {
-      const result = getNodeFromError(
-        createPlayerError(ErrorTypes.RENDER, { assetId: "test-id" }),
-        createContext(),
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    it("should be the node from the assetIdCache if the assetId is available", () => {
-      const context = createContext();
-      context.assetIdCache.set("test-id", {
-        type: NodeType.Value,
-        value: {
-          prop: "value",
-        },
-      });
-      const result = getNodeFromError(
-        createPlayerError(ErrorTypes.RENDER, { assetId: "test-id" }),
-        context,
-      );
-
-      expect(result).toStrictEqual({
-        type: NodeType.Value,
-        value: {
-          prop: "value",
-        },
-      });
-    });
-  });
-
-  describe("view errors", () => {
-    const notRealNodes = [undefined, null, [], "node"];
-    it.each(notRealNodes)(
-      "should return undefined for any view error without a node",
-      (node) => {
-        const result = getNodeFromError(
-          createPlayerError(ErrorTypes.VIEW, { node }),
-          createContext(),
-        );
-
-        expect(result).toBeUndefined();
-      },
-    );
-
-    it("should return the node property if it is a node", () => {
-      const result = getNodeFromError(
-        createPlayerError(ErrorTypes.VIEW, {
-          node: {
-            type: NodeType.Value,
-            value: {
-              prop: "value",
-            },
-          },
-        }),
-        createContext(),
-      );
-
-      expect(result).toStrictEqual({
-        type: NodeType.Value,
-        value: {
-          prop: "value",
-        },
-      });
-    });
-  });
-
-  describe("async errors", () => {
-    it("should return undefined if the error is not recognized as an async error", () => {
-      const result = getNodeFromError(
-        {
-          error: new ErrorWithProps(
-            "Error",
-            ASYNC_ERROR_TYPE,
-            ErrorSeverity.ERROR,
-            {
-              node: {
-                type: NodeType.Value,
-                value: {
-                  prop: "value",
-                },
-              },
-            },
-          ),
-          errorType: ASYNC_ERROR_TYPE,
-          skipped: false,
-        },
-        createContext(),
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    it("should return undefined if the node from the error is undefined", () => {
-      vi.mocked(isAsyncPlayerError).mockReturnValue(true);
-      const result = getNodeFromError(
-        createPlayerError(ASYNC_ERROR_TYPE, undefined),
-        createContext(),
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    it("should return the node the asyncNodeCache if an id matches", () => {
-      vi.mocked(isAsyncPlayerError).mockReturnValue(true);
-      const cacheEntry: AsyncNodeInfo = {
-        asyncNode: {
-          type: NodeType.Async,
-          id: "test-id",
-          value: {
-            type: NodeType.Value,
-            value: {
-              prop: "value cached",
-            },
-          },
-        },
-        updateNodes: new Set(),
-      };
-      const result = getNodeFromError(
-        new AsyncNodeError({
-          type: NodeType.Async,
-          id: "test-id",
-          value: {
-            type: NodeType.Value,
-            value: {
-              prop: "value",
-            },
-          },
-        }),
-        createContext({
-          asyncNodeCache: new Map([["test-id", cacheEntry]]),
-        }),
-      );
-
-      expect(result).toStrictEqual({
-        type: NodeType.Async,
-        id: "test-id",
-        value: {
-          type: NodeType.Value,
-          value: {
-            prop: "value cached",
-          },
-        },
-      });
-    });
-  });
-
-  describe("other errors", () => {
-    it("should return undefined for all other errors", () => {
-      const result = getNodeFromError(
-        createPlayerError("UNKNOWN", {}),
-        createContext(),
-      );
-
-      expect(result).toBeUndefined();
-    });
-  });
-});

package/src/utils/__tests__/isAsyncPlayerError.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isAsyncPlayerError } from "../isAsyncPlayerError";
-import {
-  ErrorMetadata,
-  ErrorSeverity,
-  PlayerErrorMetadata,
-} from "@player-ui/player";
-
-/** Test class to create an error with any additional properties */
-class ErrorWithProps extends Error implements PlayerErrorMetadata {
-  constructor(
-    message: string,
-    public type: string,
-    public severity?: ErrorSeverity,
-    public metadata?: ErrorMetadata,
-  ) {
-    super(message);
-  }
-}
-
-describe("isAsyncPlayerError", () => {
-  it("should return true for errors with the type 'ASYNC-PLUGIN'", () => {
-    expect(isAsyncPlayerError(new ErrorWithProps("test", "ASYNC-PLUGIN"))).toBe(
-      true,
-    );
-  });
-
-  it("should return false for errors without the type 'ASYNC-PLUGIN'", () => {
-    expect(isAsyncPlayerError(new ErrorWithProps("test", "UNKNOWN"))).toBe(
-      false,
-    );
-  });
-});

package/src/utils/getNodeFromError.ts

@@ -1,34 +0,0 @@
-import { PlayerError, Node, ErrorTypes } from "@player-ui/player";
-import { AsyncPluginContext } from "../internal-types";
-import { isAsyncPlayerError } from "./isAsyncPlayerError";
-
-/** Get the AST Node related to a specific error if available. */
-export const getNodeFromError = (
-  playerError: PlayerError,
-  context: AsyncPluginContext,
-): Node.Node | undefined => {
-  if (playerError.type === ErrorTypes.RENDER) {
-    const { assetId } = playerError.metadata ?? {};
-
-    if (typeof assetId !== "string") {
-      return undefined;
-    }
-
-    return context.assetIdCache.get(assetId);
-  }
-
-  if (playerError.type === ErrorTypes.VIEW) {
-    const { node } = playerError.metadata ?? {};
-    // TODO: Remove some of this from here. Maybe export type assertion functions from where the errors are generated?
-    if (typeof node === "object" && node !== null && !Array.isArray(node)) {
-      return node as Node.Node;
-    }
-  }
-
-  if (isAsyncPlayerError(playerError) && playerError.metadata !== undefined) {
-    // Use the node from the cache to ensure it is the latest version of the async node from the resolver
-    return context.asyncNodeCache.get(playerError.metadata.node.id)?.asyncNode;
-  }
-
-  return undefined;
-};

package/src/utils/isAsyncPlayerError.ts

@@ -1,8 +0,0 @@
-import { PlayerError } from "@player-ui/player";
-import { ASYNC_ERROR_TYPE, AsyncErrorMetadata } from "../AsyncNodeError";
-
-export const isAsyncPlayerError = (
-  error: PlayerError,
-): error is PlayerError<AsyncErrorMetadata> => {
-  return error.type === ASYNC_ERROR_TYPE;
-};

package/types/AsyncNodeError.d.ts

@@ -1,13 +0,0 @@
-import { ErrorSeverity, type Node, type PlayerErrorMetadata } from "@player-ui/player";
-export declare const ASYNC_ERROR_TYPE = "ASYNC-PLUGIN";
-export type AsyncErrorMetadata = {
-    node: Node.Async;
-};
-export declare class AsyncNodeError extends Error implements PlayerErrorMetadata<AsyncErrorMetadata> {
-    readonly cause?: Error | undefined;
-    readonly type: string;
-    readonly severity: ErrorSeverity;
-    readonly metadata: AsyncErrorMetadata;
-    constructor(node: Node.Async, message?: string, cause?: Error | undefined);
-}
-//# sourceMappingURL=AsyncNodeError.d.ts.map

package/types/internal-types.d.ts

@@ -1,29 +0,0 @@
-import type { Node, ViewController, ViewInstance } from "@player-ui/player";
-export type AsyncNodeInfo = {
-    /** The async node */
-    asyncNode: Node.Async;
-    /** All nodes that need to be updated when the async content changes. This could be the async node itself, or a node that created it (i.e. an asset node that transformed into an async node). */
-    updateNodes: Set<Node.Node>;
-    /** The resolved content for this async node */
-    resolvedContent?: Node.Node;
-};
-/** Object type for storing data related to a single `apply` of the `AsyncNodePluginPlugin`
- * This object should be setup once per ViewInstance to keep any cached info just for that view to avoid conflicts of shared async node ids across different view states.
- */
-export type AsyncPluginContext = {
-    /** The view instance this context is attached to. */
-    view: ViewInstance;
-    /** The view controller this context is attached to. */
-    viewController: ViewController;
-    /** Set of async node ids that are currently being managed by an incomplete promise. */
-    inProgressNodes: Set<string>;
-    /** Map of async node ids to related info for that node. */
-    asyncNodeCache: Map<string, AsyncNodeInfo>;
-    /** Maps asset ids to its original node. Used to then search for what if could be generated by. */
-    assetIdCache: Map<string, Node.Node>;
-    /** Maps nodes to the async id that generated them. */
-    generatedByMap: Map<Node.Node, string>;
-    /** Map to track the original parent of nodes that were flattened into another. This is needed to track which async nodes actually generated these nodes. */
-    originalParentMap: Map<Node.Node, Node.Node>;
-};
-//# sourceMappingURL=internal-types.d.ts.map

package/types/utils/getNodeFromError.d.ts

@@ -1,5 +0,0 @@
-import { PlayerError, Node } from "@player-ui/player";
-import { AsyncPluginContext } from "../internal-types";
-/** Get the AST Node related to a specific error if available. */
-export declare const getNodeFromError: (playerError: PlayerError, context: AsyncPluginContext) => Node.Node | undefined;
-//# sourceMappingURL=getNodeFromError.d.ts.map

package/types/utils/isAsyncPlayerError.d.ts

@@ -1,4 +0,0 @@
-import { PlayerError } from "@player-ui/player";
-import { AsyncErrorMetadata } from "../AsyncNodeError";
-export declare const isAsyncPlayerError: (error: PlayerError) => error is PlayerError<AsyncErrorMetadata>;
-//# sourceMappingURL=isAsyncPlayerError.d.ts.map