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

package/src/schema/schema.ts

@@ -1,16 +1,16 @@
-import { SyncWaterfallHook } from 'tapable-ts';
-import type { Schema as SchemaType, Formatting } from '@player-ui/types';
+import { SyncWaterfallHook } from "tapable-ts";
+import type { Schema as SchemaType, Formatting } from "@player-ui/types";
 
-import type { BindingInstance } from '../binding';
-import type { ValidationProvider, ValidationObject } from '../validator';
-import type { FormatDefinition, FormatOptions, FormatType } from './types';
+import type { BindingInstance } from "../binding";
+import type { ValidationProvider, ValidationObject } from "../validator";
+import type { FormatDefinition, FormatOptions, FormatType } from "./types";
 
 /** A function that returns itself */
 const identify = (val: any) => val;
 
 /** Expand the authored schema into a set of paths -> DataTypes */
 export function parse(
-  schema: SchemaType.Schema
+  schema: SchemaType.Schema,
 ): Map<string, SchemaType.DataTypes> {
   const expandedPaths = new Map<string, SchemaType.DataTypes>();
 
@@ -41,29 +41,29 @@ export function parse(
     Object.entries(node).forEach(([prop, type]) => {
       const nestedPath = [...path, prop];
 
-      const nestedPathStr = nestedPath.join('.');
+      const nestedPathStr = nestedPath.join(".");
 
       if (expandedPaths.has(nestedPathStr)) {
         // We've gone in a loop. Panic
         throw new Error(
-          "Path has already been processed. There's either a loop somewhere or a bug"
+          "Path has already been processed. There's either a loop somewhere or a bug",
         );
       }
 
       if (visited.has(type.type)) {
         throw new Error(
-          `Path already contained type: ${type.type}. This likely indicates a loop in the schema`
+          `Path already contained type: ${type.type}. This likely indicates a loop in the schema`,
         );
       }
 
       expandedPaths.set(nestedPathStr, type);
 
       if (type.isArray) {
-        nestedPath.push('[]');
+        nestedPath.push("[]");
       }
 
       if (type.isRecord) {
-        nestedPath.push('{}');
+        nestedPath.push("{}");
       }
 
       if (type.type && schema[type.type]) {
@@ -117,7 +117,7 @@ export class SchemaController implements ValidationProvider {
   }
 
   getValidationsForBinding(
-    binding: BindingInstance
+    binding: BindingInstance,
   ): Array<ValidationObject> | undefined {
     const typeDef = this.getApparentType(binding);
 
@@ -127,8 +127,8 @@ export class SchemaController implements ValidationProvider {
 
     // Set the defaults for schema-level validations
     return typeDef.validation.map((vRef) => ({
-      severity: 'error',
-      trigger: 'change',
+      severity: "error",
+      trigger: "change",
       ...vRef,
     }));
   }
@@ -141,22 +141,22 @@ export class SchemaController implements ValidationProvider {
 
     let bindingArray = binding.asArray();
     let normalized = bindingArray
-      .map((p) => (typeof p === 'number' ? '[]' : p))
-      .join('.');
+      .map((p) => (typeof p === "number" ? "[]" : p))
+      .join(".");
 
     if (normalized) {
       this.bindingSchemaNormalizedCache.set(binding, normalized);
-      bindingArray = normalized.split('.');
+      bindingArray = normalized.split(".");
     }
 
     bindingArray.forEach((item) => {
       const recordBinding = bindingArray
-        .map((p) => (p === item ? '{}' : p))
-        .join('.');
+        .map((p) => (p === item ? "{}" : p))
+        .join(".");
 
       if (this.schema.get(recordBinding)) {
         this.bindingSchemaNormalizedCache.set(binding, recordBinding);
-        bindingArray = recordBinding.split('.');
+        bindingArray = recordBinding.split(".");
         normalized = recordBinding;
       }
     });
@@ -167,12 +167,12 @@ export class SchemaController implements ValidationProvider {
   public getType(binding: BindingInstance): SchemaType.DataTypes | undefined {
     return this.hooks.resolveTypeForBinding.call(
       this.schema.get(this.normalizeBinding(binding)),
-      binding
+      binding,
     );
   }
 
   public getApparentType(
-    binding: BindingInstance
+    binding: BindingInstance,
   ): SchemaType.DataTypes | undefined {
     const schemaType = this.getType(binding);
 
@@ -201,7 +201,7 @@ export class SchemaController implements ValidationProvider {
   }
 
   public getFormatterForType(
-    formatReference: Formatting.Reference
+    formatReference: Formatting.Reference,
   ): FormatDefinition<unknown, unknown> | undefined {
     const { type: formatType, ...options } = formatReference;
 
@@ -226,7 +226,7 @@ export class SchemaController implements ValidationProvider {
    * If no formatter is registered, it will return undefined
    */
   public getFormatter(
-    binding: BindingInstance
+    binding: BindingInstance,
   ): FormatDefinition<unknown, unknown> | undefined {
     const type = this.getApparentType(binding);
 

package/src/schema/types.ts

@@ -1,6 +1,6 @@
-import type { Formatting } from '@player-ui/types';
+import type { Formatting } from "@player-ui/types";
 
-export type FormatOptions = Omit<Formatting.Reference, 'type'>;
+export type FormatOptions = Omit<Formatting.Reference, "type">;
 
 /**
  * The return types for the schema don't include options.
@@ -8,7 +8,7 @@ export type FormatOptions = Omit<Formatting.Reference, 'type'>;
  */
 export type FormatFunction<From, To = From, Options = unknown> = (
   val: From,
-  options?: Options
+  options?: Options,
 ) => To | undefined;
 
 export type FormatHandler<From, To = From> = (val: From) => To;
@@ -30,7 +30,7 @@ export interface FormatDefinition<DataModelType, UserDisplayType> {
 export interface FormatType<
   DataModelType,
   UserDisplayType = DataModelType,
-  Options = undefined
+  Options = undefined,
 > {
   /**
    * The name of the formatter.

package/src/string-resolver/__tests__/index.test.ts

@@ -0,0 +1,361 @@
+import { test, expect, describe } from "vitest";
+import type { Expression } from "@player-ui/types";
+import { Player, PlayerPlugin } from "../../player";
+import type { InProgressState } from "../../types";
+import { BindingParser } from "../../binding";
+import { LocalModel, withParser } from "../../data";
+import { resolveDataRefs, resolveExpressionsInString } from "..";
+
+class PhoneFormatterPlugin implements PlayerPlugin {
+  name = "phone-formatter";
+  apply(player: Player) {
+    player.hooks.schema.tap(this.name, (schema) => {
+      schema.addDataTypes([
+        {
+          type: "PhoneType",
+          format: {
+            type: "phone",
+          },
+        },
+      ]);
+
+      schema.addFormatters([
+        {
+          name: "phone",
+          format: (value) => {
+            return value.replace(/(\d{3})(\d{3})(\d{4})/, "$1-$2-$3");
+          },
+          deformat: (value) => {
+            return value.replace(/-/g, "");
+          },
+        },
+      ]);
+    });
+  }
+}
+
+test("works on basic data", () => {
+  const localModel = new LocalModel({
+    adam: {
+      age: 26,
+    },
+    index: 1,
+    person: {
+      first: "adam",
+      last: "dierkens",
+    },
+    name: "{{person.first}} {{person.last}}",
+    pets: [
+      {
+        name: "frodo",
+        type: "cat",
+      },
+      {
+        name: "ginger",
+        type: "dog",
+      },
+    ],
+  });
+
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: () => undefined,
+  });
+
+  const model = withParser(localModel, bindingParser.parse);
+
+  const options = {
+    model,
+    evaluate: (exp: Expression) => exp,
+  };
+
+  expect(
+    resolveDataRefs("Adam is {{adam.age}} years old", options),
+  ).toStrictEqual("Adam is 26 years old");
+
+  expect(
+    resolveDataRefs("My name is {{person.first}} {{person.last}}", options),
+  ).toStrictEqual("My name is adam dierkens");
+
+  expect(resolveDataRefs("My name is {{name}}", options)).toStrictEqual(
+    "My name is adam dierkens",
+  );
+
+  expect(resolveDataRefs("{{name}}", options)).toStrictEqual("adam dierkens");
+
+  expect(
+    resolveDataRefs('My cat is named {{pets[type="cat"].name}}', options),
+  ).toStrictEqual("My cat is named frodo");
+
+  expect(
+    resolveDataRefs("Name: {{pets.{{index}}.name}}", options),
+  ).toStrictEqual("Name: ginger");
+});
+
+test("replaces data w/ raw value if only data ref", () => {
+  const localModel = new LocalModel({ foo: 100 });
+
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: () => undefined,
+  });
+
+  const model = withParser(localModel, bindingParser.parse);
+
+  expect(
+    resolveDataRefs("{{foo}}", {
+      model,
+      evaluate: (exp) => exp,
+    }),
+  ).toStrictEqual(100);
+});
+
+test("works on objects and arrays", () => {
+  const localModel = new LocalModel({
+    adam: {
+      age: 26,
+    },
+    person: {
+      first: "adam",
+      last: "dierkens",
+    },
+    pets: [
+      {
+        name: "frodo",
+        type: "cat",
+      },
+      {
+        name: "ginger",
+        type: "dog",
+      },
+    ],
+  });
+
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: () => undefined,
+  });
+
+  const model = withParser(localModel, bindingParser.parse.bind(bindingParser));
+
+  expect(
+    resolveDataRefs(
+      [
+        "I have a {{pets.0.type}} named {{pets.0.name}}",
+        "I have a {{pets.1.type}} named {{pets.1.name}}",
+      ],
+      {
+        model,
+        evaluate: (exp) => exp,
+      },
+    ),
+  ).toStrictEqual(["I have a cat named frodo", "I have a dog named ginger"]);
+});
+
+test("handles undefined object", () => {
+  const localModel = new LocalModel({
+    adam: {
+      age: 26,
+    },
+    person: {
+      first: "adam",
+      last: "dierkens",
+    },
+    pets: [
+      {
+        name: "frodo",
+        type: "cat",
+      },
+      {
+        name: "ginger",
+        type: "dog",
+      },
+    ],
+  });
+
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: () => undefined,
+  });
+
+  const model = withParser(localModel, bindingParser.parse.bind(bindingParser));
+
+  expect(
+    resolveDataRefs(null, {
+      model,
+      evaluate: (exp) => exp,
+    }),
+  ).toBeNull();
+});
+
+test("resolves expressions", () => {
+  const localModel = new LocalModel({
+    adam: {
+      age: 26,
+    },
+    index: 1,
+    person: {
+      first: "adam",
+      last: "dierkens",
+    },
+    pets: [
+      {
+        name: "frodo",
+        type: "cat",
+      },
+      {
+        name: "ginger",
+        type: "dog",
+      },
+    ],
+  });
+
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: () => undefined,
+  });
+
+  const model = withParser(localModel, bindingParser.parse);
+
+  const options = {
+    model,
+    evaluate: (exp: Expression) => {
+      if (exp === '{{person.first}} + " " + {{person.last}}') {
+        return "adam dierkens";
+      }
+
+      if (exp === "{{adam.age}} + 10") {
+        return 36;
+      }
+    },
+  };
+
+  expect(
+    resolveExpressionsInString(
+      'Hello @[{{person.first}} + " " + {{person.last}}]@',
+      options,
+    ),
+  ).toBe("Hello adam dierkens");
+
+  expect(resolveDataRefs("@[{{adam.age}} + 10]@", options)).toBe(36);
+});
+
+describe("Returns unformatted values for requests", () => {
+  const player = new Player({ plugins: [new PhoneFormatterPlugin()] });
+
+  const endStateFlow = {
+    id: "minimal-player-response-format",
+    topic: "MOCK",
+    schema: {
+      ROOT: {
+        phoneNumber: {
+          type: "PhoneType",
+          default: "false",
+        },
+      },
+    },
+    data: {
+      phoneNumber: "1234567890",
+    },
+    views: [
+      {
+        actions: [
+          {
+            asset: {
+              id: "action-1",
+              type: "action",
+              value: "Next",
+              label: {
+                asset: {
+                  id: "Action-Label-Next",
+                  type: "text",
+                  value: "Continue",
+                },
+              },
+            },
+          },
+        ],
+        id: "KitchenSink-View1",
+        title: {
+          asset: {
+            id: "KitchenSink-View1-Title",
+            type: "text",
+            value: "{{phoneNumber}}",
+          },
+        },
+        type: "questionAnswer",
+      },
+    ],
+    navigation: {
+      BEGIN: "KitchenSinkFlow",
+      KitchenSinkFlow: {
+        END_Done: {
+          outcome: "{{phoneNumber}}",
+          state_type: "END",
+        },
+        VIEW_KitchenSink_1: {
+          ref: "KitchenSink-View1",
+          state_type: "VIEW",
+          transitions: {
+            param: "END_invokeWithParam",
+            "*": "END_Done",
+          },
+        },
+        END_invokeWithParam: {
+          state_type: "END",
+          outcome: "{{phoneNumber}}",
+          param: {
+            type: "someTopic",
+            topicId: "someTopicId",
+            navData: {
+              topic: "someTopic",
+              op: "EDIT",
+              param: {
+                phone: "{{phoneNumber}}",
+              },
+            },
+          },
+        },
+        startState: "VIEW_KitchenSink_1",
+      },
+    },
+  };
+
+  test("unformatted endState", async () => {
+    player.start(endStateFlow as any);
+
+    const state = player.getState() as InProgressState;
+
+    state.controllers.flow.transition("foo");
+
+    const { flowResult } = state;
+
+    const result = await flowResult;
+
+    expect(result.endState).toStrictEqual({
+      outcome: "1234567890",
+      state_type: "END",
+    });
+  });
+
+  test('unformatted "param"', async () => {
+    player.start(endStateFlow as any);
+
+    const state = player.getState() as InProgressState;
+
+    state.controllers.flow.transition("param");
+
+    const { flowResult } = state;
+
+    const result = await flowResult;
+
+    const param = result.endState.param as any;
+
+    expect(param.navData.param.phone).toBe("1234567890");
+  });
+});

package/src/string-resolver/index.ts

@@ -1,9 +1,9 @@
-import { setIn } from 'timm';
-import type { Expression } from '@player-ui/types';
-import type { DataModelWithParser } from '../data';
+import { setIn } from "timm";
+import type { Expression } from "@player-ui/types";
+import type { DataModelWithParser } from "../data";
 
-const DOUBLE_OPEN_CURLY = '{{';
-const DOUBLE_CLOSE_CURLY = '}}';
+const DOUBLE_OPEN_CURLY = "{{";
+const DOUBLE_CLOSE_CURLY = "}}";
 
 export interface Options {
   /**
@@ -52,7 +52,7 @@ export function findNextExp(str: string) {
       // Move everything over and bump our close count by 1
       count++;
       workingString = workingString.substring(
-        nextOpenCurly + DOUBLE_OPEN_CURLY.length
+        nextOpenCurly + DOUBLE_OPEN_CURLY.length,
       );
       offset += nextOpenCurly + DOUBLE_OPEN_CURLY.length;
     } else {
@@ -60,7 +60,7 @@ export function findNextExp(str: string) {
       // Decrement our count and updates offsets
       count--;
       workingString = workingString.substring(
-        nextCloseCurly + DOUBLE_CLOSE_CURLY.length
+        nextCloseCurly + DOUBLE_CLOSE_CURLY.length,
       );
       offset += nextCloseCurly + DOUBLE_CLOSE_CURLY.length;
     }
@@ -79,7 +79,7 @@ export function findNextExp(str: string) {
 /** Finds any subset of the string wrapped in @[]@ and evaluates it as an expression */
 export function resolveExpressionsInString(
   val: string,
-  { evaluate }: Options
+  { evaluate }: Options,
 ): string {
   if (!evaluate) {
     return val;
@@ -94,8 +94,8 @@ export function resolveExpressionsInString(
     const matchStart = newVal.indexOf(expStrWithBrackets);
 
     const expString = expStrWithBrackets.substr(
-      '@['.length,
-      expStrWithBrackets.length - '@['.length - ']@'.length
+      "@[".length,
+      expStrWithBrackets.length - "@[".length - "]@".length,
     );
     const expValue = evaluate(expString);
 
@@ -103,7 +103,7 @@ export function resolveExpressionsInString(
     if (
       matchStart === 0 &&
       expStrWithBrackets === val &&
-      typeof expValue !== 'string'
+      typeof expValue !== "string"
     ) {
       return expValue;
     }
@@ -126,7 +126,7 @@ export function resolveDataRefsInString(val: string, options: Options): string {
 
   if (
     !model ||
-    typeof workingString !== 'string' ||
+    typeof workingString !== "string" ||
     workingString.indexOf(DOUBLE_OPEN_CURLY) === -1
   ) {
     return workingString;
@@ -145,7 +145,7 @@ export function resolveDataRefsInString(val: string, options: Options): string {
     const binding = workingString
       .substring(
         start + DOUBLE_OPEN_CURLY.length,
-        end - DOUBLE_OPEN_CURLY.length
+        end - DOUBLE_OPEN_CURLY.length,
       )
       .trim();
 
@@ -156,7 +156,7 @@ export function resolveDataRefsInString(val: string, options: Options): string {
     if (
       start === 0 &&
       end === workingString.length &&
-      typeof evaledVal !== 'string'
+      typeof evaledVal !== "string"
     ) {
       return evaledVal;
     }
@@ -171,11 +171,11 @@ export function resolveDataRefsInString(val: string, options: Options): string {
 /** Traverse the thing and replace any model refs */
 function traverseObject<T>(val: T, options: Options): T {
   switch (typeof val) {
-    case 'string': {
+    case "string": {
       return resolveDataRefsInString(val as string, options) as unknown as T;
     }
 
-    case 'object': {
+    case "object": {
       if (!val) return val;
       // TODO: Do we care refs in keys?
       const keys = Object.keys(val);
@@ -186,7 +186,7 @@ function traverseObject<T>(val: T, options: Options): T {
           newVal = setIn(
             newVal as any,
             [key],
-            traverseObject((val as any)[key], options)
+            traverseObject((val as any)[key], options),
           ) as any;
         });
       }