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

package/src/expressions/__tests__/evaluator-functions.test.ts

@@ -0,0 +1,47 @@
+import { describe, test, expect, beforeEach } from "vitest";
+import type { DataModelWithParser } from "../../data";
+import { LocalModel, withParser } from "../../data";
+import { BindingParser } from "../../binding";
+import { deleteDataVal, setDataVal, getDataVal } from "../evaluator-functions";
+import type { ExpressionContext } from "../types";
+
+describe("eval functions", () => {
+  let model: DataModelWithParser;
+  let context: ExpressionContext;
+
+  beforeEach(() => {
+    const localModel = new LocalModel();
+    const bindingParser = new BindingParser({
+      get: localModel.get,
+      set: localModel.set,
+      evaluate: () => undefined,
+    });
+    model = withParser(localModel, bindingParser.parse);
+    context = {
+      model,
+      evaluate: () => undefined,
+    };
+  });
+
+  test("deleteDataVal", () => {
+    model.set([["foo.bar", 2]]);
+    expect(model.get("foo.bar")).toBe(2);
+
+    deleteDataVal(context, "foo.bar");
+    expect(model.get("foo.bar")).toBeUndefined();
+  });
+
+  test("setDataVal", () => {
+    model.set([["foo.bar", 2]]);
+    expect(model.get("foo.bar")).toBe(2);
+
+    setDataVal(context, "foo.bar", 10);
+    expect(model.get("foo.bar")).toBe(10);
+  });
+
+  test("getDataVal", () => {
+    model.set([["foo.bar", 2]]);
+    expect(model.get("foo.bar")).toBe(2);
+    expect(getDataVal(context, "foo.bar")).toBe(2);
+  });
+});

package/src/expressions/__tests__/evaluator.test.ts

