@player-ui/player 0.15.3 → 0.15.4--canary.881.37421

package/package.json

@@ -6,12 +6,12 @@
     "types"
   ],
   "name": "@player-ui/player",
-  "version": "0.15.3",
+  "version": "0.15.4--canary.881.37421",
   "main": "dist/cjs/index.cjs",
   "dependencies": {
-    "@player-ui/partial-match-registry": "0.15.3",
-    "@player-ui/make-flow": "0.15.3",
-    "@player-ui/types": "0.15.3",
+    "@player-ui/partial-match-registry": "0.15.4--canary.881.37421",
+    "@player-ui/make-flow": "0.15.4--canary.881.37421",
+    "@player-ui/types": "0.15.4--canary.881.37421",
     "@types/dlv": "^1.1.4",
     "dequal": "^2.0.2",
     "dlv": "^1.1.3",

package/src/__tests__/data.test.ts

@@ -482,17 +482,4 @@ describe("Read Only Data Controller", () => {
   it("Reads data", () => {
     expect(readOnlyController.get("some.data")).toStrictEqual(true);
   });
-
-  it("Logs error on set", () => {
-    expect(readOnlyController.set([["some.data", false]])).toStrictEqual([]);
-    expect(logger.error).toBeCalledWith(
-      "Error: Tried to set in a read only instance of the DataController",
-    );
-  });
-  it("Logs error on delete", () => {
-    readOnlyController.delete("some.data");
-    expect(logger.error).toBeCalledWith(
-      "Error: Tried to delete in a read only instance of the DataController",
-    );
-  });
 });

package/src/__tests__/view.test.ts

@@ -3,7 +3,7 @@ import type { Flow, NavigationFlowViewState } from "@player-ui/types";
 import type { FlowController } from "../controllers";
 import TrackBindingPlugin from "./helpers/binding.plugin";
 import type { InProgressState } from "../types";
-import { Player } from "..";
+import { Player, PlayerPlugin } from "..";
 import { ActionExpPlugin } from "./helpers/action-exp.plugin";
 
 const minimal: Flow = {
@@ -713,3 +713,36 @@ describe("view update scheduling", () => {
     });
   });
 });
+
+describe("view error capturing", () => {
+  test("should capture errors caused during view resolution and send them to the errorController", async () => {
+    const errorControllerSpy = vitest.fn(() => undefined);
+    const viewFailurePlugin: PlayerPlugin = {
+      name: "ViewFailurePlugin",
+      apply: (player) => {
+        // Force resolution failures to capture in the view controller
+        player.hooks.view.tap("fail", (view) => {
+          view.hooks.resolver.tap("fail", (resolver) => {
+            resolver.hooks.beforeResolve.tap("fail", () => {
+              throw new Error("ERROR!");
+            });
+          });
+        });
+
+        player.hooks.errorController.tap("fail", (controller) => {
+          controller.hooks.onError.tap("fail", errorControllerSpy);
+        });
+      },
+    };
+
+    const player = new Player({ plugins: [viewFailurePlugin] });
+    player.start(minimal).catch(() => {});
+    await vitest.waitFor(() => {
+      expect(errorControllerSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          cause: new Error("ERROR!"),
+        }),
+      );
+    });
+  });
+});

package/src/controllers/data/controller.ts

@@ -243,6 +243,6 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
   }
 
   public makeReadOnly(): ReadOnlyDataController {
-    return new ReadOnlyDataController(this, this.logger);
+    return new ReadOnlyDataController(this);
   }
 }

package/src/controllers/data/utils.ts

@@ -1,39 +1,18 @@
 import type { DataController } from ".";
-import type { Logger } from "../../logger";
 import type { BindingLike } from "../../binding";
-import type {
-  DataModelWithParser,
-  DataModelOptions,
-  Updates,
-} from "../../data";
+import type { DataModelWithParser, DataModelOptions } from "../../data";
 
 /** Wrapper for the Data Controller Class that prevents writes */
