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

package/src/player.ts

@@ -1,37 +1,38 @@
-import { setIn } from 'timm';
-import deferred from 'p-defer';
-import type { Flow as FlowType, FlowResult } from '@player-ui/types';
-
-import { SyncHook, SyncWaterfallHook } from 'tapable-ts';
-import type { Logger } from './logger';
-import { TapableLogger } from './logger';
-import type { ExpressionType } from './expressions';
-import { ExpressionEvaluator } from './expressions';
-import { SchemaController } from './schema';
-import { BindingParser } from './binding';
-import type { ViewInstance } from './view';
-import { resolveDataRefs } from './string-resolver';
-import type { FlowInstance } from './controllers';
+import { setIn } from "timm";
+import deferred from "p-defer";
+import type { Flow as FlowType, FlowResult } from "@player-ui/types";
+
+import { SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { Logger } from "./logger";
+import { TapableLogger } from "./logger";
+import type { ExpressionType } from "./expressions";
+import { ExpressionEvaluator } from "./expressions";
+import { SchemaController } from "./schema";
+import { BindingParser } from "./binding";
+import type { ViewInstance } from "./view";
+import { resolveDataRefs } from "./string-resolver";
+import type { FlowInstance } from "./controllers";
 import {
   ConstantsController,
   ViewController,
   DataController,
   ValidationController,
   FlowController,
-} from './controllers';
-import { FlowExpPlugin } from './plugins/flow-exp-plugin';
-import { DefaultExpPlugin } from './plugins/default-exp-plugin';
+} from "./controllers";
+import { FlowExpPlugin } from "./plugins/flow-exp-plugin";
+import { DefaultExpPlugin } from "./plugins/default-exp-plugin";
 import type {
   PlayerFlowState,
   InProgressState,
   CompletedState,
   ErrorState,
-} from './types';
-import { NOT_STARTED_STATE } from './types';
+} from "./types";
+import { NOT_STARTED_STATE } from "./types";
+import { DefaultViewPlugin } from "./plugins/default-view-plugin";
 
 // Variables injected at build time