@@ -0,0 +1,410 @@
+import { describe, it, expect, vitest, test, beforeEach } from "vitest";
+import type { DataModelWithParser } from "../../data";
+import { LocalModel, withParser } from "../../data";
+import type { BindingLike } from "../../binding";
+import { BindingParser } from "../../binding";
+import type { ExpressionType } from "..";
+import { ExpressionEvaluator } from "..";
+
+describe("evaluator", () => {
+  let evaluator: ExpressionEvaluator;
+  let model: DataModelWithParser;
+  let parseBinding: BindingParser["parse"];
+
+  beforeEach(() => {
+    const localModel = new LocalModel();
+    const bindingParser = new BindingParser({
+      get: localModel.get,
+      set: localModel.set,
+      evaluate: (exp: ExpressionType) => {
+        return evaluator.evaluate(exp);
+      },
+    });
+
+    parseBinding = bindingParser.parse;
+    model = withParser(localModel, bindingParser.parse);
+    evaluator = new ExpressionEvaluator({ model });
+  });
+
+  test("resolveOptions hook", () => {
+    model = withParser(new LocalModel({ foo: 2 }), parseBinding);
+    evaluator = new ExpressionEvaluator({ model });
+
+    const testFn = vitest.fn();
+
+    evaluator.hooks.resolveOptions.tap("test", (hookOptions) => {
+      testFn.mockImplementation((value: any) => hookOptions.model.set(value));
+
+      return { ...hookOptions, model: { ...hookOptions.model, set: testFn } };
+    });
+
+    evaluator.evaluate("{{foo}} = 3");
+    expect(model.get("foo")).toStrictEqual(3);
+    expect(testFn).toBeCalled();
+  });
+
+  test("member expression", () => {
+    evaluator.setExpressionVariable("foo", { bar: "baz" });
+    expect(evaluator.evaluate('foo["bar"]')).toStrictEqual("baz");
+  });
+  test("custom variables (identifier)", () => {
+    evaluator.setExpressionVariable("foo", 3);
+    evaluator.setExpressionVariable("bar", "baz");
+    evaluator.setExpressionVariable("bang", [1, 2, 3]);
+    expect(evaluator.evaluate("foo")).toStrictEqual(3);
+    expect(evaluator.evaluate("foo + 1")).toStrictEqual(4);
+    expect(evaluator.evaluate("bar")).toStrictEqual("baz");
+    expect(evaluator.evaluate("bang")).toStrictEqual([1, 2, 3]);
+  });
+  test("literals", () => {
+    expect(evaluator.evaluate("2")).toStrictEqual(2);
+    expect(evaluator.evaluate("true")).toStrictEqual(true);
+    expect(evaluator.evaluate("false")).toStrictEqual(false);
+    expect(evaluator.evaluate("undefined")).toBe(undefined);
+    expect(evaluator.evaluate(undefined)).toBe(undefined);
+    expect(evaluator.evaluate(null)).toBe(null);
+    expect(evaluator.evaluate("null")).toBe(null);
+
+    expect(evaluator.evaluate(2)).toStrictEqual(2);
+    expect(evaluator.evaluate(true)).toStrictEqual(true);
+    expect(evaluator.evaluate(false)).toStrictEqual(false);
+  });
+
+  test("Objects", () => {
+    expect(
+      evaluator.evaluate('[{"foo": "value"}, {"bar": "value"}]'),
+    ).toStrictEqual([
+      {
+        foo: "value",
+      },
+      { bar: "value" },
+    ]);
+    expect(evaluator.evaluate('{"foo": "value"}')).toStrictEqual({
+      foo: "value",
+    });
+    expect(evaluator.evaluate('{"foo": 1 + 2}')).toStrictEqual({
+      foo: 3,
+    });
+    expect(evaluator.evaluate('{"foo": 1 > 2}')).toStrictEqual({
+      foo: false,
+    });
+    expect(evaluator.evaluate('{"foo": 1 + 2, "bar": 4}')).toStrictEqual({
+      foo: 3,
+      bar: 4,
+    });
+    expect(
+      evaluator.evaluate('{"foo": 2, "bar": { "baz":  "foo" }}'),
+    ).toStrictEqual({
+      foo: 2,
+      bar: {
+        baz: "foo",
+      },
+    });
+
+    expect(evaluator.evaluate({ value: "1 + 2" })).toStrictEqual(3);
+  });
+  test("functions", () => {
+    model = withParser(new LocalModel({ test: 2 }), parseBinding);
+    evaluator.addExpressionFunction("publish", (_context, key, value: any) => {
+      model.set([[key as BindingLike, value]]);
+    });
+    evaluator.evaluate('publish("test", {"key": "value"})');
+    expect(model.get("test")).toStrictEqual({ key: "value" });
+  });
+
+  test("eval in context", () => {
+    model = withParser(new LocalModel({ test: 2 }), parseBinding);
+    evaluator.addExpressionFunction("exec", (_context, value: string) => {
+      _context.evaluate(value);
+    });
+    evaluator.evaluate('exec("{{foo}} = true")', { model });
+    expect(model.get("foo")).toBe(true);
+  });
+
+  test("binary operators", () => {
+    expect(evaluator.evaluate("1 == 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 == 2")).toStrictEqual(false);
+
+    expect(evaluator.evaluate("1 === 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 === 2")).toStrictEqual(false);
+
+    expect(evaluator.evaluate("1 != 1")).toStrictEqual(false);
+    expect(evaluator.evaluate("1 != 2")).toStrictEqual(true);
+
+    expect(evaluator.evaluate("1 !== 1")).toStrictEqual(false);
+    expect(evaluator.evaluate("1 !== 2")).toStrictEqual(true);
+
+    expect(evaluator.evaluate("1 < 2")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 < 1")).toStrictEqual(false);
+    expect(evaluator.evaluate("1 < 0")).toStrictEqual(false);
+    expect(evaluator.evaluate("2 > 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 > 1")).toStrictEqual(false);
+    expect(evaluator.evaluate("0 > 1")).toStrictEqual(false);
+
+    expect(evaluator.evaluate("1 <= 2")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 <= 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 <= 0")).toStrictEqual(false);
+    expect(evaluator.evaluate("2 >= 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 >= 1")).toStrictEqual(true);
+    expect(evaluator.evaluate("0 >= 1")).toStrictEqual(false);
+
+    expect(evaluator.evaluate("1 + 2")).toStrictEqual(3);
+    expect(evaluator.evaluate("5 - 3")).toStrictEqual(2);
+    expect(evaluator.evaluate("2 * 3")).toStrictEqual(6);
+    expect(evaluator.evaluate("6 / 3")).toStrictEqual(2);
+    expect(evaluator.evaluate("8 % 3")).toStrictEqual(2);
+  });
+
+  test("add binary operators", () => {
+    evaluator.addBinaryOperator("==", () => 5);
+
+    expect(evaluator.evaluate("1 == 2")).toStrictEqual(5);
+  });
+  test("add unary operators", () => {
+    evaluator.addUnaryOperator("!", () => 5);
+
+    expect(evaluator.evaluate("!1")).toStrictEqual(5);
+  });
+
+  test("logical operators", () => {
+    expect(evaluator.evaluate("true && false")).toStrictEqual(false);
+    expect(evaluator.evaluate("true && true")).toStrictEqual(true);
+    expect(evaluator.evaluate("1 && 2")).toStrictEqual(2);
+    expect(evaluator.evaluate("1 && 0")).toStrictEqual(0);
+  });
+
+  test("unary operators", () => {
+    expect(evaluator.evaluate("!false")).toStrictEqual(true);
+    expect(evaluator.evaluate("!true")).toStrictEqual(false);
+    expect(evaluator.evaluate("+1")).toStrictEqual(1);
+    expect(evaluator.evaluate("-1")).toStrictEqual(-1);
+    expect(evaluator.evaluate("-(-1)")).toStrictEqual(1);
+  });
+
+  test("model ref", () => {
+    model = withParser(new LocalModel({ foo: { bar: "baz" } }), parseBinding);
+    expect(
+      evaluator.evaluate("{{foo.bar}}", {
+        model,
+      }),
+    ).toStrictEqual("baz");
+  });
+
+  test("model ref and Object", () => {
+    model = withParser(
+      new LocalModel({ bar: { hello: "world" } }),
+      parseBinding,
+    );
+    expect(
+      evaluator.evaluate('{ "foo": {{bar}} }', {
+        model,
+      }),
+    ).toStrictEqual({ foo: { hello: "world" } });
+  });
+
+  test("ternary operator (conditional)", () => {
+    expect(evaluator.evaluate("true ? true : false")).toStrictEqual(true);
+    expect(evaluator.evaluate("false ? true : false")).toStrictEqual(false);
+  });
+
+  test("array", () => {
+    expect(evaluator.evaluate("[1,2,3]")).toStrictEqual([1, 2, 3]);
+  });
+
+  test("assignment", () => {
+    model = withParser(new LocalModel({ foo: 2 }), parseBinding);
+    evaluator.evaluate("{{foo}} = 3", {
+      model,
+    });
+    expect(model.get("foo")).toStrictEqual(3);
+  });
+
+  test("local assignment and re-assignment", () => {
+    evaluator.evaluate("foo = 5");
+    expect(evaluator.evaluate("foo")).toStrictEqual(5);
+    evaluator.evaluate("foo = 7");
+    expect(evaluator.evaluate("foo")).toStrictEqual(7);
+  });
+
+  test("object assignment", () => {
+    model = withParser(new LocalModel({ foo: 2 }), parseBinding);
+    evaluator.evaluate('{{foo}} = {"foo": 2}', {
+      model,
+    });
+
+    expect(model.get("foo")).toStrictEqual({ foo: 2 });
+  });
+  describe("modification", () => {
+    describe("on model", () => {
+      beforeEach(() => {
+        model = withParser(new LocalModel({ foo: 1 }), parseBinding);
+      });
+
+      test("simple add", () => {
+        evaluator.evaluate("{{foo}} += 3", { model });
+        expect(model.get("foo")).toStrictEqual(4);
+      });
+
+      test("simple substract", () => {
+        evaluator.evaluate("{{foo}} -= 3", { model });
+        expect(model.get("foo")).toStrictEqual(-2);
+      });
+    });
+
+    describe("on expression variable", () => {
+      beforeEach(() => {
+        evaluator.setExpressionVariable("foo", 1);
+      });
+
+      test("simple add", () => {
+        evaluator.evaluate("foo += 3");
+        expect(evaluator.getExpressionVariable("foo")).toStrictEqual(4);
+      });
+
+      test("simple subtract", () => {
+        evaluator.evaluate("foo -= 3");
+        expect(evaluator.getExpressionVariable("foo")).toStrictEqual(-2);
+      });
+    });
+  });
+
+  describe("Call Expressions", () => {
+    beforeEach(() => {
+      model = withParser(new LocalModel({ foo: 1 }), parseBinding);
+    });
+
+    test("get model", () => {
+      expect(
+        evaluator.evaluate('getDataVal("foo")', {
+          model,
+        }),
+      ).toStrictEqual(1);
+    });
+    test("set model", () => {
+      evaluator.evaluate('setDataVal("foo", 2)', {
+        model,
+      });
+      expect(model.get("foo")).toStrictEqual(2);
+    });
+    test("conditional", () => {
+      expect(
+        evaluator.evaluate("conditional(true, true, false)"),
+      ).toStrictEqual(true);
+
+      expect(
+        evaluator.evaluate("conditional(false, true, false)"),
+      ).toStrictEqual(false);
+    });
+  });
+  describe("not supported", () => {
+    test("this ref", () => {
+      expect(() => evaluator.evaluate("this")).toThrow();
+    });
+
+    test("compound expression", () => {
+      expect(() => evaluator.evaluate("foo bar")).toThrow();
+    });
+  });
+
+  describe("error handling", () => {
+    test("skips throwing error when handler is provided, but not when throwErrors is true", () => {
+      const errorHandler = vitest.fn();
+
+      evaluator.hooks.onError.tap("test", (e) => {
+        errorHandler(e);
+
+        return true;
+      });
+
+      evaluator.evaluate("foo()");
+
+      expect(errorHandler).toBeCalledTimes(1);
+
+      expect(() =>
+        evaluator.evaluate("foo()", { throwErrors: true, model }),
+      ).toThrowError();
+    });
+  });
+
+  describe("complex", () => {
+    beforeEach(() => {
+      model = withParser(
+        new LocalModel({ foo: { bar: true }, baz: { other: false } }),
+        parseBinding,
+      );
+    });
+
+    it("can set a model to an object", () => {
+      evaluator.evaluate("{{foo.nested}} = false || {{baz}}", { model });
+      expect(model.get("foo.nested.other")).toStrictEqual(false);
+    });
+  });
+
+  describe("shortcuts binary ops", () => {
+    const aFunc = vitest.fn();
+    const bFunc = vitest.fn();
+
+    beforeEach(() => {
+      aFunc.mockReset();
+      bFunc.mockReset();
+
+      evaluator.addExpressionFunction("a", aFunc);
+      evaluator.addExpressionFunction("b", bFunc);
+    });
+
+    it("shortcuts || on true", () => {
+      aFunc.mockReturnValue(true);
+      evaluator.evaluate("a() || b()");
+
+      expect(aFunc).toBeCalledTimes(1);
+      expect(bFunc).not.toBeCalled();
+    });
+
+    it("works for full ||", () => {
+      aFunc.mockReturnValue(0);
+      evaluator.evaluate("a() || b()");
+
+      expect(aFunc).toBeCalledTimes(1);
+      expect(bFunc).toBeCalledTimes(1);
+    });
+
+    it("shortcuts && on false", () => {
+      aFunc.mockReturnValue(0);
+      evaluator.evaluate("a() && b()");
+
+      expect(aFunc).toBeCalledTimes(1);
+      expect(bFunc).not.toBeCalled();
+    });
+
+    it("works for full &&", () => {
+      aFunc.mockReturnValue(true);
+      evaluator.evaluate("a() && b()");
+
+      expect(aFunc).toBeCalledTimes(1);
+      expect(bFunc).toBeCalledTimes(1);
+    });
+  });
+
+  test("throws errors for unknown expressions", () => {
+    expect(() => evaluator.evaluate("foo()")).toThrowError(
+      "Error evaluating expression: foo()",
+    );
+  });
+
+  test("enables hooks to change expression", () => {
+    evaluator.hooks.beforeEvaluate.tap("test", (expression) => {
+      return `'foo' == 'bar'`;
+    });
+
+    expect(evaluator.evaluate("bar()")).toStrictEqual(false);
+  });
+
+  test("ignores props other than value on expression", () => {
+    expect(
+      evaluator.evaluate({
+        _comment: "hello world",
+        value: true,
+      } as any),
+    ).toStrictEqual(true);
+  });
+});

package/src/expressions/__tests__/parser.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, test, expect } from "vitest";
+import { parseExpression } from "../parser";
+import { ExpNodeOpaqueIdentifier } from "../types";
+
+test("the happy stuff", () => {
+  expect(parseExpression("foo")).toMatchSnapshot();
+  expect(parseExpression("foo === bar")).toMatchSnapshot();
+  expect(parseExpression("foo || bar")).toMatchSnapshot();
+  expect(parseExpression("foo(bar)")).toMatchSnapshot();
+  expect(parseExpression('{{foo}} = "bar"')).toMatchSnapshot();
+  expect(parseExpression('{{foo}} ? "bar" : "baz"')).toMatchSnapshot();
+  expect(parseExpression("foo[bar]")).toMatchSnapshot();
+  expect(
+    parseExpression('{{foo}} == "string\nwith\tbreaks"'),
+  ).toMatchSnapshot();
+  expect(parseExpression("foo = [1, 2, 3]")).toMatchSnapshot();
+});
+
+test("nested binary op location", () => {
+  expect(parseExpression("foo === bar === baz")).toStrictEqual({
+    __id: ExpNodeOpaqueIdentifier,
+    type: "BinaryExpression",
+    operator: "===",
+    left: {
+      __id: ExpNodeOpaqueIdentifier,
+      type: "BinaryExpression",
+      operator: "===",
+      left: {
+        __id: ExpNodeOpaqueIdentifier,
+        type: "Identifier",
+        name: "foo",
+        location: {
+          start: { character: 0 },
+          end: { character: 3 },
+        },
+      },
+      right: {
+        __id: ExpNodeOpaqueIdentifier,
+        type: "Identifier",
+        name: "bar",
+        location: {
+          start: { character: 8 },
+          end: { character: 11 },
+        },
+      },
+      location: {
+        start: { character: 0 },
+        end: { character: 11 },
+      },
+    },
+    right: {
+      __id: ExpNodeOpaqueIdentifier,
+      type: "Identifier",
+      name: "baz",
+      location: {
+        start: { character: 16 },
+        end: { character: 19 },
+      },
+    },
+    location: {
+      start: { character: 0 },
+      end: { character: 19 },
+    },
+  });
+});
+
+test("the bad stuff", () => {
+  expect(() => parseExpression("{{foo")).toThrowError();
+  expect(() => parseExpression("{{foo}")).toThrowError();
+  expect(() => parseExpression('foo["bar"')).toThrowError();
+  expect(() => parseExpression('foo["bar')).toThrowError();
+  expect(() => parseExpression("foo]")).toThrowError();
+  expect(() => parseExpression("foo = (bar")).toThrowError();
+  expect(() => parseExpression("foo(")).toThrowError();
+});
+describe("expression parser", () => {
+  test("objects- in parser", () => {
+    expect(parseExpression('{"foo": "value"}')).toMatchSnapshot();
+    expect(parseExpression('{"foo": {{some.binding}}}')).toMatchSnapshot();
+    expect(parseExpression('{"foo": 1 + 2}')).toMatchSnapshot();
+    expect(parseExpression('{"foo": "value", "bar": "baz"}')).toMatchSnapshot();
+    expect(
+      parseExpression('{"foo": "value", "bar": { "baz":  "foo" }}'),
+    ).toMatchSnapshot();
+    expect(
+      parseExpression('publish("test", {"key": "value"})'),
+    ).toMatchSnapshot();
+    // no closing brace
+    expect(() => parseExpression('{"foo": "value"')).toThrowError();
+    // no key
+    expect(() => parseExpression('{: "value"}')).toThrowError();
+    // no value
+    expect(() => parseExpression('{"key": }')).toThrowError();
+    // no colon
+    expect(() => parseExpression('{"key" "value" }')).toThrowError();
+    // no comma
+    expect(() =>
+      parseExpression('{"key": "value" "key2": "value" }'),
+    ).toThrowError();
+  });
+});
+
+describe("graceful parsing", () => {
+  it("returns and sets the error for invalid expression", () => {
+    const parsed = parseExpression("{{foo}} = {{bar}", {
+      strict: false,
+    });
+
+    expect(parsed).toBeTruthy();
+    expect(parsed.error).toBeTruthy();
+    expect(parsed.error?.message).toBe(
+      'Unclosed brace after "bar}" at character 16',
+    );
+  });
+});

package/src/expressions/__tests__/utils.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { parseExpression } from "../parser";
+import { findClosestNodeAtPosition } from "../utils";
+
+describe("findClosestNodeAtPosition", () => {
+  it("finds the right nodes", () => {
+    const expression = '{{foo}} = test("bar", 12, ["baz", "qux"]) + !true';
+    const parsed = parseExpression(expression);
+
+    expect(findClosestNodeAtPosition(parsed, { character: 1 })).toStrictEqual(
+      expect.objectContaining({
+        type: "ModelRef",
+        ref: "foo",
+      }),
+    );
+
+    expect(findClosestNodeAtPosition(parsed, { character: 8 })).toStrictEqual(
+      expect.objectContaining({
+        type: "Assignment",
+      }),
+    );
+
+    expect(findClosestNodeAtPosition(parsed, { character: 12 })).toStrictEqual(
+      expect.objectContaining({
+        type: "Identifier",
+        name: "test",
+      }),
+    );
+
+    expect(findClosestNodeAtPosition(parsed, { character: 16 })).toStrictEqual(
+      expect.objectContaining({
+        type: "Literal",
+        value: "bar",
+      }),
+    );
+
+    expect(findClosestNodeAtPosition(parsed, { character: 23 })).toStrictEqual(
+      expect.objectContaining({
+        type: "Literal",
+        value: 12,
+      }),
+    );
+  });
+});

package/src/expressions/evaluator-functions.ts

@@ -1,17 +1,17 @@
-import type { Binding } from '@player-ui/types';
+import type { Binding } from "@player-ui/types";
 
-import type { BindingLike } from '../binding';
+import type { BindingLike } from "../binding";
 import type {
   ExpressionHandler,
   ExpressionContext,
   ExpressionNode,
-} from './types';
+} from "./types";
 
 /** Sets a value to the data-model */
 export const setDataVal: ExpressionHandler<[Binding, any], any> = (
   _context: ExpressionContext,
   binding,
-  value
+  value,
 ) => {
   _context.model.set([[binding as BindingLike, value]]);
 };
@@ -19,7 +19,7 @@ export const setDataVal: ExpressionHandler<[Binding, any], any> = (
 /** Fetches a valid from the data-model */
 export const getDataVal: ExpressionHandler<[Binding], unknown> = (
   _context: ExpressionContext,
-  binding
+  binding,
 ) => {
   return _context.model.get(binding as BindingLike);
 };
@@ -27,7 +27,7 @@ export const getDataVal: ExpressionHandler<[Binding], unknown> = (
 /** Deletes a value from the model */
 export const deleteDataVal: ExpressionHandler<[Binding], void> = (
   _context: ExpressionContext,
-  binding
+  binding,
 ) => {
   return _context.model.delete(binding);
 };