@player-tools/dsl 0.10.1 → 0.11.0--canary.212.4707

package/src/__tests__/util.test.tsx

@@ -1,12 +1,19 @@
 import { test, expect, describe } from "vitest";
-import { getObjectReferences } from "../utils";
+import {
+  getObjectReferences,
+  mapExpressionHandlersToFunctions,
+  wrapFunctionInType,
+} from "../utils";
+import { Binding, Expression, ExpressionHandler } from "@player-ui/player";
+import { binding, expression } from "../string-templates";
+import { LocalBazType } from "./helpers/mock-data-refs";
+import { DataTypeRefs } from "../types";
+import { makeBindingsForObject } from "../compiler/schema";
 
 describe("Testing the 'getObjectReferences' helper that creates same property references into a new object", () => {
   test("should return the object properties in referenced format", () => {
     const dataTypes = {
-      BooleanType: {
-        type: "BooleanType",
-      },
+      LocalBazType,
     };
 
     const validators = {
@@ -15,12 +22,182 @@ describe("Testing the 'getObjectReferences' helper that creates same property re
       },
     };
 
-    const dataReferences = getObjectReferences(dataTypes);
-    const validatorReferences = getObjectReferences(validators);
+    type DTREF = DataTypeRefs<typeof dataTypes>;
+
+    const dataReferences = getObjectReferences<typeof dataTypes, DTREF>(
+      dataTypes,
+    );
 
-    expect(dataReferences.BooleanTypeRef).toStrictEqual({
-      type: "BooleanType",
+    type VALREF = DataTypeRefs<typeof validators>;
+    const validatorReferences = getObjectReferences<typeof validators, VALREF>(
+      validators,
+    );
+
+    expect(dataReferences.LocalBazTypeRef).toStrictEqual({
+      type: "LocalBazType",
     });
     expect(validatorReferences.requiredRef).toStrictEqual({ type: "required" });
   });
 });
+
+describe("DSL Expression Generation Helper", () => {
+  test("Returns the correct serialization for bindings", () => {
+    const mockFunction: ExpressionHandler<[Binding], boolean> = (ctx, val) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`some.binding`;
+    const test = expression`${mockFunctionDSL(foo)} == true`;
+
+    expect(test.toValue()).toEqual("mockFunction('some.binding') == true");
+  });
+
+  test("Returns the correct serialization for mixed values and bindings", () => {
+    const mockFunction: ExpressionHandler<[string, string, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`some.binding`;
+    const test = expression`${mockFunctionDSL(foo.toRefString(), "test", 1)} == true`;
+
+    expect(test.toValue()).toEqual(
+      "mockFunction('{{some.binding}}', 'test', 1) == true",
+    );
+  });
+
+  test("Returns the correct serialization for array items", () => {
+    const mockFunction: ExpressionHandler<[Array<unknown>], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`some.binding`;
+    const test = expression`${mockFunctionDSL([1, "2", foo])}`;
+
+    expect(test.toValue()).toEqual(
+      "mockFunction([1, '2', '{{some.binding}}'])",
+    );
+  });
+
+  test("Can Dereferenced Binding", () => {
+    const mockFunction: ExpressionHandler<[boolean], boolean> = (ctx, val) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`some.binding`;
+    const test = expression`${mockFunctionDSL(foo.toRefString())} == true`;
+
+    expect(test.toValue()).toEqual("mockFunction('{{some.binding}}') == true");
+  });
+
+  test("Can Pass Nested Expressions", () => {
+    const mockFunction: ExpressionHandler<[Expression, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`foo.bar`;
+    const bar = expression`${foo} != 1`;
+    const test = expression`${mockFunctionDSL(bar, 1)}`;
+
+    expect(test.toValue()).toEqual("mockFunction('{{foo.bar}} != 1', 1)");
+  });
+
+  test("Export Generator", () => {
+    const mockFunction: ExpressionHandler<[string, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+    const expressionFunctions = { mockFunction };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(usableFunctions.mockFunction("1", 0).toValue()).toMatch(
+      "mockFunction('1', 0)",
+    );
+  });
+
+  test("Return Type Chaining", () => {
+    const mockFunction: ExpressionHandler<[string, number], string> = (
+      ctx,
+      val,
+    ) => {
+      return "false";
+    };
+
+    const mockFunction2: ExpressionHandler<[string], boolean> = (ctx, val) => {
+      return false;
+    };
+    const expressionFunctions = { mockFunction, mockFunction2 };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(
+      usableFunctions
+        .mockFunction2(usableFunctions.mockFunction("1", 0).toValue())
+        .toValue(),
+    ).toMatch("mockFunction2('mockFunction('1', 0)')");
+  });
+
+  test("Works with DSL Schema", () => {
+    const mockFunction: ExpressionHandler<[string, boolean], string> = (
+      ctx,
+      val,
+    ) => {
+      return "false";
+    };
+
+    const dataTypes = { LocalBazType };
+
+    type DTREF = DataTypeRefs<typeof dataTypes>;
+
+    const refableTypes = getObjectReferences<typeof dataTypes, DTREF>(
+      dataTypes,
+    );
+
+    const data = {
+      some: {
+        value: refableTypes.LocalBazTypeRef,
+      },
+    };
+
+    const schema = makeBindingsForObject(data);
+    const expressionFunctions = { mockFunction };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(
+      usableFunctions
+        .mockFunction("1", schema.some.value.toRefString())
+        .toValue(),
+    ).toMatch("mockFunction('1', '{{some.value}}')");
+  });
+});

package/src/compiler/schema.ts

@@ -8,7 +8,7 @@ import type { BindingTemplateInstance } from "../string-templates";
 const bindingSymbol = Symbol("binding");
 
 /** Symbol to indicate that a schema node should be generated with a different name */
-export const SchemaTypeName = Symbol("Schema Rename");
+export const SchemaTypeName: unique symbol = Symbol("Schema Rename");
 
 interface SchemaChildren {
   /** Object property that will be used to create the intermediate type */
@@ -47,7 +47,15 @@ export class SchemaGenerator {
   private generatedDataTypes: Map<string, GeneratedDataType>;
   private logger: LoggingInterface;
 
-  public hooks = {
+  public hooks: {
+    createSchemaNode: SyncWaterfallHook<
+      [
+        node: Schema.DataType<unknown>,
+        originalProperty: Record<string | symbol, unknown>,
+      ],
+      Record<string, any>
+    >;
+  } = {
     createSchemaNode: new SyncWaterfallHook<
       [
         node: Schema.DataType,
@@ -197,14 +205,14 @@ export type MakeBindingRefable<T> = {
     : T[P] extends unknown[]
       ? T[P]
       : MakeBindingRefable<T[P]>;
-} & BindingTemplateInstance;
+} & BindingTemplateInstance<T>;
 
 /**
  * Adds bindings to an object so that the object can be directly used in JSX
  */
 export function makeBindingsForObject<Type>(
   obj: Type,
-  arrayAccessorKeys = ["_index_"],
+  arrayAccessorKeys: string[] = ["_index_"],
 ): MakeBindingRefable<Type> {
   /** Proxy to track binding callbacks */
   const accessor = (paths: string[]) => {
@@ -258,7 +266,7 @@ export function makeBindingsForObject<Type>(
 /**
  * Generates binding for an object property
  */
-export const getBindingFromObject = (obj: any) => {
+export const getBindingFromObject = (obj: any): BindingTemplateInstance => {
   const baseBindings = obj[bindingSymbol] as string[];
   if (!Array.isArray(baseBindings) || baseBindings.length === 0) {
     throw new Error(`Unable to get binding for ${obj}`);
@@ -270,13 +278,13 @@ export const getBindingFromObject = (obj: any) => {
 /**
  * Returns the binding string from an object path
  */
-export const getBindingStringFromObject = (obj: any) => {
+export const getBindingStringFromObject = (obj: any): string => {
   return getBindingFromObject(obj).toString();
 };
 
 /**
  * Returns the ref string from an object path
  */
-export const getRefStringFromObject = (obj: any) => {
+export const getRefStringFromObject = (obj: any): string => {
   return getBindingFromObject(obj).toRefString();
 };

package/src/expressions/__tests__/native.test.tsx

@@ -0,0 +1,159 @@
+import { test, expect, describe } from "vitest";
+import {
+  and,
+  assign,
+  binding as b,
+  expression as e,
+  equals,
+  nand,
+  nor,
+  not,
+  or,
+} from "../../";
+
+describe("assign", () => {
+  test("string", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, "1").toValue()).toStrictEqual("{{foo.bar}} = '1'");
+  });
+  test("number", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, 1).toValue()).toStrictEqual("{{foo.bar}} = 1");
+  });
+  test("boolean", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, true).toValue()).toStrictEqual("{{foo.bar}} = true");
+  });
+  test("undefined", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, undefined).toValue()).toStrictEqual(
+      "{{foo.bar}} = null",
+    );
+  });
+});
+
+describe("not", () => {
+  test("binding", () => {
+    const binding = b<boolean>`foo.bar`;
+    expect(not(binding).toValue()).toStrictEqual("!({{foo.bar}})");
+  });
+  test("expression", () => {
+    const expression = e<boolean>`${b`foo.bar`} = true`;
+
+    expect(not(expression).toValue()).toStrictEqual("!({{foo.bar}} = true)");
+  });
+});
+
+describe("and", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(and(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} && {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(and(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) && ({{foo.baz}} == '1')",
+    );
+  });
+});
+
+describe("or", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(or(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} || {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(or(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) || ({{foo.baz}} == '1')",
+    );
+  });
+});
+
+describe("nand", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(nand(binding, binding2).toValue()).toStrictEqual(
+      "!({{foo.bar}} && {{foo.baz}})",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(nand(expression, expression2).toValue()).toStrictEqual(
+      "!(({{foo.bar}} == true) && ({{foo.baz}} == '1'))",
+    );
+  });
+});
+
+describe("nor", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(nor(binding, binding2).toValue()).toStrictEqual(
+      "!({{foo.bar}} || {{foo.baz}})",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(nor(expression, expression2).toValue()).toStrictEqual(
+      "!(({{foo.bar}} == true) || ({{foo.baz}} == '1'))",
+    );
+  });
+});
+
+describe("equals", () => {
+  test("binding-string", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, "1").toValue()).toStrictEqual("{{foo.bar}} == '1'");
+  });
+
+  test("binding-number", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, 1).toValue()).toStrictEqual("{{foo.bar}} == 1");
+  });
+
+  test("binding-boolean", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, true).toValue()).toStrictEqual(
+      "{{foo.bar}} == true",
+    );
+  });
+
+  test("binding-undefined", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, undefined).toValue()).toStrictEqual(
+      "{{foo.bar}} == null",
+    );
+  });
+
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(equals(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} == {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(equals(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) == ({{foo.baz}} == '1')",
+    );
+  });
+});

