@player-ui/player 0.4.0-next.4 → 0.4.0-next.6

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@player-ui/player",
-  "version": "0.4.0-next.4",
+  "version": "0.4.0-next.6",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {},
   "dependencies": {
-    "@player-ui/partial-match-registry": "0.4.0-next.4",
-    "@player-ui/types": "0.4.0-next.4",
+    "@player-ui/partial-match-registry": "0.4.0-next.6",
+    "@player-ui/types": "0.4.0-next.6",
     "dequal": "^2.0.2",
     "p-defer": "^3.0.0",
     "queue-microtask": "^1.2.3",

package/src/controllers/data.ts

@@ -157,8 +157,6 @@ export class DataController implements DataModelWithParser<DataModelOptions> {
 
     this.hooks.onSet.call(normalizedTransaction);
 
-    this.hooks.onSet.call(normalizedTransaction);
-
     if (setUpdates.length > 0) {
       this.hooks.onUpdate.call(setUpdates, options);
     }

package/src/expressions/evaluator.ts

@@ -1,5 +1,5 @@
 import { SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
-import parse from './parser';
+import { parseExpression } from './parser';
 import * as DEFAULT_EXPRESSION_HANDLERS from './evaluator-functions';
 import { isExpressionNode } from './types';
 import type {
@@ -212,7 +212,7 @@ export class ExpressionEvaluator {
         return this._execAST(storedAST, options);
       }
 
-      const expAST = parse(matchedExp);
+      const expAST = parseExpression(matchedExp);
       this.expressionsCache.set(matchedExp, expAST);
 
       return this._execAST(expAST, options);

package/src/expressions/index.ts

@@ -1,3 +1,4 @@
 export * from './evaluator';
 export * from './types';
 export * from './utils';
+export * from './parser';

package/src/expressions/parser.ts

@@ -195,7 +195,15 @@ function isModelRefStart(ch0: number, ch1: number) {
 }
 
 /** Parse out an expression from the string */
-export default function parseExpression(expr: string): ExpressionNode {
+export function parseExpression(
+  expr: string,
+  options?: {
+    /** If true (the default), will throw on invalid expressions */
+    strict?: boolean;
+  }
+): ExpressionNode {
+  const strictMode = options?.strict ?? true;
+
   // `index` stores the character number we are currently at while `length` is a constant
   // All of the gobbles below will modify `index` as we move along
   const charAtFunc = expr.charAt;
@@ -789,6 +797,10 @@ export default function parseExpression(expr: string): ExpressionNode {
       args.push(node);
     }
 
+    if (charIndex !== termination) {
+      throwError(`Expected ${String.fromCharCode(termination)}`, index);
+    }
+
     return args;
   }
 
@@ -899,37 +911,51 @@ export default function parseExpression(expr: string): ExpressionNode {
 
   const nodes = [];
 
-  while (index < length) {
-    const chIndex = exprICode(index);
+  try {
+    while (index < length) {
+      const chIndex = exprICode(index);
+
+      // Expressions can be separated by semicolons, commas, or just inferred without any
+      // separators
+      if (chIndex === SEMCOL_CODE || chIndex === COMMA_CODE) {
+        index++; // ignore separators
+        continue;
+      }
+
+      const node = gobbleExpression();
 
-    // Expressions can be separated by semicolons, commas, or just inferred without any
-    // separators
-    if (chIndex === SEMCOL_CODE || chIndex === COMMA_CODE) {
-      index++; // ignore separators
-      continue;
+      // Try to gobble each expression individually
+      if (node) {
+        nodes.push(node);
+        // If we weren't able to find a binary expression and are out of room, then
+        // the expression passed in probably has too much
+      } else if (index < length) {
+        throwError(`Unexpected "${exprI(index)}"`, index);
+      }
     }
 
-    const node = gobbleExpression();
+    // If there's only one expression just try returning the expression
+    if (nodes.length === 1) {
+      return nodes[0];
+    }
 
-    // Try to gobble each expression individually
-    if (node) {
-      nodes.push(node);
-      // If we weren't able to find a binary expression and are out of room, then
-      // the expression passed in probably has too much
-    } else if (index < length) {
-      throwError(`Unexpected "${exprI(index)}"`, index);
+    return {
+      __id: ExpNodeOpaqueIdentifier,
+      type: 'Compound',
+      body: nodes,
+      location: getLocation(0),
+    };
+  } catch (e) {
+    if (strictMode || !(e instanceof Error)) {
+      throw e;
     }
-  }
 
-  // If there's only one expression just try returning the expression
-  if (nodes.length === 1) {
-    return nodes[0];
+    return {
+      __id: ExpNodeOpaqueIdentifier,
+      type: 'Compound',
+      body: nodes,
+      location: getLocation(0),
+      error: e,
+    };
   }
-
-  return {
-    __id: ExpNodeOpaqueIdentifier,
-    type: 'Compound',
-    body: nodes,
-    location: getLocation(0),
-  };
 }

package/src/expressions/types.ts

@@ -81,6 +81,12 @@ export interface BaseNode<T> {
 
   /** The location of the node in the source expression string */
   location?: NodeLocation;
+
+  /**
+   * The error that occurred while parsing this node
+   * This is only set if the parsing mode is set to non-strict
+   */
+  error?: Error;
 }
 
 /** A helper interface for nodes that container left and right children */

package/src/player.ts

@@ -21,6 +21,7 @@ import {
   FlowController,
 } from './controllers';
 import { FlowExpPlugin } from './plugins/flow-exp-plugin';
+import { DefaultExpPlugin } from './plugins/default-exp-plugin';
 import type {
   PlayerFlowState,
   InProgressState,
@@ -30,8 +31,8 @@ import type {
 import { NOT_STARTED_STATE } from './types';
 
 // Variables injected at build time
-const PLAYER_VERSION = '0.4.0-next.4';
-const COMMIT = 'e03645f7ab5fbdfab274edcc92542752712afe01';
+const PLAYER_VERSION = '0.4.0-next.6';
+const COMMIT = '380eb6be2e6d61675cf721c4c3e64821099e5fbe';
 
 export interface PlayerPlugin {
   /**
@@ -49,6 +50,18 @@ export interface PlayerPlugin {
   apply: (player: Player) => void;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface ExtendedPlayerPlugin<
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Assets = void,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Views = void,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Expressions = void,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  DataTypes = void
+> {}
+
 export interface PlayerConfigOptions {
   /** A set of plugins to load  */
   plugins?: PlayerPlugin[];
@@ -117,17 +130,16 @@ export class Player {
   };
 
   constructor(config?: PlayerConfigOptions) {
-    const initialPlugins: PlayerPlugin[] = [];
-    const flowExpPlugin = new FlowExpPlugin();
-
-    initialPlugins.push(flowExpPlugin);
-
     if (config?.logger) {
       this.logger.addHandler(config.logger);
     }
 
     this.config = config || {};
-    this.config.plugins = [...(this.config.plugins || []), ...initialPlugins];
+    this.config.plugins = [
+      new DefaultExpPlugin(),
+      ...(this.config.plugins || []),
+      new FlowExpPlugin(),
+    ];
     this.config.plugins?.forEach((plugin) => {
       plugin.apply(this);
     });
@@ -414,19 +426,6 @@ export class Player {
     });
     this.hooks.viewController.call(viewController);
 
-    /** Gets formatter for given formatName and formats value if found, returns value otherwise */
-    const formatFunction: ExpressionHandler<[unknown, string], any> = (
-      ctx,
-      value,
-      formatName
-    ) => {
-      return (
-        schema.getFormatterForType({ type: formatName })?.format(value) ?? value
-      );
-    };
-
-    expressionEvaluator.addExpressionFunction('format', formatFunction);
-
     return {
       start: () => {
         flowController

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

@@ -0,0 +1,57 @@
+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) => {
+  /**
+   * The generated handler for the given schema
+   */
+  const handler: ExpressionHandler<[unknown, string], any> = (
+    ctx,
+    value,
+    formatName
+  ) => {
+    return (
+      schema.getFormatterForType({ type: formatName })?.format(value) ?? value
+    );
+  };
+
+  return handler;
+};
+
+/**
+ * A plugin that provides the out-of-the-box expressions for player
+ */
+export class DefaultExpPlugin implements PlayerPlugin {
+  name = 'flow-exp-plugin';
+
+  apply(player: Player) {
+    let formatFunction: ExpressionHandler<[unknown, string]> | undefined;
+
+    player.hooks.schema.tap(this.name, (schemaController) => {
+      formatFunction = createFormatFunction(schemaController);
+    });
+
+    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
+      if (formatFunction) {
+        expEvaluator.addExpressionFunction('format', formatFunction);
+      }
+
+      expEvaluator.addExpressionFunction('log', (ctx, ...args) => {
+        player.logger.info(...args);
+      });
+
+      expEvaluator.addExpressionFunction('debug', (ctx, ...args) => {
+        player.logger.debug(...args);
+      });
+
+      expEvaluator.addExpressionFunction(
+        'eval',
+        (ctx, ...args: [ExpressionType]) => {
+          return ctx.evaluate(...args);
+        }
+      );
+    });
+  }
+}

package/src/schema/schema.ts

@@ -11,8 +11,8 @@ const identify = (val: any) => val;
 /** Expand the authored schema into a set of paths -> DataTypes */
 export function parse(
   schema: SchemaType.Schema
-): Map<string, SchemaType.DataType> {
-  const expandedPaths = new Map<string, SchemaType.DataType>();
+): Map<string, SchemaType.DataTypes> {
+  const expandedPaths = new Map<string, SchemaType.DataTypes>();
 
   if (!schema.ROOT) {
     return expandedPaths;
@@ -62,6 +62,10 @@ export function parse(
         nestedPath.push('[]');
       }
 
+      if (type.isRecord) {
+        nestedPath.push('{}');
+      }
+
       if (type.type && schema[type.type]) {
         parseQueue.push({
           path: nestedPath,
@@ -85,14 +89,14 @@ export class SchemaController implements ValidationProvider {
     new Map();
 
   private types: Map<string, SchemaType.DataType<any>> = new Map();
-  public readonly schema: Map<string, SchemaType.DataType> = new Map();
+  public readonly schema: Map<string, SchemaType.DataTypes> = new Map();
 
   private bindingSchemaNormalizedCache: Map<BindingInstance, string> =
     new Map();
 
   public readonly hooks = {
     resolveTypeForBinding: new SyncWaterfallHook<
-      [SchemaType.DataType | undefined, BindingInstance]
+      [SchemaType.DataTypes | undefined, BindingInstance]
     >(),
   };
 
@@ -135,17 +139,32 @@ export class SchemaController implements ValidationProvider {
       return cached;
     }
 
-    const normalized = binding
-      .asArray()
+    let bindingArray = binding.asArray();
+    let normalized = bindingArray
       .map((p) => (typeof p === 'number' ? '[]' : p))
       .join('.');
 
-    this.bindingSchemaNormalizedCache.set(binding, normalized);
+    if (normalized) {
+      this.bindingSchemaNormalizedCache.set(binding, normalized);
+      bindingArray = normalized.split('.');
+    }
+
+    bindingArray.forEach((item) => {
+      const recordBinding = bindingArray
+        .map((p) => (p === item ? '{}' : p))
+        .join('.');
+
+      if (this.schema.get(recordBinding)) {
+        this.bindingSchemaNormalizedCache.set(binding, recordBinding);
+        bindingArray = recordBinding.split('.');
+        normalized = recordBinding;
+      }
+    });
 
     return normalized;
   }
 
-  public getType(binding: BindingInstance): SchemaType.DataType | undefined {
+  public getType(binding: BindingInstance): SchemaType.DataTypes | undefined {
     return this.hooks.resolveTypeForBinding.call(
       this.schema.get(this.normalizeBinding(binding)),
       binding
@@ -154,7 +173,7 @@ export class SchemaController implements ValidationProvider {
 
   public getApparentType(
     binding: BindingInstance
-  ): SchemaType.DataType | undefined {
+  ): SchemaType.DataTypes | undefined {
     const schemaType = this.getType(binding);
 
     if (schemaType === undefined) {

package/src/string-resolver/index.ts

@@ -6,11 +6,17 @@ const DOUBLE_OPEN_CURLY = '{{';
 const DOUBLE_CLOSE_CURLY = '}}';
 
 export interface Options {
-  /** The model to use when resolving refs */
-  model: DataModelWithParser;
-
-  /** A function to evaluate an expression */
-  evaluate: (exp: Expression) => any;
+  /**
+   * The model to use when resolving refs
+   * Passing `false` will skip trying to resolve any direct model refs ({{foo}})
+   */
+  model: false | DataModelWithParser;
+
+  /**
+   * A function to evaluate an expression
+   * Passing `false` will skip trying to evaluate any expressions (@[ foo() ]@)
+   */
+  evaluate: false | ((exp: Expression) => any);
 }
 
 /** Search the given string for the coordinates of the next expression to resolve */
@@ -70,6 +76,10 @@ export function resolveExpressionsInString(
   val: string,
   { evaluate }: Options
 ): string {
+  if (!evaluate) {
+    return val;
+  }
+
   const expMatch = /@\[.*?\]@/;
   let newVal = val;
   let match = newVal.match(expMatch);
@@ -110,6 +120,7 @@ export function resolveDataRefsInString(val: string, options: Options): string {
   let workingString = resolveExpressionsInString(val, options);
 
   if (
+    !model ||
     typeof workingString !== 'string' ||
     workingString.indexOf(DOUBLE_OPEN_CURLY) === -1
   ) {
@@ -166,13 +177,13 @@ function traverseObject<T>(val: T, options: Options): T {
       let newVal = val;
 
       if (keys.length > 0) {
-        for (const key of keys) {
+        keys.forEach((key) => {
           newVal = setIn(
             newVal as any,
             [key],
             traverseObject((val as any)[key], options)
           ) as any;
-        }
+        });
       }
 
       return newVal;

package/src/validator/validation-middleware.ts

@@ -72,7 +72,10 @@ export class ValidationMiddleware implements DataModelMiddleware {
       } else if (validations instanceof Set) {
         validations.forEach((validation) => {
           invalidBindings.push(validation.binding);
-          if (!validation.isStrong) {
+          if (
+            !validation.isStrong &&
+            validation.binding.asString() === binding.asString()
+          ) {
             nextTransaction.push([validation.binding, value]);
           }
         });

package/src/view/parser/index.ts

@@ -120,7 +120,13 @@ export class Parser {
 
       const objEntries = Array.isArray(localObj)
         ? localObj.map((v, i) => [i, v])
-        : Object.entries(localObj);
+        : [
+            ...Object.entries(localObj),
+            ...Object.getOwnPropertySymbols(localObj).map((s) => [
+              s,
+              (localObj as any)[s],
+            ]),
+          ];
 
       const defaultValue: NestedObj = {
         children: [],