-const PLAYER_VERSION = '0.8.0--canary.307.9621';
-const COMMIT = '2f21b7b894c885ccfed826751ba96a0638e3d8d8';
+const PLAYER_VERSION = "__VERSION__";
+const COMMIT = "__GIT_COMMIT__";
 
 export interface PlayerPlugin {
   /**
@@ -58,7 +59,7 @@ export interface ExtendedPlayerPlugin<
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   Expressions = void,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  DataTypes = void
+  DataTypes = void,
 > {}
 
 export interface PlayerConfigOptions {
@@ -136,6 +137,7 @@ export class Player {
     this.config = config || {};
     this.config.plugins = [
       new DefaultExpPlugin(),
+      new DefaultViewPlugin(),
       ...(this.config.plugins || []),
       new FlowExpPlugin(),
     ];
@@ -151,7 +153,7 @@ export class Player {
 
   /** Find instance of [Plugin] that has been registered to Player */
   public findPlugin<Plugin extends PlayerPlugin>(
-    symbol: symbol
+    symbol: symbol,
   ): Plugin | undefined {
     return this.config.plugins?.find((el) => el.symbol === symbol) as Plugin;
   }
@@ -159,7 +161,7 @@ export class Player {
   /** Retrieve an instance of [Plugin] and conditionally invoke [apply] if it exists */
   public applyTo<Plugin extends PlayerPlugin>(
     symbol: symbol,
-    apply: (plugin: Plugin) => void
+    apply: (plugin: Plugin) => void,
   ): void {
     const plugin = this.findPlugin<Plugin>(symbol);
 
@@ -208,7 +210,7 @@ export class Player {
     start: () => void;
 
     /** the state object to kick if off */
-    state: Omit<InProgressState, 'ref'>;
+    state: Omit<InProgressState, "ref">;
   } {
     const userFlow = this.hooks.resolveFlowContent.call(userContent);
 
@@ -254,21 +256,21 @@ export class Player {
       logger: this.logger,
     });
 
-    dataController.hooks.format.tap('player', (value, binding) => {
+    dataController.hooks.format.tap("player", (value, binding) => {
       const formatter = schema.getFormatter(binding);
 
       return formatter ? formatter.format(value) : value;
     });
 
-    dataController.hooks.deformat.tap('player', (value, binding) => {
+    dataController.hooks.deformat.tap("player", (value, binding) => {
       const formatter = schema.getFormatter(binding);
 
       return formatter ? formatter.deformat(value) : value;
     });
 
     dataController.hooks.resolveDefaultValue.tap(
-      'player',
-      (binding) => schema.getApparentType(binding)?.default
+      "player",
+      (binding) => schema.getApparentType(binding)?.default,
     );
 
     // eslint-disable-next-line prefer-const
@@ -281,7 +283,7 @@ export class Player {
 
     this.hooks.expressionEvaluator.call(expressionEvaluator);
 
-    expressionEvaluator.hooks.onError.tap('player', (e) => {
+    expressionEvaluator.hooks.onError.tap("player", (e) => {
       flowResultDeferred.reject(e);
 
       return true;
@@ -296,14 +298,14 @@ export class Player {
       });
     }
 
-    flowController.hooks.flow.tap('player', (flow: FlowInstance) => {
-      flow.hooks.beforeTransition.tap('player', (state, transitionVal) => {
+    flowController.hooks.flow.tap("player", (flow: FlowInstance) => {
+      flow.hooks.beforeTransition.tap("player", (state, transitionVal) => {
         /** Checks to see if there are any transitions for a specific transition state (i.e. next, back). If not, it will default to * */
         const computedTransitionVal = state.transitions[transitionVal]
           ? transitionVal
-          : '*';
+          : "*";
         if (state.onEnd && state.transitions[computedTransitionVal]) {
-          if (typeof state.onEnd === 'object' && 'exp' in state.onEnd) {
+          if (typeof state.onEnd === "object" && "exp" in state.onEnd) {
             expressionEvaluator?.evaluate(state.onEnd.exp);
           } else {
             expressionEvaluator?.evaluate(state.onEnd as ExpressionType);
@@ -312,7 +314,7 @@ export class Player {
 
         /** If the transition does not exist, then do not resolve any expressions */
         if (
-          !('transitions' in state) ||
+          !("transitions" in state) ||
           !state.transitions[computedTransitionVal]
         ) {
           return state;
@@ -321,15 +323,15 @@ export class Player {
         /** resolves and sets the transition to the computed exp */
         return setIn(
           state,
-          ['transitions', computedTransitionVal],
-          resolveStrings(state.transitions[computedTransitionVal])
+          ["transitions", computedTransitionVal],
+          resolveStrings(state.transitions[computedTransitionVal]),
         ) as any;
       });
 
-      flow.hooks.skipTransition.tap('validation', (currentState) => {
-        if (currentState?.value.state_type === 'VIEW') {
+      flow.hooks.skipTransition.tap("validation", (currentState) => {
+        if (currentState?.value.state_type === "VIEW") {
           const { canTransition, validations } =
-            validationController.validateView('navigation');
+            validationController.validateView("navigation");
 
           if (!canTransition && validations) {
             const bindings = new Set(validations.keys());
@@ -342,36 +344,36 @@ export class Player {
         return undefined;
       });
 
-      flow.hooks.resolveTransitionNode.tap('player', (state) => {
+      flow.hooks.resolveTransitionNode.tap("player", (state) => {
         let newState = state;
 
-        if ('ref' in state) {
-          newState = setIn(state, ['ref'], resolveStrings(state.ref)) as any;
+        if ("ref" in state) {
+          newState = setIn(state, ["ref"], resolveStrings(state.ref)) as any;
         }
 
-        if ('param' in state) {
+        if ("param" in state) {
           newState = setIn(
             state,
-            ['param'],
-            resolveStrings(state.param, false)
+            ["param"],
+            resolveStrings(state.param, false),
           ) as any;
         }
 
         return newState;
       });
 
-      flow.hooks.transition.tap('player', (_oldState, newState) => {
-        if (newState.value.state_type !== 'VIEW') {
+      flow.hooks.transition.tap("player", (_oldState, newState) => {
+        if (newState.value.state_type !== "VIEW") {
           validationController.reset();
         }
       });
 
-      flow.hooks.afterTransition.tap('player', (flowInstance) => {
+      flow.hooks.afterTransition.tap("player", (flowInstance) => {
         const value = flowInstance.currentState?.value;
-        if (value && value.state_type === 'ACTION') {
+        if (value && value.state_type === "ACTION") {
           const { exp } = value;
           flowController?.transition(
-            String(expressionEvaluator?.evaluate(exp))
+            String(expressionEvaluator?.evaluate(exp)),
           );
         }
 
@@ -418,7 +420,7 @@ export class Player {
       },
       constants: this.constantsController,
     });
-    viewController.hooks.view.tap('player', (view) => {
+    viewController.hooks.view.tap("player", (view) => {
       validationController.onView(view);
       this.hooks.view.call(view);
     });
@@ -445,7 +447,7 @@ export class Player {
           .finally(() => this.hooks.onEnd.call());
       },
       state: {
-        status: 'in-progress',
+        status: "in-progress",
         flowResult: flowResultDeferred.promise,
         controllers: {
           data: dataController,
@@ -464,13 +466,13 @@ export class Player {
   }
 
   public async start(payload: FlowType): Promise<CompletedState> {
-    const ref = Symbol(payload?.id ?? 'payload');
+    const ref = Symbol(payload?.id ?? "payload");
 
     /** A check to avoid updating the state for a flow that's not the current one */
     const maybeUpdateState = <T extends PlayerFlowState>(newState: T) => {
       if (this.state.ref !== ref) {
         this.logger.warn(
-          `Received update for a flow that's not the current one`
+          `Received update for a flow that's not the current one`,
         );
 
         return newState;
@@ -482,7 +484,7 @@ export class Player {
     };
 
     this.setState({
-      status: 'not-started',
+      status: "not-started",
       ref,
     });
 
@@ -499,7 +501,7 @@ export class Player {
       // make sure to use the same ref as the starting one
       const endProps = {
         ref,
-        status: 'completed',
+        status: "completed",
         flow: state.flow,
         controllers: {
           data: state.controllers.data.makeReadOnly(),
@@ -512,7 +514,7 @@ export class Player {
       });
     } catch (error: any) {
       const errorState: ErrorState = {
-        status: 'error',
+        status: "error",
         ref,
         flow: payload,
         error,

package/src/plugins/default-exp-plugin.ts

@@ -1,6 +1,6 @@
-import type { ExpressionHandler, ExpressionType } from '../expressions';
-import type { SchemaController } from '../schema';
-import type { Player, PlayerPlugin } from '../player';
+import type { ExpressionHandler, ExpressionType } from "../expressions";
+import type { SchemaController } from "../schema";
+import type { Player, PlayerPlugin } from "../player";
 
 /** Gets formatter for given formatName and formats value if found, returns value otherwise */
 const createFormatFunction = (schema: SchemaController) => {
@@ -10,7 +10,7 @@ const createFormatFunction = (schema: SchemaController) => {
   const handler: ExpressionHandler<[unknown, string], any> = (
     ctx,
     value,
-    formatName
+    formatName,
   ) => {
     return (
       schema.getFormatterForType({ type: formatName })?.format(value) ?? value
@@ -24,7 +24,7 @@ const createFormatFunction = (schema: SchemaController) => {
  * A plugin that provides the out-of-the-box expressions for player
  */
 export class DefaultExpPlugin implements PlayerPlugin {
-  name = 'flow-exp-plugin';
+  name = "flow-exp-plugin";
 
   apply(player: Player) {
     let formatFunction: ExpressionHandler<[unknown, string]> | undefined;
@@ -35,22 +35,22 @@ export class DefaultExpPlugin implements PlayerPlugin {
 
     player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
       if (formatFunction) {
-        expEvaluator.addExpressionFunction('format', formatFunction);
+        expEvaluator.addExpressionFunction("format", formatFunction);
       }
 
-      expEvaluator.addExpressionFunction('log', (ctx, ...args) => {
+      expEvaluator.addExpressionFunction("log", (ctx, ...args) => {
         player.logger.info(...args);
       });
 
-      expEvaluator.addExpressionFunction('debug', (ctx, ...args) => {
+      expEvaluator.addExpressionFunction("debug", (ctx, ...args) => {
         player.logger.debug(...args);
       });
 
       expEvaluator.addExpressionFunction(
-        'eval',
+        "eval",
         (ctx, ...args: [ExpressionType]) => {
           return ctx.evaluate(...args);
-        }
+        },
       );
     });
   }

package/src/plugins/default-view-plugin.ts

@@ -0,0 +1,29 @@
+import type { Player, PlayerPlugin } from "../player";
+import {
+  ApplicabilityPlugin,
+  StringResolverPlugin,
+  SwitchPlugin,
+  TemplatePlugin,
+  toNodeResolveOptions,
+} from "../view";
+
+/**
+ * A plugin that provides the out-of-the-box expressions for player
+ */
+export class DefaultViewPlugin implements PlayerPlugin {
+  name = "default-view-plugin";
+
+  apply(player: Player) {
+    player.hooks.viewController.tap(this.name, (viewController) => {
+      viewController.hooks.view.tap(this.name, (view) => {
+        const pluginOptions = toNodeResolveOptions(view.resolverOptions);
+        new SwitchPlugin(pluginOptions).apply(view);
+        new ApplicabilityPlugin().apply(view);
+        new StringResolverPlugin().apply(view);
+        const templatePlugin = new TemplatePlugin(pluginOptions);
+        templatePlugin.apply(view);
+        view.hooks.onTemplatePluginCreated.call(templatePlugin);
+      });
+    });
+  }
+}

package/src/plugins/flow-exp-plugin.ts

@@ -2,10 +2,10 @@ import type {
   Expression,
   ExpressionObject,
   NavigationFlowState,
-} from '@player-ui/types';
-import type { ExpressionEvaluator, ExpressionType } from '../expressions';
-import type { FlowInstance } from '../controllers';
-import type { Player, PlayerPlugin } from '../player';
+} from "@player-ui/types";
+import type { ExpressionEvaluator, ExpressionType } from "../expressions";
+import type { FlowInstance } from "../controllers";
+import type { Player, PlayerPlugin } from "../player";
 
 /**
  * A plugin that taps into the flow controller to evaluate available expressions
@@ -13,7 +13,7 @@ import type { Player, PlayerPlugin } from '../player';
  * e.g: onStart, onEnd
  */
 export class FlowExpPlugin implements PlayerPlugin {
-  name = 'flow-exp-plugin';
+  name = "flow-exp-plugin";
 
   apply(player: Player) {
     let expressionEvaluator: ExpressionEvaluator | undefined;
@@ -25,7 +25,7 @@ export class FlowExpPlugin implements PlayerPlugin {
      */
     const handleEval = (exp: Expression | ExpressionObject) => {
       if (exp) {
-        if (typeof exp === 'object' && 'exp' in exp) {
+        if (typeof exp === "object" && "exp" in exp) {
           expressionEvaluator?.evaluate(exp.exp);
         } else {
           expressionEvaluator?.evaluate(exp as ExpressionType);

package/src/schema/__tests__/schema.test.ts

@@ -0,0 +1,243 @@
+import { describe, test, expect } from "vitest";
+import { BindingParser } from "../../binding";
+import { SchemaController } from "..";
+
+const { parse } = new BindingParser({
+  get: () => undefined,
+  set: () => undefined,
+  evaluate: () => undefined,
+});
+
+describe("schema", () => {
+  const schema = new SchemaController({
+    ROOT: {
+      pets: {
+        type: "PetType",
+        isArray: true,
+      },
+      owner: {
+        type: "OwnerType",
+      },
+      animals: {
+        type: "AnimalType",
+        isRecord: true,
+      },
+      automobile: {
+        type: "carType",
+        isArray: true,
+      },
+    },
+    PetType: {
+      breed: {
+        type: "StringType",
+      },
+      name: {
+        type: "StringType",
+        validation: [
+          {
+            type: "required",
+          },
+        ],
+      },
+      age: {
+        type: "IntegerType",
+        validation: [
+          {
+            type: "required",
+          },
+        ],
+      },
+    },
+    OwnerType: {
+      name: {
+        type: "FirstNameType",
+        validation: [
+          {
+            type: "enum",
+            options: ["adam"],
+          },
+        ],
+      },
+    },
+    AnimalType: {
+      age: {
+        type: "IntegerType",
+        validation: [
+          {
+            type: "required",
+          },
+        ],
+      },
+      type: {
+        type: "StringType",
+      },
+      name: {
+        type: "StringType",
+        validation: [
+          {
+            type: "length",
+            min: 1,
+            max: 10,
+          },
+        ],
+      },
+      colors: {
+        type: "colorType",
+        isArray: true,
+      },
+    },
+    carType: {
+      year: {
+        type: "IntegerType",
+      },
+      car: {
+        type: "makeType",
+        isRecord: true,
+      },
+    },
+    colorType: {
+      color: {
+        type: "StringType",
+      },
+    },
+    makeType: {
+      makeInteger: {
+        type: "IntegerType",
+        validation: [
+          {
+            type: "required",
+          },
+        ],
+      },
+      model: {
+        type: "modelType",
+        isArray: true,
+      },
+    },
+    modelType: {
+      color: {
+        type: "StringType",
+      },
+      body: {
+        type: "StringType",
+        validation: [
+          {
+            type: "required",
+          },
+        ],
+      },
+    },
+  });
+
+  test("gets basic type info", () => {
+    expect(schema.getType(parse("owner.name"))?.type).toBe("FirstNameType");
+    expect(schema.getValidationsForBinding(parse("owner.name"))).toStrictEqual([
+      {
+        type: "enum",
+        options: ["adam"],
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+  });
+
+  test("gets the type for objects in an array", () => {
+    expect(schema.getType(parse("pets.4.name"))?.type).toBe("StringType");
+    expect(
+      schema.getValidationsForBinding(parse("pets.999.name")),
+    ).toStrictEqual([
+      {
+        type: "required",
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+  });
+
+  test("gets the type for an array parent", () => {
+    expect(schema.getType(parse("pets"))).toStrictEqual({
+      type: "PetType",
+      isArray: true,
+    });
+  });
+
+  test("gets the type for an record parent", () => {
+    expect(schema.getType(parse("animals"))).toStrictEqual({
+      type: "AnimalType",
+      isRecord: true,
+    });
+  });
+
+  test("gets the type for objects in a record", () => {
+    expect(schema.getType(parse("animals.cat.age"))?.type).toBe("IntegerType");
+    expect(
+      schema.getValidationsForBinding(parse("animals.cat.age")),
+    ).toStrictEqual([
+      {
+        type: "required",
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+  });
+
+  test("gets the type for objects in a record in an array", () => {
+    expect(schema.getType(parse("animals.cat.colors.0.color"))?.type).toBe(
+      "StringType",
+    );
+  });
+
+  test("gets the type for objects in a record with validation", () => {
+    expect(schema.getType(parse("animals.ginger.name"))?.type).toBe(
+      "StringType",
+    );
+    expect(
+      schema.getValidationsForBinding(parse("animals.ginger.name")),
+    ).toStrictEqual([
+      {
+        type: "length",
+        min: 1,
+        max: 10,
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+  });
+
+  test("gets the schema type for an array of objects in an object. and an array in an object of arrays", () => {
+    expect(schema.getType(parse("automobile.0.year"))?.type).toBe(
+      "IntegerType",
+    );
+    expect(
+      schema.getType(parse("automobile.0.car.honda.makeInteger"))?.type,
+    ).toBe("IntegerType");
+    expect(
+      schema.getValidationsForBinding(
+        parse("automobile.0.car.honda.makeInteger"),
+      ),
+    ).toStrictEqual([
+      {
+        type: "required",
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+    expect(
+      schema.getType(parse("automobile.0.car.honda.model.0.color"))?.type,
+    ).toBe("StringType");
+    expect(
+      schema.getType(parse("automobile.0.car.honda.model.0.body"))?.type,
+    ).toBe("StringType");
+    expect(
+      schema.getValidationsForBinding(
+        parse("automobile.0.car.honda.model.0.body"),
+      ),
+    ).toStrictEqual([
+      {
+        type: "required",
+        trigger: "change",
+        severity: "error",
+      },
+    ]);
+  });
+});

package/src/schema/index.ts

@@ -1,2 +1,2 @@
-export * from './types';
-export * from './schema';
+export * from "./types";
+export * from "./schema";