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

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

@@ -0,0 +1,113 @@
+import { describe, it, expect } from "vitest";
+import { BindingInstance } from "..";
+
+describe("contains", () => {
+  it("works for simple neg case", () => {
+    const foo = new BindingInstance("foo");
+    const bar = new BindingInstance("bar");
+    expect(foo.contains(bar)).toBe(false);
+  });
+
+  it("works for simple pos cases", () => {
+    const foo = new BindingInstance("foo");
+    const fooBar = new BindingInstance("foo.bar");
+    expect(foo.contains(fooBar)).toBe(true);
+    expect(fooBar.contains(foo)).toBe(false);
+  });
+
+  it("can handle bindings starting with numbers", () => {
+    const instance = new BindingInstance(
+      "foo.5f4704fd-adab-49df-bcbc-5aedb04194f9.baz",
+    );
+    expect(instance.asString()).toBe(
+      "foo.5f4704fd-adab-49df-bcbc-5aedb04194f9.baz",
+    );
+    expect(instance.asArray()[1]).toBe("5f4704fd-adab-49df-bcbc-5aedb04194f9");
+    expect(instance.key()).toBe("baz");
+  });
+
+  it("handles overlapping key-string matches", () => {
+    const foo = new BindingInstance("foo");
+    const fooBar = new BindingInstance("fo");
+    expect(foo.contains(fooBar)).toBe(false);
+
+    expect(
+      new BindingInstance("foo.bar.baz").contains(
+        new BindingInstance("foo.bar.bazzzz"),
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("relative", () => {
+  it("works for simple case", () => {
+    const foo = new BindingInstance("foo");
+    const fooBar = new BindingInstance("foo.bar");
+    expect(fooBar.relative(foo)).toStrictEqual(["bar"]);
+  });
+});
+
+describe("parent", () => {
+  it("works for easy ones", () => {
+    const fooBar = new BindingInstance("foo.bar");
+    expect(fooBar.parent().asString()).toBe("foo");
+  });
+});
+
+describe("key", () => {
+  it("works for easy ones", () => {
+    const fooBar = new BindingInstance("foo.bar");
+    expect(fooBar.key()).toBe("bar");
+  });
+});
+
+describe("numberic segments", () => {
+  it("splits numberic keys", () => {
+    expect(new BindingInstance("foo.1.bar").asArray()).toStrictEqual([
+      "foo",
+      1,
+      "bar",
+    ]);
+    expect(new BindingInstance(["foo", 1, "bar"]).asArray()).toStrictEqual([
+      "foo",
+      1,
+      "bar",
+    ]);
+  });
+});
+
+describe("descendent binding", () => {
+  it("generate child path from string", () => {
+    const binding = new BindingInstance("foo.1.bar");
+    expect(binding.descendent("barChild.UUID").asArray()).toStrictEqual([
+      "foo",
+      1,
+      "bar",
+      "barChild",
+      "UUID",
+    ]);
+  });
+
+  it("generate child path from binding segments", () => {
+    const binding = new BindingInstance("foo.1.bar");
+    expect(binding.descendent(["barChild", "UUID"]).asArray()).toStrictEqual([
+      "foo",
+      1,
+      "bar",
+      "barChild",
+      "UUID",
+    ]);
+  });
+
+  it("generate child path from a binding", () => {
+    const binding = new BindingInstance("foo.1.bar");
+    const childBinding = new BindingInstance("barChild.UUID");
+    expect(binding.descendent(childBinding).asArray()).toStrictEqual([
+      "foo",
+      1,
+      "bar",
+      "barChild",
+      "UUID",
+    ]);
+  });
+});

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

@@ -0,0 +1,208 @@
+import { describe, test, expect, vitest } from "vitest";
+import { BindingParser } from "..";
+
+test("caches bindings", () => {
+  const parser = new BindingParser();
+  const b1 = parser.parse("foo.bar");
+  const b2 = parser.parse("foo.bar");
+  const b3 = parser.parse(["foo", "bar"]);
+
+  expect(b1).toBe(b2);
+  expect(b1).toBe(b3);
+});
+
+test("does not call the update hook when readOnly is true", () => {
+  const onSetHook = vitest.fn();
+  const onGetHook = vitest.fn();
+
+  const parser = new BindingParser({
+    get: (b) => {
+      onGetHook(b);
+      return [{ bar: "blah" }];
+    },
+    set: onSetHook,
+    readOnly: true,
+  });
+
+  parser.parse('foo[bar="baz"].blah');
+  expect(onGetHook).toBeCalledWith(parser.parse("foo"));
+  expect(onSetHook).not.toHaveBeenCalled();
+});
+
+test("calls the update hook when data needs to be changed", () => {
+  const onSetHook = vitest.fn();
+  const onGetHook = vitest.fn();
+
+  const parser = new BindingParser({
+    get: (b) => {
+      onGetHook(b);
+
+      return [{ bar: "blah" }];
+    },
+    set: onSetHook,
+  });
+
+  parser.parse('foo[bar="baz"].blah');
+  expect(onGetHook).toBeCalledWith(parser.parse("foo"));
+  expect(onSetHook).toBeCalledWith([[parser.parse("foo.1.bar"), "baz"]]);
+});
+
+test("skips the update hook when data does not need to be changed", () => {
+  const onSetHook = vitest.fn();
+  const onGetHook = vitest.fn();
+
+  const parser = new BindingParser({
+    get: (b) => {
+      onGetHook(b);
+
+      return [{ bar: "baz" }];
+    },
+    set: onSetHook,
+  });
+
+  parser.parse('foo[bar="baz"].blah');
+  expect(onGetHook).toBeCalledWith(parser.parse("foo"));
+  expect(onSetHook).not.toBeCalledWith(parser.parse("foo"));
+});
+
+test("throws error on bad binding syntax", () => {
+  const parser = new BindingParser();
+  expect(() => parser.parse("foo.bar[")).toThrowError(
+    /Cannot normalize path "foo.bar\[/,
+  );
+});
+
+test("works for binding with nested refs", () => {
+  let callCount = 0;
+
+  const parser = new BindingParser({
+    get: () => {
+      return callCount++;
+    },
+  });
+
+  expect(parser.parse("foo.{{bar}}.baz").asString()).toBe("foo.0.baz");
+  expect(parser.parse("foo.{{bar}}.baz").asString()).toBe("foo.1.baz");
+});
+
+test("works for bindings with nested boolean refs", () => {
+  const parser = new BindingParser({
+    get: () => {
+      return true;
+    },
+  });
+
+  expect(parser.parse("foo.{{bar}}.baz").asString()).toBe("foo.true.baz");
+});
+
+test("works for binding with partial-nested refs", () => {
+  const parser = new BindingParser({
+    get: (binding) => {
+      if (binding.asString() === "hello") {
+        return "bar";
+      }
+
+      return "not-{{hello}}";
+    },
+  });
+
+  expect(parser.parse("foo.{{hello}}_world.baz").asString()).toBe(
+    "foo.bar_world.baz",
+  );
+  expect(parser.parse("foo.{{hello}}_other_{{world}}.baz").asString()).toBe(
+    "foo.bar_other_not-bar.baz",
+  );
+});
+
+test("works for expanded nested refs", () => {
+  const parser = new BindingParser({
+    get: (binding) => {
+      if (binding.asString() === "nested") {
+        return "nested.ref[1]";
+      }
+    },
+  });
+
+  expect(parser.parse("foo.{{nested}}.baz").asString()).toBe(
+    "foo.nested.ref.1.baz",
+  );
+});
+
+test("returns a binding if its already parsed", () => {
+  const parser = new BindingParser();
+  const binding = parser.parse("foo.bar");
+  expect(parser.parse(binding)).toBe(binding);
+});
+
+test("top level parser returns empty key set", () => {
+  const parser = new BindingParser();
+  const binding = parser.parse("");
+  expect(binding.asArray()).toHaveLength(0);
+  expect(binding.asString()).toBe("");
+});
+
+describe("errors", () => {
+  test("throws when it gets an undefined nested path", () => {
+    const parser = new BindingParser({
+      get: () => undefined,
+    });
+
+    expect(() => parser.parse("foo.{{nested}}.bar")).toThrowError();
+  });
+
+  test("throws when get is used but not wired up", () => {
+    const parser = new BindingParser({
+      get: () => undefined,
+    });
+
+    expect(() =>
+      parser.parse("foo.{{nested}}.bar"),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[NestedError: Cannot resolve binding: foo.{{nested}}.bar]`,
+    );
+  });
+
+  test("throws when set is used but not wired up", () => {
+    const parser = new BindingParser({
+      get: () => [],
+    });
+
+    expect(() => parser.parse("foo[foo=bar].bar")).toThrowError();
+  });
+
+  test("throws when eval is used but not wired up", () => {
+    const parser = new BindingParser();
+
+    expect(() => parser.parse("foo.`exp()`.bar")).toThrowError();
+  });
+
+  test("throws when a path is not binding serializable", () => {
+    const parser = new BindingParser({
+      get: () => ({
+        foo: "bar",
+      }),
+    });
+
+    expect(() => parser.parse("foo.{{nested}}.bar")).toThrowError();
+  });
+
+  // When exp() === '' -> ??? (foo.bar) | Error
+
+  describe("expressions", () => {
+    test("throws when expression returns undef", () => {
+      const parser = new BindingParser({
+        evaluate: () => undefined,
+      });
+
+      expect(() => parser.parse("foo.`exp()`.bar")).toThrowError();
+    });
+
+    test("throws when expression returns empty binding", () => {
+      const parser = new BindingParser({
+        evaluate: () => "",
+      });
+
+      expect(() => parser.parse("foo.`exp()`.bar")).toThrowError();
+    });
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, test, expect, vitest } from "vitest";
+import get from "dlv";
+import type { ParserSuccessResult } from "../../binding-grammar";
+import { parseParsimmon } from "../../binding-grammar";
+import { resolveBindingAST } from "../resolver";
+import { getBindingSegments } from "../utils";
+
+const testModel = {
+  foo: {
+    pets: [
+      {
+        name: "ginger",
+        type: "dog",
+      },
+      {
+        name: "daisy",
+        type: "dog",
+      },
+      {
+        name: "frodo",
+        type: "cat",
+      },
+      "other",
+    ],
+  },
+};
+
+const testCases: Array<[string, string]> = [
+  ["foo.bar", "foo.bar"],
+  ["foo.pets.1.name", "foo.pets.1.name"],
+  ['foo.pets[name = "frodo"].type', "foo.pets.2.type"],
+  ['foo.pets["name" = "sprinkles"].type', "foo.pets.4.type"],
+];
+
+test.each(testCases)("Resolving binding: %s", (binding, expectedResolved) => {
+  const parsedBinding = parseParsimmon(binding);
+  expect(parsedBinding.status).toBe(true);
+  const actual = resolveBindingAST(
+    (parsedBinding as ParserSuccessResult).path,
+    {
+      getValue: (path) => get(testModel, getBindingSegments(path) as any),
+      convertToPath: (p) => p,
+      evaluate: () => undefined,
+    },
+  );
+
+  expect(actual.path.join(".")).toBe(expectedResolved);
+});
+
+test("works for nested keys", () => {
+  const parsedBinding = parseParsimmon("foo.{{BASE_PATH}}.bar");
+  expect(parsedBinding.status).toBe(true);
+
+  const resolved = resolveBindingAST(
+    (parsedBinding as ParserSuccessResult).path,
+    {
+      getValue: () => "path.nested[1]",
+      convertToPath: () => "path.nested.1",
+      evaluate: () => undefined,
+    },
+  );
+  expect(resolved.path.join(".")).toBe("foo.path.nested.1.bar");
+  expect(resolved.path).toStrictEqual(["foo", "path", "nested", 1, "bar"]);
+});
+
+describe("expressions", () => {
+  test("evaluates expressions as paths", () => {
+    const parsedBinding = parseParsimmon("foo.bar.`exp()`");
+
+    const evaluate = vitest.fn().mockReturnValue(100);
+    const resolved = resolveBindingAST(
+      (parsedBinding as ParserSuccessResult).path,
+      {
+        getValue: () => undefined,
+        convertToPath: (p) => p,
+        evaluate,
+      },
+    );
+
+    expect(evaluate).toBeCalledWith("exp()");
+    expect(resolved.path.join(".")).toBe("foo.bar.100");
+  });
+});

package/src/binding/binding.ts

@@ -1,4 +1,4 @@
-import { getBindingSegments } from './utils';
+import { getBindingSegments } from "./utils";
 
 export interface BindingParserOptions {
   /** Get the value for a specific binding */
@@ -31,7 +31,7 @@ export type RawBinding = string | RawBindingSegment[];
 export type BindingLike = RawBinding | BindingInstance;
 export type BindingFactory = (
   raw: RawBinding,
-  options?: Partial<BindingParserOptions>
+  options?: Partial<BindingParserOptions>,
 ) => BindingInstance;
 
 /**
@@ -44,11 +44,11 @@ export class BindingInstance {
 
   constructor(
     raw: RawBinding,
-    factory = (rawBinding: RawBinding) => new BindingInstance(rawBinding)
+    factory = (rawBinding: RawBinding) => new BindingInstance(rawBinding),
   ) {
-    const split = Array.isArray(raw) ? raw : raw.split('.');
+    const split = Array.isArray(raw) ? raw : raw.split(".");
     this.split = split.map((segment) => {
-      if (typeof segment === 'number') {
+      if (typeof segment === "number") {
         return segment;
       }
 
@@ -56,7 +56,7 @@ export class BindingInstance {
       return isNaN(tryNum) ? segment : tryNum;
     });
     Object.freeze(this.split);
-    this.joined = this.split.join('.');
+    this.joined = this.split.join(".");
     this.factory = factory;
   }
 

package/src/binding/index.ts

@@ -1,18 +1,18 @@
-import { SyncBailHook, SyncWaterfallHook } from 'tapable-ts';
-import { NestedError } from 'ts-nested-error';
-import type { ParserResult, AnyNode } from '../binding-grammar';
+import { SyncBailHook, SyncWaterfallHook } from "tapable-ts";
+import { NestedError } from "ts-nested-error";
+import type { ParserResult, AnyNode } from "../binding-grammar/index";
 import {
   // We can swap this with whichever parser we want to use
   parseCustom as parseBinding,
-} from '../binding-grammar';
-import type { BindingParserOptions, BindingLike } from './binding';
-import { BindingInstance } from './binding';
-import { isBinding } from './utils';
-import type { NormalizedResult, ResolveBindingASTOptions } from './resolver';
-import { resolveBindingAST } from './resolver';
+} from "../binding-grammar";
+import type { BindingParserOptions, BindingLike } from "./binding";
+import { BindingInstance } from "./binding";
+import { isBinding } from "./utils";
+import type { NormalizedResult, ResolveBindingASTOptions } from "./resolver";
+import { resolveBindingAST } from "./resolver";
 
-export * from './utils';
-export * from './binding';
+export * from "./utils";
+export * from "./binding";
 
 export const SIMPLE_BINDING_REGEX = /^[\w\-@]+(\.[\w\-@]+)*$/;
 export const BINDING_BRACKETS_REGEX = /[\s()*=`{}'"[\]]/;
@@ -20,13 +20,13 @@ const LAZY_BINDING_REGEX = /^[^.]+(\..+)*$/;
 
 const DEFAULT_OPTIONS: BindingParserOptions = {
   get: () => {
-    throw new Error('Not Implemented');
+    throw new Error("Not Implemented");
   },
   set: () => {
-    throw new Error('Not Implemented');
+    throw new Error("Not Implemented");
   },
   evaluate: () => {
-    throw new Error('Not Implemented');
+    throw new Error("Not Implemented");
   },
 };
 
@@ -59,7 +59,7 @@ export class BindingParser {
    */
   private normalizePath(
     path: string,
-    resolveOptions: ResolveBindingASTOptions
+    resolveOptions: ResolveBindingASTOptions,
   ) {
     /**
      * Ensure no binding characters exist in path and the characters remaining
@@ -70,15 +70,15 @@ export class BindingParser {
       LAZY_BINDING_REGEX.test(path) &&
       this.hooks.skipOptimization.call(path) !== true
     ) {
-      return { path: path.split('.'), updates: undefined } as NormalizedResult;
+      return { path: path.split("."), updates: undefined } as NormalizedResult;
     }
 
     const ast = this.parseCache[path] ?? parseBinding(path);
     this.parseCache[path] = ast;
 
-    if (typeof ast !== 'object' || !ast?.status) {
+    if (typeof ast !== "object" || !ast?.status) {
       throw new TypeError(
-        `Cannot normalize path "${path}": ${ast?.error ?? 'Unknown Error.'}`
+        `Cannot normalize path "${path}": ${ast?.error ?? "Unknown Error."}`,
       );
     }
 
@@ -90,17 +90,17 @@ export class BindingParser {
   }
 
   private getBindingForNormalizedResult(
-    normalized: NormalizedResult
+    normalized: NormalizedResult,
   ): BindingInstance {
-    const normalizedStr = normalized.path.join('.');
+    const normalizedStr = normalized.path.join(".");
 
     if (this.cache[normalizedStr]) {
       return this.cache[normalizedStr];
     }
 
     const created = new BindingInstance(
-      normalizedStr === '' ? [] : normalized.path,
-      this.parse
+      normalizedStr === "" ? [] : normalized.path,
+      this.parse,
     );
     this.cache[normalizedStr] = created;
 
@@ -109,7 +109,7 @@ export class BindingParser {
 
   public parse(
     rawBinding: BindingLike,
-    overrides: Partial<BindingParserOptions> = {}
+    overrides: Partial<BindingParserOptions> = {},
   ): BindingInstance {
     if (isBinding(rawBinding)) {
       return rawBinding;
@@ -123,12 +123,12 @@ export class BindingParser {
     let updates: Record<string, any> = {};
 
     const joined = Array.isArray(rawBinding)
-      ? rawBinding.join('.')
+      ? rawBinding.join(".")
       : String(rawBinding);
 
     const normalizeConfig: ResolveBindingASTOptions = {
       getValue: (path: Array<string | number>) => {
-        const normalized = this.normalizePath(path.join('.'), normalizeConfig);
+        const normalized = this.normalizePath(path.join("."), normalizeConfig);
 
         return options.get(this.getBindingForNormalizedResult(normalized));
       },
@@ -138,17 +138,17 @@ export class BindingParser {
       convertToPath: (path: any) => {
         if (path === undefined) {
           throw new Error(
-            'Attempted to convert undefined value to binding path'
+            "Attempted to convert undefined value to binding path",
           );
         }
 
         if (
-          typeof path !== 'string' &&
-          typeof path !== 'number' &&
-          typeof path !== 'boolean'
+          typeof path !== "string" &&
+          typeof path !== "number" &&
+          typeof path !== "boolean"
         ) {
           throw new Error(
-            `Attempting to convert ${typeof path} to a binding path.`
+            `Attempting to convert ${typeof path} to a binding path.`,
           );
         }
 
@@ -161,10 +161,10 @@ export class BindingParser {
           };
         }
 
-        const joinedNormalizedPath = normalized.path.join('.');
+        const joinedNormalizedPath = normalized.path.join(".");
 
-        if (joinedNormalizedPath === '') {
-          throw new Error('Nested path resolved to an empty path');
+        if (joinedNormalizedPath === "") {
+          throw new Error("Nested path resolved to an empty path");
         }
 
         return joinedNormalizedPath;
@@ -187,7 +187,7 @@ export class BindingParser {
         (updatedBinding) => [
           this.parse(updatedBinding),
           updates[updatedBinding],
-        ]
+        ],
       );
 
       options.set(updateTransaction);