@player-ui/player 0.13.0 → 0.14.0-next.0

package/package.json

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

package/src/binding/__tests__/resolver.test.ts

@@ -11,14 +11,17 @@ export const testModel = {
       {
         name: "ginger",
         type: "dog",
+        isDog: true,
       },
       {
         name: "daisy",
         type: "dog",
+        isDog: true,
       },
       {
         name: "frodo",
         type: "cat",
+        isDog: false,
       },
       "other",
     ],
@@ -33,6 +36,8 @@ export const testCases: Array<[string, string]> = [
   ["foo.pets[01].name", "foo.pets.1.name"],
   ['foo.pets[name = "frodo"].type', "foo.pets.2.type"],
   ['foo.pets["name" = "sprinkles"].type', "foo.pets.4.type"],
+  ['foo.pets["isDog" = false].type', "foo.pets.2.type"],
+  ['foo.pets["isDog" = true].type', "foo.pets.0.type"],
 ];
 
 test.each(testCases)("Resolving binding: %s", (binding, expectedResolved) => {

package/src/binding/resolver.ts

@@ -107,7 +107,11 @@ export function resolveBindingAST(
         break;
 
       case "Value":
-        appendPathSegments(resolvedNode.value);
+        appendPathSegments(
+          typeof resolvedNode.value === "boolean"
+            ? String(resolvedNode.value)
+            : resolvedNode.value,
+        );
         break;
 
       case "Query": {

package/src/binding-grammar/__tests__/parser.test.ts

@@ -6,40 +6,8 @@ import {
   VALID_AST_PARSER_CUSTOM_TESTS,
 } from "./test-utils/ast-cases";
 import type { ParserSuccessResult, ParserFailureResult } from "../ast";
-import { parse as parseParsimmon } from "./parsimmon";
-import { parse as parseEBNF } from "./ebnf";
 import { parse as parseCustom } from "../custom";
 
-describe("parsimmon", () => {
-  test.each(VALID_AST_PARSER_TESTS)("Parsimmon Valid: %s", (binding, AST) => {
-    const result = parseParsimmon(binding);
-
-    expect(result.status).toBe(true);
-    expect((result as ParserSuccessResult).path).toStrictEqual(AST);
-  });
-
-  test.each(INVALID_AST_PARSER_TESTS)("Parsimmon Invalid: %s", (binding) => {
-    const result = parseParsimmon(binding);
-    expect(result.status).toBe(false);
-    expect((result as ParserFailureResult).error.length > 0).toBe(true);
-  });
-});
-
-describe("ebnf", () => {
-  test.each(VALID_AST_PARSER_TESTS)("EBNF Valid: %s", (binding, AST) => {
-    const result = parseEBNF(binding);
-
-    expect(result.status).toBe(true);
-    expect((result as ParserSuccessResult).path).toStrictEqual(AST);
-  });
-
-  test.each(INVALID_AST_PARSER_TESTS)("EBNF Invalid: %s", (binding) => {
-    const result = parseEBNF(binding);
-    expect(result.status).toBe(false);
-    expect((result as ParserFailureResult).error.length > 0).toBe(true);
-  });
-});
-
 describe("custom", () => {
   test.each(VALID_AST_PARSER_TESTS)("Custom Valid: %s", (binding, AST) => {
     const result = parseCustom(binding);

package/src/binding-grammar/__tests__/test-utils/ast-cases.ts

@@ -54,6 +54,31 @@ export const VALID_AST_PARSER_TESTS: Array<[string, PathNode]> = [
       toQuery(toValue("Month"), toValue("New[.]]Mo,nth.")),
     ]),
   ],
+  // Boolean values only treated as bools for query compare values
+  [
+    `foo.true['true'=true]`,
+    toPath([
+      toValue("foo"),
+      toValue("true"),
+      toQuery(toValue("true"), toValue(true)),
+    ]),
+  ],
+  [
+    `foo.false['false'=false]`,
+    toPath([
+      toValue("foo"),
+      toValue("false"),
+      toQuery(toValue("false"), toValue(false)),
+    ]),
+  ],
+  [
+    `foo.bar[baz == true]`,
+    toPath([
+      toValue("foo"),
+      toValue("bar"),
+      toQuery(toValue("baz"), toValue(true)),
+    ]),
+  ],
 
   // Nested Paths
   ["{{foo}}", toPath([toPath([toValue("foo")])])],
@@ -176,6 +201,12 @@ export const VALID_AST_PARSER_TESTS: Array<[string, PathNode]> = [
       toValue("baz"),
     ]),
   ],
+
+  // With numbers
+  [
+    "foo.0[1=2]",
+    toPath([toValue("foo"), toValue(0), toQuery(toValue(1), toValue(2))]),
+  ],
 ];
 
 export const INVALID_AST_PARSER_TESTS: Array<string> = [

package/src/binding-grammar/ast.ts

@@ -27,7 +27,7 @@ export interface QueryNode extends Node<"Query"> {
 /** A simple segment */
 export interface ValueNode extends Node<"Value"> {
   /** The segment value */
-  value: string | number;
+  value: string | number | boolean;
 }
 
 /** A nested expression */
@@ -37,7 +37,7 @@ export interface ExpressionNode extends Node<"Expression"> {
 }
 
 /** Helper to create a value node */
-export const toValue = (value: string | number): ValueNode => ({
+export const toValue = (value: string | number | boolean): ValueNode => ({
   name: "Value",
   value,
 });

package/src/binding-grammar/custom/index.ts

@@ -76,7 +76,7 @@ export const parse: Parser = (path) => {
   };
 
   /** get an identifier if you can */
-  const identifier = (): ValueNode | undefined => {
+  const identifier = (allowBoolValue = false): ValueNode | undefined => {
     if (!isIdentifierChar(ch)) {
       return;
     }
@@ -91,6 +91,15 @@ export const parse: Parser = (path) => {
       value += ch;
     }
 
+    if (allowBoolValue) {
+      if (value === "true") {
+        return toValue(true);
+      }
+      if (value === "false") {
+        return toValue(false);
+      }
+    }
+
     if (value) {
       const maybeNumber = Number(value);
       value = isNaN(maybeNumber) ? value : maybeNumber;
@@ -156,7 +165,8 @@ export const parse: Parser = (path) => {
   };
 
   /** get a simple segment node */
-  const simpleSegment = () => nestedPath() ?? expression() ?? identifier();
+  const simpleSegment = (allowBoolValue = false) =>
+    nestedPath() ?? expression() ?? identifier(allowBoolValue);
 
   /** Parse a segment */
   const segment = ():
@@ -182,11 +192,9 @@ export const parse: Parser = (path) => {
   };
 
   /** get an optionally quoted block */
-  const optionallyQuotedSegment = ():
-    | ValueNode
-    | PathNode
-    | ExpressionNode
-    | undefined => {
+  const optionallyQuotedSegment = (
+    allowBoolValue = false,
+  ): ValueNode | PathNode | ExpressionNode | undefined => {
     whitespace();
 
     // see if we have a quote
@@ -199,7 +207,7 @@ export const parse: Parser = (path) => {
       return id;
     }
 
-    return simpleSegment();
+    return simpleSegment(allowBoolValue);
   };
 
   /** eat equals signs */
@@ -231,7 +239,7 @@ export const parse: Parser = (path) => {
         whitespace();
         if (equals()) {
           whitespace();
-          const second = optionallyQuotedSegment();
+          const second = optionallyQuotedSegment(true);
           value = toQuery(value, second);
           whitespace();
         }

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, test } from "vitest";
+import { describe, it, expect, test, vi } from "vitest";
 import { LocalModel, withParser } from "../../data";
 import { ExpressionEvaluator } from "../../expressions";
 import { BindingParser } from "../../binding";
@@ -1014,4 +1014,64 @@ describe("view", () => {
 
     expect(view).toBeDefined();
   });
+
+  test("should call onUpdate with undefined when triggering an async update with no resolver", () => {
+    const model = withParser(new LocalModel({}), parseBinding);
+    const evaluator = new ExpressionEvaluator({ model });
+    const schema = new SchemaController();
+
+    const view = new ViewInstance(
+      {
+        id: "view",
+        type: "asset",
+      },
+      {
+        model,
+        parseBinding,
+        evaluator,
+        schema,
+      },
+    );
+    new StringResolverPlugin().apply(view);
+
+    const onUpdateTap = vi.fn();
+    view.hooks.onUpdate.tap("test", onUpdateTap);
+
+    view.updateAsync("test");
+
+    expect(onUpdateTap).toHaveBeenCalledWith(undefined);
+  });
+
+  test("should call onUpdate with the view when triggering an async update with a resolver", () => {
+    const model = withParser(new LocalModel({}), parseBinding);
+    const evaluator = new ExpressionEvaluator({ model });
+    const schema = new SchemaController();
+
+    const view = new ViewInstance(
+      {
+        id: "view",
+        type: "asset",
+      },
+      {
+        model,
+        parseBinding,
+        evaluator,
+        schema,
+      },
+    );
+
+    new StringResolverPlugin().apply(view);
+
+    const onUpdateTap = vi.fn();
+
+    // Trigger first update to get resolver ready.
+    view.update();
+
+    view.hooks.onUpdate.tap("test", onUpdateTap);
+    view.updateAsync("test");
+    expect(onUpdateTap).toHaveBeenCalledWith({
+      id: "view",
+      type: "asset",
+    });
+  });
 });

package/src/view/builder/index.ts

@@ -62,11 +62,16 @@ export class Builder {
    *
    * @param id - the id of async node. It should be identical for each async node
    */
-  static asyncNode(id: string, flatten = true): Node.Async {
+  static asyncNode(
+    id: string,
+    flatten = true,
+    onValueReceived?: (node: Node.Node) => Node.Node,
+  ): Node.Async {
     return {
       id,
       type: NodeType.Async,
       flatten: flatten,
+      onValueReceived,
       value: {
         type: NodeType.Value,
         value: {

package/src/view/parser/index.ts

@@ -21,6 +21,47 @@ export interface ParseObjectChildOptions {
   parentObj: object;
 }
 
+export type ParserHooks = {
+  /**
+   * A hook to interact with an object _before_ parsing it into an AST
+   *
+   * @param value - The object we're are about to parse
+   * @returns - A new value to parse.
+   *  If undefined, the original value is used.
+   *  If null, we stop parsing this node.
+   */
+  onParseObject: SyncWaterfallHook<[object, NodeType]>;
+  /**
+   * A callback to interact with an AST _after_ we parse it into the AST
+   *
+   * @param value - The object we parsed
+   * @param node - The AST node we generated
+   * @returns - A new AST node to use
+   *   If undefined, the original value is used.
+   *   If null, we ignore this node all together
+   */
+  onCreateASTNode: SyncWaterfallHook<[Node.Node | undefined | null, object]>;
+  /** A hook to call when parsing an object into an AST node
+   *
+   * @param obj - The object we're are about to parse
+   * @param nodeType - The type of node we're parsing
+   * @param parseOptions - Additional options when parsing
+   * @param childOptions - Additional options that are populated when the node being parsed is a child of another node
+   * @returns - A new AST node to use
+   *   If undefined, the original value is used.
+   *   If null, we ignore this node all together
+   */
+  parseNode: SyncBailHook<
+    [
+      obj: object,
+      nodeType: Node.ChildrenTypes,
+      parseOptions: ParseObjectOptions,
+      childOptions?: ParseObjectChildOptions,
+    ],
+    Node.Node | Node.Child[]
+  >;
+};
+
 interface NestedObj {
   /** The values of a nested local object */
   children: Node.Child[];
@@ -32,39 +73,10 @@ interface NestedObj {
  * It provides a few ways to interact with the parsing, including mutating an object before and after creation of an AST node
  */
 export class Parser {
-  public readonly hooks = {
-    /**
-     * A hook to interact with an object _before_ parsing it into an AST
-     *
-     * @param value - The object we're are about to parse
-     * @returns - A new value to parse.
-     *  If undefined, the original value is used.
-     *  If null, we stop parsing this node.
-     */
-    onParseObject: new SyncWaterfallHook<[object, NodeType]>(),
-
-    /**
-     * A callback to interact with an AST _after_ we parse it into the AST
-     *
-     * @param value - The object we parsed
-     * @param node - The AST node we generated
-     * @returns - A new AST node to use
-     *   If undefined, the original value is used.
-     *   If null, we ignore this node all together
-     */
-    onCreateASTNode: new SyncWaterfallHook<
-      [Node.Node | undefined | null, object]
-    >(),
-
-    parseNode: new SyncBailHook<
-      [
-        obj: object,
-        nodeType: Node.ChildrenTypes,
-        parseOptions: ParseObjectOptions,
-        childOptions?: ParseObjectChildOptions,
-      ],
-      Node.Node | Node.Child[]
-    >(),
+  public readonly hooks: ParserHooks = {
+    onParseObject: new SyncWaterfallHook(),
+    onCreateASTNode: new SyncWaterfallHook(),
+    parseNode: new SyncBailHook(),
   };
 
   public parseView(value: AnyAssetType): Node.View {

package/src/view/parser/types.ts

@@ -22,6 +22,9 @@ export declare namespace Node {
 
     /** Every node (outside of the root) contains a reference to it's parent */
     parent?: Node;
+
+    /** The ids of async nodes resolved within this node */
+    asyncNodesResolved?: string[];
   }
 
   export type PathSegment = string | number;
@@ -123,6 +126,8 @@ export declare namespace Node {
      * Should the content streamed in be flattened during resolving
      */
     flatten?: boolean;
+    /** Function to run against parsed content from the node to manipulate the content before resolving it. */
+    onValueReceived?: (node: Node.Node) => Node.Node;
   }
 
   export interface PluginOptions {

package/src/view/plugins/__tests__/multi-node.test.ts

@@ -35,4 +35,40 @@ describe("multi-node", () => {
       }),
     ).toMatchSnapshot();
   });
+
+  it("should parse an array into a multi node", () => {
+    expect(
+      parser.parseObject([
+        {
+          asset: {
+            type: "type",
+            id: "asset-1",
+          },
+        },
+      ]),
+    ).toStrictEqual({
+      override: false,
+      type: "multi-node",
+      values: [
+        {
+          type: "value",
+          value: undefined,
+          parent: expect.anything(),
+          children: [
+            {
+              path: ["asset"],
+              value: {
+                type: "asset",
+                parent: expect.anything(),
+                value: {
+                  id: "asset-1",
+                  type: "type",
+                },
+              },
+            },
+          ],
+        },
+      ],
+    });
+  });
 });

package/src/view/plugins/multi-node.ts

@@ -10,7 +10,7 @@ import { hasTemplateValues, hasTemplateKey } from "../parser/utils";
 
 /** A view plugin to resolve multi nodes */
 export default class MultiNodePlugin implements ViewPlugin {
-  applyParser(parser: Parser) {
+  applyParser(parser: Parser): void {
     parser.hooks.parseNode.tap(
       "multi-node",
       (
@@ -20,8 +20,7 @@ export default class MultiNodePlugin implements ViewPlugin {
         childOptions?: ParseObjectChildOptions,
       ) => {
         if (
-          childOptions &&
-          !hasTemplateKey(childOptions.key) &&
+          (childOptions === undefined || !hasTemplateKey(childOptions.key)) &&
           Array.isArray(obj)
         ) {
           const values = obj
@@ -37,10 +36,9 @@ export default class MultiNodePlugin implements ViewPlugin {
           const multiNode = parser.createASTNode(
             {
               type: NodeType.MultiNode,
-              override: !hasTemplateValues(
-                childOptions.parentObj,
-                childOptions.key,
-              ),
+              override:
+                childOptions !== undefined &&
+                !hasTemplateValues(childOptions.parentObj, childOptions.key),
               values,
             },
             obj,
@@ -56,18 +54,20 @@ export default class MultiNodePlugin implements ViewPlugin {
             });
           }
 
-          return [
-            {
-              path: [...childOptions.path, childOptions.key],
-              value: multiNode,
-            },
-          ];
+          return childOptions === undefined
+            ? multiNode
+            : [
+                {
+                  path: [...childOptions.path, childOptions.key],
+                  value: multiNode,
+                },
+              ];
         }
       },
     );
   }
 
-  apply(view: ViewInstance) {
+  apply(view: ViewInstance): void {
     view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
   }
 }

package/src/view/resolver/__tests__/index.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, beforeEach, vi, expect } from "vitest";
+import { BindingParser } from "../../../binding";
+import { ExpressionEvaluator } from "../../../expressions";
+import { LocalModel, withParser } from "../../../data";
+import { SchemaController } from "../../../schema";
+import { Resolve, Resolver } from "..";
+import type { Node } from "../../parser";
+import { NodeType, Parser } from "../../parser";
+
+const simpleViewWithAsync: Node.View = {
+  type: NodeType.View,
+  children: [
+    {
+      path: ["value"],
+      value: {
+        type: NodeType.Async,
+        id: "async-node",
+        value: {
+          type: NodeType.Value,
+          value: {
+            id: "async-node",
+          },
+        },
+      },
+    },
+    {
+      path: ["value"],
+      value: {
+        type: NodeType.Value,
+        value: {
+          id: "value-node",
+        },
+      },
+    },
+  ],
+  value: {
+    type: "view",
+    id: "view",
+  },
+};
+
+describe("Async Node Resolution", () => {
+  let resolverOptions: Resolve.ResolverOptions;
+
+  beforeEach(() => {
+    const model = new LocalModel({});
+    const parser = new Parser();
+    const bindingParser = new BindingParser();
+
+    resolverOptions = {
+      model,
+      parseBinding: bindingParser.parse.bind(bindingParser),
+      parseNode: parser.parseObject.bind(parser),
+      evaluator: new ExpressionEvaluator({
+        model: withParser(model, bindingParser.parse),
+      }),
+      schema: new SchemaController(),
+    };
+  });
+
+  it("should", () => {
+    const beforeResolveFunction = vi.fn((node: Node.Node | null) => node);
+
+    const resolver = new Resolver(simpleViewWithAsync, resolverOptions);
+    resolver.hooks.beforeResolve.tap("test", beforeResolveFunction);
+
+    // Update once to setup cache
+    resolver.update();
+    // Should call beforeResolve once for each node.
+    expect(beforeResolveFunction).toHaveBeenCalledTimes(3);
+
+    // Clear call information before next update.
+    beforeResolveFunction.mockClear();
+
+    // Confirm cache by running another update with no changes.
+    resolver.update(new Set());
+    // Should not need to call before resolve on cached nodes.
+    expect(beforeResolveFunction).toHaveBeenCalledTimes(0);
+
+    // Updating with changes marked on "async-node". Should invalidate cache for itself and its parent.
+    resolver.update(new Set(), new Set(["async-node"]));
+    // Should be called for the async node and the view parent.
+    expect(beforeResolveFunction).toHaveBeenCalledTimes(2);
+    expect(beforeResolveFunction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: NodeType.View,
+        value: {
+          type: "view",
+          id: "view",
+        },
+      }),
+      expect.anything(),
+    );
+    expect(beforeResolveFunction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: NodeType.Async,
+        id: "async-node",
+        value: {
+          type: NodeType.Value,
+          value: {
+            id: "async-node",
+          },
+        },
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("should also", () => {
+    const beforeResolveFunction = vi.fn((node: Node.Node | null) => {
+      // Add asyncNodesResolved to view to test tracking and invalidation of just the view.
+      if (node?.type === NodeType.View) {
+        return {
+          ...node,
+          asyncNodesResolved: ["other-async-id"],
+        };
+      }
+
+      return node;
+    });
+
+    const resolver = new Resolver(simpleViewWithAsync, resolverOptions);
+    resolver.hooks.beforeResolve.tap("test", beforeResolveFunction);
+
+    // Update once to setup cache
+    resolver.update();
+    // Should call beforeResolve once for each node.
+    expect(beforeResolveFunction).toHaveBeenCalledTimes(3);
+
+    // Clear call information before next update.
+    beforeResolveFunction.mockClear();
+
+    // Confirm cache by running another update with no changes.
+    resolver.update(new Set());
+    // Should not need to call before resolve on cached nodes.
+    expect(beforeResolveFunction).toHaveBeenCalledTimes(0);
+
+    // Updating with changes marked on "async-node". Should invalidate cache for itself and its parent.
+    resolver.update(new Set(), new Set(["other-async-id"]));
+    // Should be called just for the view.
+    expect(beforeResolveFunction).toHaveBeenCalledOnce();
+    expect(beforeResolveFunction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: NodeType.View,
+        value: {
+          type: "view",
+          id: "view",
+        },
+      }),
+      expect.anything(),
+    );
+  });
+});