-export class ReadOnlyDataController implements DataModelWithParser<DataModelOptions> {
+export class ReadOnlyDataController
+  implements Pick<DataModelWithParser<DataModelOptions>, "get">
+{
   private controller: DataController;
-  private logger?: Logger;
 
-  constructor(controller: DataController, logger?: Logger) {
+  constructor(controller: DataController) {
     this.controller = controller;
-    this.logger = logger;
   }
 
   get(binding: BindingLike, options?: DataModelOptions | undefined) {
     return this.controller.get(binding, options);
   }
-
-  set(
-    transaction: [BindingLike, any][],
-    options?: DataModelOptions | undefined,
-  ): Updates {
-    this.logger?.error(
-      "Error: Tried to set in a read only instance of the DataController",
-    );
-    return [];
-  }
-
-  delete(binding: BindingLike, options?: DataModelOptions | undefined): void {
-    this.logger?.error(
-      "Error: Tried to delete in a read only instance of the DataController",
-    );
-  }
 }

package/src/controllers/error/__tests__/controller.test.ts

@@ -0,0 +1,359 @@
+import { describe, it, beforeEach, expect, vitest } from "vitest";
+import { ErrorController } from "../controller";
+import {
+  ErrorMetadata,
+  ErrorSeverity,
+  ErrorTypes,
+  PlayerErrorMetadata,
+} from "../types";
+import type { DataController } from "../../data/controller";
+import type { FlowController } from "../../flow/controller";
+import type { Logger } from "../../../logger";
+
+/** 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("ErrorController", () => {
+  let errorController: ErrorController;
+  let mockDataController: DataController;
+  let mockFlowController: FlowController;
+  let mockLogger: Logger;
+  let mockFail: ReturnType<typeof vitest.fn>;
+
+  beforeEach(() => {
+    mockDataController = {
+      set: vitest.fn(),
+      get: vitest.fn(),
+      delete: vitest.fn(),
+    } as any;
+
+    mockFlowController = {
+      current: undefined,
+    } as any;
+
+    mockLogger = {
+      trace: vitest.fn(),
+      debug: vitest.fn(),
+      info: vitest.fn(),
+      warn: vitest.fn(),
+      error: vitest.fn(),
+    };
+
+    mockFail = vitest.fn();
+
+    errorController = new ErrorController({
+      logger: mockLogger,
+      flow: mockFlowController,
+      fail: mockFail,
+      model: mockDataController,
+    });
+  });
+
+  describe("captureError", () => {
+    it("should capture error with metadata", () => {
+      const error = new ErrorWithProps(
+        "Test error",
+        ErrorTypes.EXPRESSION,
+        ErrorSeverity.ERROR,
+        { state: "VIEW_Test" },
+      );
+
+      const result = errorController.captureError(error);
+
+      expect(result).toBe(false);
+      const playerError = errorController.getCurrentError();
+      expect(playerError).toBe(error);
+      expect(playerError?.type).toBe(ErrorTypes.EXPRESSION);
+      expect(playerError?.severity).toBe(ErrorSeverity.ERROR);
+      expect(playerError?.metadata?.state).toBe("VIEW_Test");
+    });
+
+    it("should add error to history", () => {
+      const error1 = new ErrorWithProps("Error 1", "test-error-1");
+      const error2 = new ErrorWithProps("Error 2", "test-error-2");
+
+      errorController.captureError(error1);
+      errorController.captureError(error2);
+
+      const history = errorController.getErrors();
+      expect(history).toHaveLength(2);
+      expect(history[0]).toBe(error1);
+      expect(history[1]).toBe(error2);
+    });
+
+    it("should set as current error", () => {
+      const error = new ErrorWithProps("Test error", "test-error");
+      errorController.captureError(error);
+
+      const currentError = errorController.getCurrentError();
+      expect(currentError).toBe(error);
+    });
+
+    it("should write to data model", () => {
+      const error = new ErrorWithProps("Test error", ErrorTypes.EXPRESSION);
+      errorController.captureError(error);
+
+      expect(mockDataController.set).toHaveBeenCalledWith(
+        [
+          [
+            "errorState",
+            expect.objectContaining({
+              message: "Test error",
+              name: "Error",
+              errorType: ErrorTypes.EXPRESSION,
+            }),
+          ],
+        ],
+        expect.objectContaining({
+          writeSymbol: expect.any(Symbol),
+        }),
+      );
+    });
+  });
+
+  describe("getCurrentError", () => {
+    it("should return undefined when no errors", () => {
+      expect(errorController.getCurrentError()).toBeUndefined();
+    });
+
+    it("should return current error", () => {
+      const error = new ErrorWithProps("Test error", "test-error");
+      errorController.captureError(error);
+
+      expect(errorController.getCurrentError()).toBe(error);
+    });
+  });
+
+  describe("getErrors", () => {
+    it("should return empty array when no errors", () => {
+      expect(errorController.getErrors()).toEqual([]);
+    });
+
+    it("should return error history", () => {
+      const error1 = new ErrorWithProps("Error 1", "error-1");
+      const error2 = new ErrorWithProps("Error 2", "error-2");
+
+      errorController.captureError(error1);
+      errorController.captureError(error2);
+
+      const errors = errorController.getErrors();
+      expect(errors).toHaveLength(2);
+      expect(errors[0]).toBe(error1);
+      expect(errors[1]).toBe(error2);
+    });
+  });
+
+  describe("clearErrors", () => {
+    it("should clear all errors and history", () => {
+      errorController.captureError(new ErrorWithProps("Error 1", "error-1"));
+      errorController.captureError(new ErrorWithProps("Error 2", "error-2"));
+
+      errorController.clearErrors();
+
+      expect(errorController.getCurrentError()).toBeUndefined();
+      expect(errorController.getErrors()).toEqual([]);
+    });
+
+    it("should delete errorState from data model", () => {
+      errorController.captureError(
+        new ErrorWithProps("Test error", "test-error"),
+      );
+
+      // Reset mock to track only clearErrors call
+      vitest.mocked(mockDataController.set).mockClear();
+
+      errorController.clearErrors();
+
+      expect(mockDataController.delete).toHaveBeenCalledWith(
+        "errorState",
+        expect.objectContaining({
+          writeSymbol: expect.any(Symbol),
+        }),
+      );
+    });
+
+    it("should handle missing data controller gracefully", () => {
+      const controller = new ErrorController({
+        logger: mockLogger,
+        flow: mockFlowController,
+        fail: mockFail,
+      });
+      controller.captureError(new ErrorWithProps("Test error", "test-error"));
+
+      expect(() => controller.clearErrors()).not.toThrow();
+    });
+  });
+
+  describe("clearCurrentError", () => {
+    it("should clear current error but preserve history", () => {
+      const error1 = new ErrorWithProps("Error 1", "error-1");
+      const error2 = new ErrorWithProps("Error 2", "error-2");
+
+      errorController.captureError(error1);
+      errorController.captureError(error2);
+
+      errorController.clearCurrentError();
+
+      expect(errorController.getCurrentError()).toBeUndefined();
+      expect(errorController.getErrors()).toHaveLength(2);
+    });
+
+    it("should delete errorState from data model", () => {
+      errorController.captureError(
+        new ErrorWithProps("Test error", "test-error"),
+      );
+
+      // Reset mock to track only clearCurrentError call
+      vitest.mocked(mockDataController.set).mockClear();
+
+      errorController.clearCurrentError();
+
+      expect(mockDataController.delete).toHaveBeenCalledWith(
+        "errorState",
+        expect.objectContaining({
+          writeSymbol: expect.any(Symbol),
+        }),
+      );
+    });
+
+    it("should handle missing data controller gracefully", () => {
+      const controller = new ErrorController({
+        logger: mockLogger,
+        flow: mockFlowController,
+        fail: mockFail,
+      });
+      controller.captureError(new ErrorWithProps("Test error", "test-error"));
+
+      expect(() => controller.clearCurrentError()).not.toThrow();
+    });
+  });
+
+  describe("onError hook", () => {
+    it("should allow plugins to observe errors", () => {
+      const onErrorSpy = vitest.fn();
+      errorController.hooks.onError.tap("test", onErrorSpy);
+
+      const error = new ErrorWithProps("Test error", "test-error");
+      errorController.captureError(error);
+
+      expect(onErrorSpy).toHaveBeenCalledTimes(1);
+      expect(onErrorSpy).toHaveBeenCalledWith(error);
+    });
+
+    it("should allow plugins to bail by returning true, stopping execution and preventing data model update", () => {
+      const observer1 = vitest.fn(() => undefined);
+      const skipPlugin = vitest.fn(() => true);
+      const observer2 = vitest.fn(() => undefined);
+
+      errorController.hooks.onError.tap("observer1", observer1);
+      errorController.hooks.onError.tap("skip-plugin", skipPlugin);
+      errorController.hooks.onError.tap("observer2", observer2);
+
+      const error = new ErrorWithProps("Test error", "test-error");
+      const result = errorController.captureError(error);
+
+      expect(observer1).toHaveBeenCalledTimes(1);
+      expect(skipPlugin).toHaveBeenCalledWith(error);
+      expect(observer2).not.toHaveBeenCalled(); // Execution stops after bail
+      // Data model should not be updated when skipped
+      expect(mockDataController.set).not.toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+
+    it("should continue to next plugin when undefined is returned", () => {
+      const observer1 = vitest.fn(() => undefined);
+      const observer2 = vitest.fn(() => undefined);
+      errorController.hooks.onError.tap("observer1", observer1);
+      errorController.hooks.onError.tap("observer2", observer2);
+
+      const error = new ErrorWithProps("Test error", "test-error");
+      errorController.captureError(error);
+
+      expect(observer1).toHaveBeenCalledTimes(1);
+      expect(observer2).toHaveBeenCalledTimes(1);
+      // Data model should be updated when not skipped
+      expect(mockDataController.set).toHaveBeenCalled();
+    });
+  });
+
+  describe("custom error types", () => {
+    it("should allow custom plugin error types", () => {
+      const error = new ErrorWithProps(
+        "Custom plugin error",
+        "my-custom-plugin",
+        ErrorSeverity.WARNING,
+      );
+      const result = errorController.captureError(error);
+
+      expect(result).toBe(false);
+      const playerError = errorController.getCurrentError();
+      expect(playerError?.type).toBe("my-custom-plugin");
+      expect(playerError?.severity).toBe(ErrorSeverity.WARNING);
+    });
+  });
+
+  describe("integration with middleware", () => {
+    it("should use middleware to protect errorState from external deletes", () => {
+      const middleware = errorController.getDataMiddleware();
+
+      // Middleware should block deletes by default
+      expect(middleware.name).toBe("error-state-middleware");
+
+      // Capture an error (sets errorState)
+      errorController.captureError(
+        new ErrorWithProps("Test error", ErrorTypes.VIEW),
+      );
+      expect(mockDataController.set).toHaveBeenCalled();
+
+      // Clear error should delete via middleware with writeSymbol
+      vitest.mocked(mockDataController.set).mockClear();
+      errorController.clearCurrentError();
+      expect(mockDataController.delete).toHaveBeenCalledWith(
+        "errorState",
+        expect.objectContaining({
+          writeSymbol: expect.any(Symbol),
+        }),
+      );
+    });
+  });
+
+  describe("Fallback - Error without PlayerErrorMetadata interface", () => {
+    it("should not write errors that do not implement PlayerErrorMetadata", () => {
+      const middleware = errorController.getDataMiddleware();
+
+      // Middleware should block deletes by default
+      expect(middleware.name).toBe("error-state-middleware");
+
+      // Capture an error without metadata - no error in data controller
+      errorController.captureError(new Error("Test error"));
+      expect(mockDataController.set).not.toHaveBeenCalled();
+
+      // Clear error shouldn't about current state. Should always try to clear.
+      vitest.mocked(mockDataController.set).mockClear();
+      errorController.clearCurrentError();
+      expect(mockDataController.delete).toHaveBeenCalledWith(
+        "errorState",
+        expect.objectContaining({
+          writeSymbol: expect.any(Symbol),
+        }),
+      );
+    });
+
+    it("should not call the onError hook when the error is unrecognized.", () => {
+      const onErrorSpy = vitest.fn();
+      errorController.hooks.onError.tap("test", onErrorSpy);
+      errorController.captureError(new Error("Test error"));
+
+      expect(onErrorSpy).not.toHaveBeenCalled();
+    });
+  });
+});