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

package/src/view/plugins/__tests__/__snapshots__/template.test.ts.snap

@@ -0,0 +1,278 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`dynamic templates > Works with template items plus value items > Should show template item first when coming before values on lexical order 1`] = `
+{
+  "asset": {
+    "id": "overviewItem3",
+    "label": {
+      "asset": {
+        "id": "overviewItem3-label",
+        "type": "text",
+        "value": "1099-A",
+      },
+    },
+    "type": "overviewItem",
+    "values": [
+      {
+        "asset": {
+          "id": "overviewItem3-year",
+          "type": "text",
+          "value": "Desciption of concept 1099 1",
+        },
+      },
+      {
+        "asset": {
+          "id": "loverviewItem3-cy",
+          "type": "text",
+          "value": "4000",
+        },
+      },
+    ],
+  },
+}
+`;
+
+exports[`dynamic templates > Works with template items plus value items > Should show template item last when coming after values on lexical order 1`] = `
+{
+  "asset": {
+    "id": "overviewItem1",
+    "label": {
+      "asset": {
+        "id": "overviewItem1-label",
+        "type": "text",
+        "value": "First Summary",
+      },
+    },
+    "type": "overviewItem",
+    "values": [
+      {
+        "asset": {
+          "id": "overviewItem1-year",
+          "type": "text",
+          "value": "Desciption of year summary 1",
+        },
+      },
+      {
+        "asset": {
+          "id": "loverviewItem1-cy",
+          "type": "text",
+          "value": "14000",
+        },
+      },
+    ],
+  },
+}
+`;
+
+exports[`templates > works with nested templates 1`] = `
+{
+  "children": [
+    {
+      "path": [
+        "values",
+      ],
+      "value": {
+        "override": false,
+        "parent": [Circular],
+        "type": "multi-node",
+        "values": [
+          {
+            "children": [
+              {
+                "path": [
+                  "asset",
+                ],
+                "value": {
+                  "children": [
+                    {
+                      "path": [
+                        "values",
+                      ],
+                      "value": {
+                        "override": false,
+                        "parent": [Circular],
+                        "type": "multi-node",
+                        "values": [
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.0}} + {{foo.people.0}}",
+                            },
+                          },
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.0}} + {{foo.people.1}}",
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  ],
+                  "parent": [Circular],
+                  "type": "asset",
+                  "value": {
+                    "id": "outer-collection-0",
+                    "type": "collection",
+                  },
+                },
+              },
+            ],
+            "parent": [Circular],
+            "type": "value",
+            "value": undefined,
+          },
+          {
+            "children": [
+              {
+                "path": [
+                  "asset",
+                ],
+                "value": {
+                  "children": [
+                    {
+                      "path": [
+                        "values",
+                      ],
+                      "value": {
+                        "override": false,
+                        "parent": [Circular],
+                        "type": "multi-node",
+                        "values": [
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.1}} + {{foo.people.0}}",
+                            },
+                          },
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.1}} + {{foo.people.1}}",
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  ],
+                  "parent": [Circular],
+                  "type": "asset",
+                  "value": {
+                    "id": "outer-collection-1",
+                    "type": "collection",
+                  },
+                },
+              },
+            ],
+            "parent": [Circular],
+            "type": "value",
+            "value": undefined,
+          },
+          {
+            "children": [
+              {
+                "path": [
+                  "asset",
+                ],
+                "value": {
+                  "children": [
+                    {
+                      "path": [
+                        "values",
+                      ],
+                      "value": {
+                        "override": false,
+                        "parent": [Circular],
+                        "type": "multi-node",
+                        "values": [
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.2}} + {{foo.people.0}}",
+                            },
+                          },
+                          {
+                            "parent": [Circular],
+                            "type": "value",
+                            "value": {
+                              "text": "{{foo.pets.2}} + {{foo.people.1}}",
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  ],
+                  "parent": [Circular],
+                  "type": "asset",
+                  "value": {
+                    "id": "outer-collection-2",
+                    "type": "collection",
+                  },
+                },
+              },
+            ],
+            "parent": [Circular],
+            "type": "value",
+            "value": undefined,
+          },
+        ],
+      },
+    },
+  ],
+  "type": "value",
+  "value": {
+    "id": "foo",
+    "type": "collection",
+  },
+}
+`;
+
+exports[`templates > works with simple ones 1`] = `
+{
+  "children": [
+    {
+      "path": [
+        "values",
+      ],
+      "value": {
+        "override": false,
+        "parent": [Circular],
+        "type": "multi-node",
+        "values": [
+          {
+            "parent": [Circular],
+            "type": "value",
+            "value": {
+              "value": "{{foo.bar.0}}",
+            },
+          },
+          {
+            "parent": [Circular],
+            "type": "value",
+            "value": {
+              "value": "{{foo.bar.1}}",
+            },
+          },
+          {
+            "parent": [Circular],
+            "type": "value",
+            "value": {
+              "value": "{{foo.bar.2}}",
+            },
+          },
+        ],
+      },
+    },
+  ],
+  "type": "value",
+  "value": {
+    "id": "foo",
+    "type": "collection",
+  },
+}
+`;

