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

package/package.json

@@ -1,77 +1,43 @@
 {
   "name": "@player-ui/player",
-  "version": "0.8.0--canary.307.9621",
-  "private": false,
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
-  "peerDependencies": {},
+  "version": "0.8.0-next.0",
+  "main": "dist/cjs/index.cjs",
   "dependencies": {
-    "@player-ui/partial-match-registry": "0.8.0--canary.307.9621",
-    "@player-ui/types": "0.8.0--canary.307.9621",
+    "@player-ui/partial-match-registry": "0.8.0-next.0",
+    "@player-ui/make-flow": "0.8.0-next.0",
+    "@player-ui/types": "0.8.0-next.0",
+    "@types/dlv": "^1.1.4",
+    "@types/parsimmon": "^1.10.0",
+    "arr-flatten": "^1.1.0",
     "dequal": "^2.0.2",
+    "dlv": "^1.1.3",
+    "ebnf": "^1.9.0",
+    "error-polyfill": "^0.1.3",
     "p-defer": "^3.0.0",
+    "parsimmon": "^1.12.0",
     "queue-microtask": "^1.2.3",
     "tapable-ts": "^0.2.3",
-    "parsimmon": "^1.12.0",
-    "@types/parsimmon": "^1.10.0",
-    "arr-flatten": "^1.1.0",
-    "ebnf": "^1.9.0",
     "timm": "^1.6.2",
-    "error-polyfill": "^0.1.3",
     "ts-nested-error": "^1.2.1",
-    "@babel/runtime": "7.15.4"
+    "tslib": "^2.6.2"
   },
-  "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/Player.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/player.prod.js"
+  "peerDependencies": {}
 }

package/src/__tests__/data.test.ts