package/src/expressions/native.ts

@@ -0,0 +1,141 @@
+import {
+  expression as e,
+  BindingTemplateInstance,
+  ExpressionTemplateInstance,
+  isTemplateStringInstance,
+  isBindingTemplateInstance,
+} from "..";
+
+type Argument<T> =
+  | string
+  | boolean
+  | number
+  | undefined
+  | BindingTemplateInstance<T>
+  | ExpressionTemplateInstance<T>;
+
+const escapePrimitive = <T>(
+  val: Exclude<
+    Argument<T>,
+    BindingTemplateInstance<T> | ExpressionTemplateInstance<T>
+  >,
+): string => {
+  switch (typeof val) {
+    case "string": {
+      return `'${val}'`;
+    }
+    case "undefined": {
+      return "null";
+    }
+    default: {
+      return `${val}`;
+    }
+  }
+};
+
+const handleBindingOrExpression = (
+  val: BindingTemplateInstance | ExpressionTemplateInstance,
+) => {
+  if (isBindingTemplateInstance(val)) {
+    return val.toRefString();
+  } else {
+    return `(${val.toValue()})`;
+  }
+};
+
+const handleArgument = <T>(arg: Argument<T>): string => {
+  return isTemplateStringInstance(arg)
+    ? handleBindingOrExpression(arg)
+    : escapePrimitive(arg);
+};
+
+/**
+ * Performs an assigment of a value to a binding by returning the expression
+ * {{<binding>}} = <value>
+ * @param binding
+ * @param value
+ */
+export const assign = <T>(
+  binding: BindingTemplateInstance<any>,
+  value: Argument<T>,
+): ExpressionTemplateInstance<void> => {
+  return e`${binding} = ${isTemplateStringInstance(value) ? value : escapePrimitive(value)}`;
+};
+
+/**
+ * Returns an equality comparison between the two values
+ */
+export const equals = <A, B>(
+  a: Argument<A>,
+  b: Argument<B>,
+): ExpressionTemplateInstance<boolean> => {
+  return e`${handleArgument(a)} == ${handleArgument(b)}`;
+};
+
+/**
+ * Returns the negated version of the binding/expression
+ * by returning !(<value>)
+ * @param binding Binding/Expression to invert
+ * @returns Negated binding/expression
+ */
+export const not = (
+  value: BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>,
+): ExpressionTemplateInstance<boolean> => {
+  return e<boolean>`!(${value})`;
+};
+
+/**
+ * Creates an expression for the logical or'ing of the provided values
+ * e.g: <exp1> || <exp2> || ...
+ * @param values Array of bindings/expressions to logically or
+ * @returns boolean
+ */
+export const or = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return e`${values.map(handleBindingOrExpression).join(" || ")}` as ExpressionTemplateInstance<boolean>;
+};
+
+/**
+ * Creates an expression for the logical nor'ing of the provided values
+ * e.g: !(<exp1> || <exp2> || ...)
+ * @param values Array of bindings/expressions to logically nor
+ * @returns boolean
+ */
+export const nor = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return not(or(...values));
+};
+
+/**
+ * Creates an expression for the logical and'ing of the provided values
+ * e.g: <exp1> && <exp2> && ...
+ * @param values Array of bindings/expressions to logically and
+ * @returns boolean
+ */
+export const and = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return e`${values.map(handleBindingOrExpression).join(" && ")}` as ExpressionTemplateInstance<boolean>;
+};
+
+/**
+ * Creates an expression for the logical nand'ing of the provided values
+ * e.g: !(<exp1> && <exp2> && ...)
+ * @param values Array of bindings/expressions to logically nand
+ * @returns boolean
+ */
+export const nand = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return not(and(...values));
+};