package/src/view/plugins/__tests__/applicability.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { BindingParser } from "../../../binding";
+import type { DataModelWithParser } from "../../../data";
+import { LocalModel, withParser } from "../../../data";
+import { ExpressionEvaluator } from "../../../expressions";
+import { SchemaController } from "../../../schema";
+import type { Resolve } from "../../resolver";
+import { Resolver } from "../../resolver";
+import type { Node } from "../../parser";
+import { Parser } from "../../parser";
+import { ApplicabilityPlugin, StringResolverPlugin } from "..";
+
+const parseBinding = new BindingParser().parse;
+
+describe("applicability", () => {
+  let model: DataModelWithParser;
+  let expressionEvaluator: ExpressionEvaluator;
+  let resolverOptions: Resolve.ResolverOptions;
+  let parser: Parser;
+
+  beforeEach(() => {
+    model = withParser(new LocalModel(), parseBinding);
+    expressionEvaluator = new ExpressionEvaluator({
+      model,
+    });
+    parser = new Parser();
+
+    resolverOptions = {
+      evaluator: expressionEvaluator,
+      parseBinding,
+      model,
+      parseNode: parser.parseObject.bind(parser),
+      schema: new SchemaController(),
+    };
+  });
+
+  it("undefined does not remove asset", () => {
+    const aP = new ApplicabilityPlugin();
+    const sP = new StringResolverPlugin();
+
+    aP.applyParser(parser);
+
+    const root = parser.parseObject({
+      asset: {
+        values: [
+          {
+            applicability: "{{foo}}",
+            value: "foo",
+          },
+          {
+            value: "bar",
+          },
+        ],
+      },
+    });
+
+    const resolver = new Resolver(root as Node.Node, resolverOptions);
+
+    aP.applyResolver(resolver);
+    sP.applyResolver(resolver);
+
+    expect(resolver.update()).toStrictEqual({
+      asset: { values: [{ value: "foo" }, { value: "bar" }] },
+    });
+    model.set([["foo", false]]);
+    expect(resolver.update()).toStrictEqual({
+      asset: { values: [{ value: "bar" }] },
+    });
+  });
+
+  it("removes empty objects", () => {
+    new ApplicabilityPlugin().applyParser(parser);
+    const root = parser.parseObject({
+      asset: {
+        values: [
+          {
+            applicability: "{{foo}}",
+            value: "foo",
+          },
+          {
+            value: "bar",
+          },
+        ],
+      },
+    });
+    model.set([["foo", true]]);
+    const resolver = new Resolver(root as Node.Node, resolverOptions);
+
+    new ApplicabilityPlugin().applyResolver(resolver);
+    new StringResolverPlugin().applyResolver(resolver);
+
+    expect(resolver.update()).toStrictEqual({
+      asset: { values: [{ value: "foo" }, { value: "bar" }] },
+    });
+
+    model.set([["foo", false]]);
+    expect(resolver.update()).toStrictEqual({
+      asset: { values: [{ value: "bar" }] },
+    });
+  });
+
+  it("removes asset wrappers", () => {
+    new ApplicabilityPlugin().applyParser(parser);
+    const root = parser.parseObject({
+      asset: {
+        title: {
+          applicability: "{{foo}}",
+          asset: {
+            value: "foo",
+          },
+        },
+        value: "Hello World",
+      },
+    });
+    model.set([["foo", true]]);
+    const resolver = new Resolver(root as Node.Node, resolverOptions);
+
+    new ApplicabilityPlugin().applyResolver(resolver);
+    new StringResolverPlugin().applyResolver(resolver);
+
+    expect(resolver.update()).toStrictEqual({
+      asset: { title: { asset: { value: "foo" } }, value: "Hello World" },
+    });
+    model.set([["foo", false]]);
+    expect(resolver.update()).toStrictEqual({
+      asset: { value: "Hello World" },
+    });
+  });
+
+  it("handles empty models", () => {
+    new ApplicabilityPlugin().applyParser(parser);
+    const root = parser.parseObject({
+      asset: {
+        values: [
+          {
+            asset: {
+              id: "some-asset-1",
+              type: "text",
+            },
+          },
+          {
+            asset: {
+              id: "some-asset-2",
+              type: "text",
+              applicability: "{{foo}} == true",
+              value: "foo",
+              label: {
+                asset: {
+                  applicability: "{{bar}} == true",
+                  value: "bar",
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+    const fooBinding = parseBinding("foo");
+    const barBinding = parseBinding("bar");
+
+    model.set([
+      [fooBinding, true],
+      [barBinding, true],
+    ]);
+    const resolver = new Resolver(root as Node.Node, resolverOptions);
+
+    new ApplicabilityPlugin().applyResolver(resolver);
+    new StringResolverPlugin().applyResolver(resolver);
+
+    expect(resolver.update()).toStrictEqual({
+      asset: {
+        values: [
+          {
+            asset: {
+              id: "some-asset-1",
+              type: "text",
+            },
+          },
+          {
+            asset: {
+              id: "some-asset-2",
+              type: "text",
+              value: "foo",
+              label: { asset: { value: "bar" } },
+            },
+          },
+        ],
+      },
+    });
+    model.set([[fooBinding, false]]);
+    expect(resolver.update(new Set([fooBinding]))).toStrictEqual({
+      asset: {
+        values: [
+          {
+            asset: {
+              id: "some-asset-1",
+              type: "text",
+            },
+          },
+        ],
+      },
+    });
+
+    model.set([[fooBinding, true]]);
+    expect(resolver.update(new Set([fooBinding]))).toStrictEqual({
+      asset: {
+        values: [
+          {
+            asset: {
+              id: "some-asset-1",
+              type: "text",
+            },
+          },
+          {
+            asset: {
+              id: "some-asset-2",
+              type: "text",
+              value: "foo",
+              label: { asset: { value: "bar" } },
+            },
+          },
+        ],
+      },
+    });
+
+    model.set([[barBinding, false]]);
+    expect(resolver.update(new Set([barBinding]))).toStrictEqual({
+      asset: {
+        values: [
+          {
+            asset: {
+              id: "some-asset-1",
+              type: "text",
+            },
+          },
+          {
+            asset: {
+              id: "some-asset-2",
+              type: "text",
+              value: "foo",
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  it("determines if nodeType is applicability", () => {
+    new ApplicabilityPlugin().applyParser(parser);
+    const nodeTest = {
+      applicability: "{{bar}} == true",
+    };
+    const nodeType = parser.hooks.determineNodeType.call(nodeTest);
+    expect(nodeType).toStrictEqual("applicability");
+  });
+
+  it("Does not return a nodeType", () => {
+    new ApplicabilityPlugin().applyParser(parser);
+    const nodeTest = {
+      value: "foo",
+    };
+    const nodeType = parser.hooks.determineNodeType.call(nodeTest);
+    expect(nodeType).toBe(undefined);
+  });
+});

package/src/view/plugins/__tests__/string.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, beforeEach, test } from "vitest";
+import { BindingParser } from "../../../binding";
+import type { DataModelImpl } from "../../../data";
+import { LocalModel, withParser } from "../../../data";
+import { ExpressionEvaluator } from "../../../expressions";
+import { SchemaController } from "../../../schema";
+import type { Resolve } from "../../resolver";
+import { Resolver } from "../../resolver";
+import { NodeType, Parser } from "../../parser";
+import { StringResolverPlugin } from "..";
+
+describe("string-resolver", () => {
+  let model: DataModelImpl;
+  let expressionEvaluator: ExpressionEvaluator;
+  let resolverOptions: Resolve.ResolverOptions;
+  let parser: Parser;
+
+  beforeEach(() => {
+    const localModel = new LocalModel({
+      name: "Adam",
+      age: 27,
+      city: "San Diego",
+      nested: "Name: {{name}} age: {{age}}",
+    });
+
+    const bindingParser = new BindingParser({
+      set: localModel.set,
+      get: localModel.get,
+    });
+    model = withParser(localModel, bindingParser.parse);
+
+    expressionEvaluator = new ExpressionEvaluator({
+      model,
+    });
+    parser = new Parser();
+
+    resolverOptions = {
+      evaluator: expressionEvaluator,
+      model,
+      parseBinding: bindingParser.parse,
+      parseNode: parser.parseObject.bind(parser),
+      schema: new SchemaController(),
+    };
+  });
+
+  test("resolves basic objects", () => {
+    const root = parser.parseObject({
+      asset: {
+        type: "bar",
+        name: "My name is {{name}}",
+        age: "{{age}}",
+        alt: "{{nested}}",
+      },
+    });
+    const resolver = new Resolver(root!, resolverOptions);
+    new StringResolverPlugin().applyResolver(resolver);
+    expect(resolver.update()).toStrictEqual({
+      asset: {
+        type: "bar",
+        name: "My name is Adam",
+        age: 27,
+        alt: "Name: Adam age: 27",
+      },
+    });
+  });
+
+  test("skips exp prop when configured", () => {
+    const root = parser.parseObject({
+      asset: {
+        type: "bar",
+        name: "My name is {{name}}",
+        age: "{{age}}",
+        alt: "{{nested}}",
+        exp: {
+          onStart: '{{name}} = "test"',
+        },
+        label: {
+          asset: {
+            id: "foo",
+            type: "bar",
+            exp: '{{name}} = "other"',
+          },
+        },
+      },
+    });
+
+    const resolver = new Resolver(root!, resolverOptions);
+
+    resolver.hooks.beforeResolve.tap("test", (n) => {
+      if (n?.type === NodeType.Asset || n?.type === NodeType.View) {
+        return {
+          ...n,
+          plugins: {
+            stringResolver: {
+              propertiesToSkip: ["exp"],
+            },
+          },
+        };
+      }
+    });
+
+    new StringResolverPlugin().applyResolver(resolver);
+    expect(resolver.update()).toStrictEqual({
+      asset: {
+        type: "bar",
+        name: "My name is Adam",
+        age: 27,
+        alt: "Name: Adam age: 27",
+        exp: {
+          onStart: '{{name}} = "test"',
+        },
+        label: {
+          asset: {
+            id: "foo",
+            type: "bar",
+            exp: '{{name}} = "other"',
+          },
+        },
+      },
+    });
+  });
+});