@@ -0,0 +1,498 @@
+import { describe, it, beforeEach, vitest, test, expect } from "vitest";
+import { BindingParser } from "../binding";
+import { LocalModel } from "../data";
+import { ValidationMiddleware } from "../validator";
+import type { Logger } from "..";
+import { DataController } from "..";
+import type { ReadOnlyDataController } from "../controllers/data/utils";
+
+test("works with basic data", () => {
+  const model = {
+    foo: {
+      bar: "baz",
+    },
+    bar: "foo",
+    baz: [{ foo: "1" }],
+  };
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({ get: localData.get, set: localData.set });
+  const controller = new DataController({}, { pathResolver: parser });
+
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  expect(controller.get("foo")).toStrictEqual(model.foo);
+  expect(controller.get("foo.bar")).toStrictEqual(model.foo.bar);
+  expect(controller.get("baz.0.foo")).toStrictEqual(model.baz[0].foo);
+
+  controller.set({ "foo.baz": "bar" });
+  expect(controller.get("foo.baz")).toStrictEqual("bar");
+});
+
+test("works with path segments starting with numbers", () => {
+  const model = {
+    foo: {
+      "5f4704fd-adab-49df-bcbc-5aedb04194f9": {
+        bar: "baz",
+      },
+    },
+  };
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({ get: localData.get, set: localData.set });
+  const controller = new DataController({}, { pathResolver: parser });
+
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  expect(controller.get("foo.5f4704fd-adab-49df-bcbc-5aedb04194f9.bar")).toBe(
+    "baz",
+  );
+});
+
+test("works with nested model refs", () => {
+  const model = {
+    foo: {
+      bar: "baz",
+    },
+    other: "bar",
+  };
+
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({ get: localData.get, set: localData.set });
+  const controller = new DataController({}, { pathResolver: parser });
+
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  expect(controller.get("foo.{{other}}")).toStrictEqual(model.foo.bar);
+});
+
+test("works with variable indexes", () => {
+  const model = {
+    foo: [{ bar: "AAA" }, { bar: "BBB" }],
+    baz: 1,
+  };
+
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({ get: localData.get, set: localData.set });
+  const controller = new DataController({}, { pathResolver: parser });
+
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  expect(controller.get("foo[{{baz}}].bar")).toStrictEqual("BBB");
+  controller.set([["baz", 0]]);
+  expect(controller.get("foo[{{baz}}].bar")).toStrictEqual("AAA");
+});
+
+test("works with updates", () => {
+  const model = {
+    foo: [{ UUID: "not baz" }],
+  };
+
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({ get: localData.get, set: localData.set });
+  const controller = new DataController({}, { pathResolver: parser });
+
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  controller.set({
+    "foo[UUID='baz'].blah": "blah",
+  });
+
+  expect(controller.get("foo.0.UUID")).toStrictEqual(model.foo[0].UUID);
+  expect(controller.get("foo.1.UUID")).toStrictEqual("baz");
+  expect(controller.get("foo.1.blah")).toStrictEqual("blah");
+});
+
+describe("delete", () => {
+  test("requires binding", () => {
+    const model = {
+      foo: {
+        bar: "Some Data",
+      },
+    };
+
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    expect(() => controller.delete(undefined as any)).toThrow(
+      "Invalid arguments: delete expects a data path (string)",
+    );
+  });
+
+  test("does nothing if not in dataModel", () => {
+    const model = {
+      foo: {
+        bar: "Some Data",
+      },
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("foo.baz");
+
+    expect(controller.get("")).toStrictEqual({
+      foo: { bar: "Some Data" },
+    });
+  });
+
+  test("deletes property", () => {
+    const model = {
+      foo: {
+        bar: "Some Data",
+      },
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("foo.bar");
+
+    expect(controller.get("")).toStrictEqual({ foo: {} });
+  });
+
+  test("deletes array item", () => {
+    const model = {
+      foo: ["Some Data"],
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("foo.0");
+
+    expect(controller.get("")).toStrictEqual({ foo: [] });
+  });
+
+  test("doesn't delete data that is out of range", () => {
+    const model = {
+      foo: ["Some Data"],
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("foo.1");
+
+    expect(controller.get("")).toStrictEqual({ foo: ["Some Data"] });
+  });
+
+  test("deletes root property", () => {
+    const model = {
+      foo: {
+        bar: "Some Data",
+      },
+      baz: "Other data",
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("foo");
+
+    expect(controller.get("")).toStrictEqual({ baz: "Other data" });
+  });
+
+  test("deletes nothing for a blank binding", () => {
+    const model = {
+      foo: {
+        bar: "Some Data",
+      },
+    };
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+    controller.hooks.resolveDataStages.tap("Local", () => [localData]);
+
+    controller.delete("");
+
+    expect(controller.get("")).toStrictEqual({
+      foo: {
+        bar: "Some Data",
+      },
+    });
+  });
+});
+
+describe("formatting", () => {
+  it("formats data", () => {
+    const localData = new LocalModel({});
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+
+    controller.hooks.format.tap("test", (val) => {
+      if (val === "should-format") {
+        return "formatted!";
+      }
+
+      return val;
+    });
+
+    controller.hooks.deformat.tap("test", (val) => {
+      if (val === "should-deformat") {
+        return "deformatted!";
+      }
+
+      return val;
+    });
+
+    controller.set([["foo.bar", "should-format"]], { formatted: true });
+    expect(controller.get("foo.bar")).toBe("should-format");
+    expect(controller.get("foo.bar", { formatted: true })).toBe("formatted!");
+
+    controller.set([["foo.baz", "should-deformat"]]);
+    expect(controller.get("foo.baz")).toBe("should-deformat");
+
+    controller.set([["foo.baz", "should-deformat"]], { formatted: true });
+    expect(controller.get("foo.baz")).toBe("deformatted!");
+    expect(controller.get("foo.baz", { formatted: false })).toBe(
+      "deformatted!",
+    );
+  });
+});
+
+describe("serialization", () => {
+  it("can hook into serializing", () => {
+    const localData = new LocalModel();
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController(
+      { testData: 0 },
+      { pathResolver: parser },
+    );
+
+    controller.hooks.serialize.tap("test", (dataModel) => {
+      return {
+        ...dataModel,
+        keys: Object.keys(dataModel),
+      };
+    });
+
+    expect(controller.serialize()).toStrictEqual({
+      testData: 0,
+      keys: ["testData"],
+    });
+  });
+
+  it("doesnt include invalid data", () => {
+    const localData = new LocalModel();
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+
+    const dc = new DataController(
+      { valid: true, invalid: false },
+      {
+        pathResolver: parser,
+        middleware: [
+          new ValidationMiddleware((binding, model) => {
+            if (
+              binding.asString() === "invalid" &&
+              model.get(binding) !== false
+            ) {
+              return {
+                severity: "error",
+                message: "Nope",
+              };
+            }
+          }),
+        ],
+      },
+    );
+
+    expect(dc?.serialize()).toStrictEqual({
+      valid: true,
+      invalid: false,
+    });
+
+    dc.set([["invalid", true]]);
+
+    expect(dc?.serialize()).toStrictEqual({
+      valid: true,
+      invalid: false,
+    });
+
+    expect(dc.get("", { includeInvalid: true })).toStrictEqual({
+      valid: true,
+      invalid: true,
+    });
+  });
+});
+
+describe("default value", () => {
+  it("gets/sets with default", () => {
+    const model = {
+      foo: "foo",
+    };
+
+    const localData = new LocalModel(model);
+
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    const controller = new DataController({}, { pathResolver: parser });
+
+    controller.hooks.resolveDefaultValue.tap("test", (b) => {
+      if (b.asString() === "foo") {
+        return "FOO";
+      }
+
+      if (b.asString() === "bar") {
+        return "BAR";
+      }
+    });
+
+    controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+    expect(controller.get("bar")).toBe("BAR");
+
+    controller.set([["foo", undefined]]);
+    expect(controller.get("foo")).toBe("FOO");
+
+    // The data isn't actually set though
+    expect(controller.get("")).toStrictEqual({ foo: undefined });
+  });
+});
+
+it("should not send update for deeply equal data", () => {
+  const model = {
+    user: {
+      name: "frodo",
+      age: 3,
+    },
+  };
+
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({
+    get: localData.get,
+    set: localData.set,
+  });
+  const controller = new DataController({}, { pathResolver: parser });
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  const onUpdateCallback = vitest.fn();
+  controller.hooks.onUpdate.tap("test", onUpdateCallback);
+
+  controller.set([["user", { name: "frodo", age: 3 }]]);
+
+  expect(onUpdateCallback).not.toBeCalled();
+});
+
+it("should handle deleting non-existent value + parent value", () => {
+  const model = {
+    user: {
+      name: "frodo",
+      age: 3,
+    },
+  };
+
+  const localData = new LocalModel(model);
+
+  const parser = new BindingParser({
+    get: localData.get,
+    set: localData.set,
+  });
+  const controller = new DataController({}, { pathResolver: parser });
+  controller.hooks.resolveDataStages.tap("basic", () => [localData]);
+
+  controller.delete("user.email");
+
+  expect(controller.get("user")).toStrictEqual({
+    name: "frodo",
+    age: 3,
+  });
+
+  controller.delete("foo.bar");
+});
+
+describe("Read Only Data Controller", () => {
+  let readOnlyController: ReadOnlyDataController;
+  let logger: Logger;
+
+  beforeEach(() => {
+    const localData = new LocalModel();
+    const parser = new BindingParser({
+      get: localData.get,
+      set: localData.set,
+    });
+    logger = {
+      trace: vitest.fn(),
+      debug: vitest.fn(),
+      info: vitest.fn(),
+      warn: vitest.fn(),
+      error: vitest.fn(),
+    };
+
+    const controller = new DataController(
+      { some: { data: true } },
+      { pathResolver: parser, logger },
+    );
+
+    readOnlyController = controller.makeReadOnly();
+  });
+
+  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",
+    );
+  });
+});