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

package/src/binding/resolver.ts

@@ -1,7 +1,7 @@
-import { NestedError } from 'ts-nested-error';
-import type { SyncWaterfallHook } from 'tapable-ts';
-import type { PathNode, AnyNode } from '../binding-grammar';
-import { findInArray, maybeConvertToNum } from './utils';
+import { NestedError } from "ts-nested-error";
+import type { SyncWaterfallHook } from "tapable-ts";
+import type { PathNode, AnyNode } from "../binding-grammar";
+import { findInArray, maybeConvertToNum } from "./utils";
 
 export interface NormalizedResult {
   /** The normalized path */
@@ -33,7 +33,7 @@ export interface ResolveBindingASTHooks {
 export function resolveBindingAST(
   bindingPathNode: PathNode,
   options: ResolveBindingASTOptions,
-  hooks?: ResolveBindingASTHooks
+  hooks?: ResolveBindingASTHooks,
 ): NormalizedResult {
   const context: Required<NormalizedResult> = {
     updates: {},
@@ -45,11 +45,11 @@ export function resolveBindingAST(
 
   /** Get the value for any child node */
   function getValueForNode(node: AnyNode): any {
-    if (node.name === 'Value') {
+    if (node.name === "Value") {
       return node.value;
     }
 
-    if (node.name === 'PathNode') {
+    if (node.name === "PathNode") {
       const nestedResolvedValue = resolveBindingAST(node, options);
 
       if (nestedResolvedValue.updates) {
@@ -61,17 +61,17 @@ export function resolveBindingAST(
 
       try {
         return options.convertToPath(
-          options.getValue(nestedResolvedValue.path)
+          options.getValue(nestedResolvedValue.path),
         );
       } catch (e: any) {
         throw new NestedError(
           `Unable to resolve path segment: ${nestedResolvedValue.path}`,
-          e
+          e,
         );
       }
     }
 
-    if (node.name === 'Expression') {
+    if (node.name === "Expression") {
       try {
         const actualValue = options.evaluate(node.value);
 
@@ -86,8 +86,8 @@ export function resolveBindingAST(
 
   /** Handle when path segments are binding paths (foo.bar) or single segments (foo) */
   function appendPathSegments(segment: string | number) {
-    if (typeof segment === 'string' && segment.indexOf('.') > -1) {
-      segment.split('.').forEach((i) => {
+    if (typeof segment === "string" && segment.indexOf(".") > -1) {
+      segment.split(".").forEach((i) => {
         context.path.push(maybeConvertToNum(i));
       });
     } else {
@@ -101,16 +101,16 @@ export function resolveBindingAST(
       hooks?.beforeResolveNode.call(_node, { ...context, ...options }) ?? _node;
 
     switch (resolvedNode.name) {
-      case 'Expression':
-      case 'PathNode':
+      case "Expression":
+      case "PathNode":
         appendPathSegments(getValueForNode(resolvedNode));
         break;
 
-      case 'Value':
+      case "Value":
         appendPathSegments(resolvedNode.value);
         break;
 
-      case 'Query': {
+      case "Query": {
         // Look for an object at the path with the given key/val criteria
         const objToQuery: Record<string, any>[] =
           options.getValue(context.path) ?? [];
@@ -124,7 +124,7 @@ export function resolveBindingAST(
 
         if (index === undefined || index === -1) {
           context.updates[
-            [...context.path, objToQuery.length, resolvedKey].join('.')
+            [...context.path, objToQuery.length, resolvedKey].join(".")
           ] = resolvedValue;
           context.path.push(objToQuery.length);
         } else {
@@ -134,8 +134,8 @@ export function resolveBindingAST(
         break;
       }
 
-      case 'Concatenated':
-        context.path.push(resolvedNode.value.map(getValueForNode).join(''));
+      case "Concatenated":
+        context.path.push(resolvedNode.value.map(getValueForNode).join(""));
         break;
 
       default:

package/src/binding/utils.ts

@@ -1,8 +1,8 @@
-import type { BindingLike, BindingInstance } from './binding';
+import type { BindingLike, BindingInstance } from "./binding";
 
 /** Check if the parameter representing a binding is already of the Binding class */
 export function isBinding(binding: BindingLike): binding is BindingInstance {
-  return !(typeof binding === 'string' || Array.isArray(binding));
+  return !(typeof binding === "string" || Array.isArray(binding));
 }
 
 /** Convert the string to an int if you can, otherwise just return the original string */
@@ -20,14 +20,14 @@ export function maybeConvertToNum(i: string): string | number {
  * utility to convert binding into binding segments.
  */
 export function getBindingSegments(
-  binding: BindingLike
+  binding: BindingLike,
 ): Array<string | number> {
   if (Array.isArray(binding)) {
     return binding;
   }
 
-  if (typeof binding === 'string') {
-    return binding.split('.');
+  if (typeof binding === "string") {
+    return binding.split(".");
   }
 
   return binding.asArray();
@@ -37,10 +37,10 @@ export function getBindingSegments(
 export function findInArray<T extends Record<string | number, object>>(
   array: Array<T>,
   key: string | number,
-  value: T
+  value: T,
 ): number | undefined {
   return array.findIndex((obj) => {
-    if (obj && typeof obj === 'object') {
+    if (obj && typeof obj === "object") {
       // Intentional double-equals because we want '4' to be coerced to 4
       // eslint-disable-next-line eqeqeq
       return obj[key] == value;

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

@@ -0,0 +1,64 @@
+import { describe, test, expect } from "vitest";
+
+import {
+  VALID_AST_PARSER_TESTS,
+  INVALID_AST_PARSER_TESTS,
+  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);
+    expect(result.status).toBe(true);
+    expect((result as ParserSuccessResult).path).toStrictEqual(AST);
+  });
+
+  test.each(INVALID_AST_PARSER_TESTS)("Custom Invalid: %s", (binding) => {
+    const result = parseCustom(binding);
+    expect(result.status).toBe(false);
+    expect((result as ParserFailureResult).error.length > 0).toBe(true);
+  });
+
+  test.each(VALID_AST_PARSER_CUSTOM_TESTS)(
+    "Custom Unicode Valid: %s",
+    (binding, AST) => {
+      const result = parseCustom(binding);
+      expect(result.status).toBe(true);
+      expect((result as ParserSuccessResult).path).toStrictEqual(AST);
+    },
+  );
+});

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

@@ -0,0 +1,198 @@
+import type { PathNode } from "../../ast";
+import {
+  toValue,
+  toQuery,
+  toConcatenatedNode,
+  toPath,
+  toExpression,
+} from "../../ast";
+
+export const VALID_AST_PARSER_TESTS: Array<[string, PathNode]> = [
+  // Basic ones
+  ["", toPath([])],
+  ["foo", toPath([toValue("foo")])],
+  ["foo.bar", toPath([toValue("foo"), toValue("bar")])],
+  ["1234567890_ABC_abc", toPath([toValue("1234567890_ABC_abc")])],
+  ["a-b-c-d-", toPath([toValue("a-b-c-d-")])],
+
+  // Queries
+  [
+    "foo[x=something]",
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    "foo[x == something]",
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    "foo[x === something]",
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    `foo[x = 'something']`,
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    'foo[x == "something"]',
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    'foo["x"         =           "something"]',
+    toPath([toValue("foo"), toQuery(toValue("x"), toValue("something"))]),
+  ],
+  [
+    `foo['x'='hello [!@#$%^&*().]']`,
+    toPath([
+      toValue("foo"),
+      toQuery(toValue("x"), toValue("hello [!@#$%^&*().]")),
+    ]),
+  ],
+  [
+    `foo['Month'='New[.]]Mo,nth.']`,
+    toPath([
+      toValue("foo"),
+      toQuery(toValue("Month"), toValue("New[.]]Mo,nth.")),
+    ]),
+  ],
+
+  // Nested Paths
+  ["{{foo}}", toPath([toPath([toValue("foo")])])],
+  ["{{hello.world}}", toPath([toPath([toValue("hello"), toValue("world")])])],
+  [
+    "foo.bar.{{nested}}.baz",
+    toPath([
+      toValue("foo"),
+      toValue("bar"),
+      toPath([toValue("nested")]),
+      toValue("baz"),
+    ]),
+  ],
+  [
+    "foo[{{bar}}].baz",
+    toPath([toValue("foo"), toPath([toValue("bar")]), toValue("baz")]),
+  ],
+
+  // Brackets
+  [
+    "foo[a][b][c]",
+    toPath([toValue("foo"), toValue("a"), toValue("b"), toValue("c")]),
+  ],
+  [
+    `foo['a']["b"][c="bar"]`,
+    toPath([
+      toValue("foo"),
+      toValue("a"),
+      toValue("b"),
+      toQuery(toValue("c"), toValue("bar")),
+    ]),
+  ],
+  [
+    'foo[a][b == " [x    ]" ][c]',
+    toPath([
+      toValue("foo"),
+      toValue("a"),
+      toQuery(toValue("b"), toValue(" [x    ]")),
+      toValue("c"),
+    ]),
+  ],
+
+  // Multi-Nodes
+  [
+    "_hello_{{world}}",
+    toPath([
+      toConcatenatedNode([toValue("_hello_"), toPath([toValue("world")])]),
+    ]),
+  ],
+  [
+    "_hello_{{world}}_foo_",
+    toPath([
+      toConcatenatedNode([
+        toValue("_hello_"),
+        toPath([toValue("world")]),
+        toValue("_foo_"),
+      ]),
+    ]),
+  ],
+  [
+    "{{hello}}{{world}}",
+    toPath([
+      toConcatenatedNode([
+        toPath([toValue("hello")]),
+        toPath([toValue("world")]),
+      ]),
+    ]),
+  ],
+  [
+    "{{hello}}_foobar_{{world}}",
+    toPath([
+      toConcatenatedNode([
+        toPath([toValue("hello")]),
+        toValue("_foobar_"),
+        toPath([toValue("world")]),
+      ]),
+    ]),
+  ],
+  [
+    "{{hello}}_world_",
+    toPath([
+      toConcatenatedNode([toPath([toValue("hello")]), toValue("_world_")]),
+    ]),
+  ],
+  [
+    "{{hello}}_world",
+    toPath([
+      toConcatenatedNode([toPath([toValue("hello")]), toValue("_world")]),
+    ]),
+  ],
+  [
+    "foo.{{hello}}_world",
+    toPath([
+      toValue("foo"),
+      toConcatenatedNode([toPath([toValue("hello")]), toValue("_world")]),
+    ]),
+  ],
+
+  // Expressions
+  [
+    "foo.`bar()`.baz",
+    toPath([toValue("foo"), toExpression("bar()"), toValue("baz")]),
+  ],
+  [
+    "foo`bar()`.baz",
+    toPath([
+      toConcatenatedNode([toValue("foo"), toExpression("bar()")]),
+      toValue("baz"),
+    ]),
+  ],
+  [
+    "foo[`bar()`].baz",
+    toPath([toValue("foo"), toExpression("bar()"), toValue("baz")]),
+  ],
+  [
+    'foo["readonly" = `foo() == bar()`].baz',
+    toPath([
+      toValue("foo"),
+      toQuery(toValue("readonly"), toExpression("foo() == bar()")),
+      toValue("baz"),
+    ]),
+  ],
+];
+
+export const INVALID_AST_PARSER_TESTS: Array<string> = [
+  " ",
+  "@#$%^&*()",
+  ".",
+  "foo.bar[",
+  "foo.bar.{{nested.}",
+  "foo.bar`not done()",
+  "{foo.bar",
+];
+
+export const VALID_AST_PARSER_CUSTOM_TESTS: Array<[string, PathNode]> = [
+  ["foo‑<>~¡¢£", toPath([toValue("foo‑<>~¡¢£")])],
+  ["foo.bar<>~¡¢£", toPath([toValue("foo"), toValue("bar<>~¡¢£")])],
+  [
+    "foo[{{b‑ar}}].baz",
+    toPath([toValue("foo"), toPath([toValue("b‑ar")]), toValue("baz")]),
+  ],
+];

package/src/binding-grammar/__tests__/test-utils/perf-test.ts

@@ -0,0 +1,66 @@
+import { VALID_AST_PARSER_TESTS } from "./ast-cases";
+import { parse as parseParsimmon } from "../../parsimmon";
+import { parse as parseEBNF } from "../../ebnf";
+import { parse as parseCustom } from "../../custom";
+
+import type { Parser } from "../../ast";
+
+const parsers: Array<{
+  /** The name of the parser being tested */
+  name: string;
+
+  /** The parse function  */
+  parser: Parser;
+}> = [
+  { name: "parsimmon", parser: parseParsimmon },
+  { name: "ebnf", parser: parseEBNF },
+  { name: "custom", parser: parseCustom },
+];
+
+const VALID_ITERATIONS = 1000;
+
+/** Execute 1 iteration of the parser test */
+const runOnce = (parser: Parser): number => {
+  const start = Date.now();
+
+  for (const testCase of VALID_AST_PARSER_TESTS) {
+    parser(testCase[0]);
+  }
+
+  const end = Date.now();
+
+  return end - start;
+};
+
+/** Run all parser perf tests */
+export const testAll = () => {
+  const results: Array<{
+    /** The name of the parser */
+    name: string;
+
+    /** How long it took overall */
+    time: number;
+
+    /** Average number of bindings parsed per sec */
+    opsPerSec: number;
+  }> = [];
+
+  for (const parser of parsers) {
+    const runs = [];
+
+    for (let i = 0; i < VALID_ITERATIONS; i++) {
+      runs.push(runOnce(parser.parser));
+    }
+
+    const total = runs.reduce((s, n) => s + n);
+    const opsPerSec =
+      (VALID_ITERATIONS * VALID_AST_PARSER_TESTS.length) / (total / 1000);
+    results.push({
+      name: parser.name,
+      time: total,
+      opsPerSec,
+    });
+  }
+
+  console.table(results);
+};

package/src/binding-grammar/ast.ts

@@ -7,7 +7,7 @@ export interface Node<T extends string> {
  * An AST node that represents a nested path in the model
  * foo.{{bar}}.baz (this is {{bar}})
  */
-export interface PathNode extends Node<'PathNode'> {
+export interface PathNode extends Node<"PathNode"> {
   /** The path in the model that this node represents */
   path: Array<AnyNode>;
 }
@@ -16,7 +16,7 @@ export interface PathNode extends Node<'PathNode'> {
  * A segment representing a query
  * [foo=bar]
  */
-export interface QueryNode extends Node<'Query'> {
+export interface QueryNode extends Node<"Query"> {
   /** The key to query */
   key: AnyNode;
 
@@ -25,52 +25,52 @@ export interface QueryNode extends Node<'Query'> {
 }
 
 /** A simple segment */
-export interface ValueNode extends Node<'Value'> {
+export interface ValueNode extends Node<"Value"> {
   /** The segment value */
   value: string | number;
 }
 
 /** A nested expression */
-export interface ExpressionNode extends Node<'Expression'> {
+export interface ExpressionNode extends Node<"Expression"> {
   /** The expression */
   value: string;
 }
 
 /** Helper to create a value node */
 export const toValue = (value: string | number): ValueNode => ({
-  name: 'Value',
+  name: "Value",
   value,
 });
 
 /** Helper to create an expression node */
 export const toExpression = (value: string): ExpressionNode => ({
-  name: 'Expression',
+  name: "Expression",
   value,
 });
 
 /** Helper to create a nested path node */
 export const toPath = (path: Array<AnyNode>): PathNode => ({
-  name: 'PathNode',
+  name: "PathNode",
   path,
 });
 
 /** Helper to create a query node */
 export const toQuery = (key: AnyNode, value?: AnyNode): QueryNode => ({
-  name: 'Query',
+  name: "Query",
   key,
   value,
 });
 
 /** Create a concat node */
 export const toConcatenatedNode = (
-  values: Array<PathNode | ValueNode | ExpressionNode>
+  values: Array<PathNode | ValueNode | ExpressionNode>,
 ): PathNode | ValueNode | ConcatenatedNode | ExpressionNode => {
   if (values.length === 1) {
     return values[0];
   }
 
   return {
-    name: 'Concatenated',
+    name: "Concatenated",
     value: values,
   };
 };
@@ -79,7 +79,7 @@ export const toConcatenatedNode = (
  * A binding segment that's multiple smaller ones
  * {{foo}}_bar_{{baz}}
  */
-export interface ConcatenatedNode extends Node<'Concatenated'> {
+export interface ConcatenatedNode extends Node<"Concatenated"> {
   /** A list of nested paths, or value nodes to concat together to form a segment */
   value: Array<PathNode | ValueNode | ExpressionNode>;
 }

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

@@ -6,24 +6,24 @@ import type {
   ValueNode,
   QueryNode,
   ExpressionNode,
-} from '../ast';
+} from "../ast";
 import {
   toValue,
   toPath,
   toConcatenatedNode,
   toQuery,
   toExpression,
-} from '../ast';
-
-const SEGMENT_SEPARATOR = '.';
-const OPEN_CURL = '{';
-const CLOSE_CURL = '}';
-const OPEN_BRACKET = '[';
-const CLOSE_BRACKET = ']';
-const EQUALS = '=';
+} from "../ast";
+
+const SEGMENT_SEPARATOR = ".";
+const OPEN_CURL = "{";
+const CLOSE_CURL = "}";
+const OPEN_BRACKET = "[";
+const CLOSE_BRACKET = "]";
+const EQUALS = "=";
 const SINGLE_QUOTE = "'";
 const DOUBLE_QUOTE = '"';
-const BACK_TICK = '`';
+const BACK_TICK = "`";
 // const IDENTIFIER_REGEX = /[\w\-@]+/;
 
 /** A _faster_ way to match chars instead of a regex. */
@@ -65,14 +65,13 @@ export const parse: Parser = (path) => {
 
     ch = path.charAt(index);
     index += 1;
-    // console.log(`Index: ${index} Char: ${ch}`);
     return ch;
   };
 
   /** gobble all whitespace */
   const whitespace = () => {
     /* eslint-disable no-unmodified-loop-condition */
-    while (ch === ' ') {
+    while (ch === " ") {
       next();
     }
   };
@@ -146,15 +145,13 @@ export const parse: Parser = (path) => {
   const nestedPath = (): PathNode | undefined => {
     if (ch === OPEN_CURL) {
       next(OPEN_CURL);
-      if (ch === OPEN_CURL) {
-        next(OPEN_CURL);
-
-        /* eslint-disable-next-line @typescript-eslint/no-use-before-define */
-        const modelRef = parsePath();
-        next(CLOSE_CURL);
-        next(CLOSE_CURL);
-        return modelRef;
-      }
+      next(OPEN_CURL);
+
+      /* eslint-disable-next-line @typescript-eslint/no-use-before-define */
+      const modelRef = parsePath();
+      next(CLOSE_CURL);
+      next(CLOSE_CURL);
+      return modelRef;
     }
   };
 
@@ -254,7 +251,7 @@ export const parse: Parser = (path) => {
   const parseSegmentAndBrackets = (): Array<AnyNode> => {
     // try to parse a segment first
 
-    const parsed = [];
+    const parsed: Array<AnyNode> = [];
 
     const firstSegment = segment();