package/src/index.ts

@@ -9,3 +9,4 @@ export * from "react-json-reconciler";
 export * from "./compiler/schema";
 export * from "./compiler";
 export * from "./compiler/types";
+export * from "./expressions/native";

package/src/string-templates/index.ts

@@ -22,9 +22,11 @@ export interface TemplateInstanceRefStringOptions {
   ) => string;
 }
 
-const OpaqueIdentifier = Symbol("TemplateStringType");
+const OpaqueIdentifier: unique symbol = Symbol("TemplateStringType");
 
-export type TemplateStringType = React.ReactElement & {
+export type TemplateStringType<
+  T extends string | number | boolean | unknown = any,
+> = React.ReactElement & {
   /** An identifier to show that this is a template type */
   [OpaqueIdentifier]: true;
   /** The value of the template string when in another string */
@@ -32,15 +34,21 @@ export type TemplateStringType = React.ReactElement & {
   /** the raw value of the template string */
   toValue: () => string;
   /** the dereferenced value when used in another */
-  toRefString: (options?: TemplateRefStringOptions) => string;
+  toRefString: (options?: TemplateRefStringOptions) => T;
+  /** Underlying type of this binding */
+  type: T;
 };
 
-export type BindingTemplateInstance = TemplateStringType & {
+export type BindingTemplateInstance<
+  DataType extends string | number | boolean | unknown = any,
+> = TemplateStringType<DataType> & {
   /** An identifier for a binding instance */
   __type: "binding";
 };
 
-export type ExpressionTemplateInstance = TemplateStringType & {
+export type ExpressionTemplateInstance<
+  ReturnType extends string | number | boolean | unknown = any,
+> = TemplateStringType<ReturnType> & {
   /** The identifier for an expression instance */
   __type: "expression";
 };
@@ -49,7 +57,9 @@ export type ExpressionTemplateInstance = TemplateStringType & {
 export const TemplateStringComponent = (props: {
   /** The string value of the child template string */
   value: string;
-}) => {
+}): React.ReactElement<{
+  value: string;
+}> => {
   return React.createElement(
     "value",
     {
@@ -179,10 +189,10 @@ const createExpressionTemplateInstance = (
 };
 
 /** A tagged-template constructor for a binding  */
-export const binding = (
+export const binding = <T>(
   strings: TemplateStringsArray,
   ...nested: Array<TemplateStringType | string>
-): BindingTemplateInstance => {
+): BindingTemplateInstance<T> => {
   return createBindingTemplateInstance({
     strings,
     other: nested,
@@ -191,12 +201,12 @@ export const binding = (
 };
 
 /** A tagged-template constructor for an expression */
-export const expression = (
+export const expression = <T>(
   strings: TemplateStringsArray,
   ...nested: Array<
     ExpressionTemplateInstance | BindingTemplateInstance | string
   >
-): ExpressionTemplateInstance => {
+): ExpressionTemplateInstance<T> => {
   return createExpressionTemplateInstance({
     strings,
     other: nested,