@player-ui/player 0.4.0-next.8 → 0.4.0-next.9

package/src/data/local-model.ts

@@ -1,5 +1,5 @@
 import get from 'dlv';
-import { setIn } from 'timm';
+import { setIn, omit, removeAt } from 'timm';
 import type { BindingInstance } from '../binding';
 import type { BatchSetTransaction, DataModelImpl, Updates } from './model';
 
@@ -38,4 +38,28 @@ export class LocalModel implements DataModelImpl {
     });
     return effectiveOperations;
   }
+
+  public delete(binding: BindingInstance) {
+    const parentBinding = binding.parent();
+
+    if (parentBinding) {
+      const parentValue = this.get(parentBinding);
+
+      if (parentValue !== undefined) {
+        if (Array.isArray(parentValue)) {
+          this.model = setIn(
+            this.model,
+            parentBinding.asArray(),
+            removeAt(parentValue, binding.key() as number)
+          ) as any;
+        } else {
+          this.model = setIn(
+            this.model,
+            parentBinding.asArray(),
+            omit(parentValue, binding.key() as string)
+          ) as any;
+        }
+      }
+    }
+  }
 }

package/src/data/model.ts

@@ -56,11 +56,13 @@ export interface DataModelOptions {
 export interface DataModelWithParser<Options = DataModelOptions> {
   get(binding: BindingLike, options?: Options): any;
   set(transaction: [BindingLike, any][], options?: Options): Updates;
+  delete(binding: BindingLike, options?: Options): void;
 }
 
 export interface DataModelImpl<Options = DataModelOptions> {
   get(binding: BindingInstance, options?: Options): any;
   set(transaction: BatchSetTransaction, options?: Options): Updates;
+  delete(binding: BindingInstance, options?: Options): void;
 }
 
 export interface DataModelMiddleware {
@@ -72,11 +74,19 @@ export interface DataModelMiddleware {
     options?: DataModelOptions,
     next?: DataModelImpl
   ): Updates;
+
   get(
     binding: BindingInstance,
     options?: DataModelOptions,
     next?: DataModelImpl
   ): any;
+
+  delete?(
+    binding: BindingInstance,
+    options?: DataModelOptions,
+    next?: DataModelImpl
+  ): void;
+
   reset?(): void;
 }
 
@@ -86,12 +96,16 @@ export function withParser<Options = unknown>(
   parseBinding: BindingFactory
 ): DataModelWithParser<Options> {
   /** Parse something into a binding if it requires it */
-  function maybeParse(binding: BindingLike): BindingInstance {
+  function maybeParse(
+    binding: BindingLike,
+    readOnly: boolean
+  ): BindingInstance {
     const parsed = isBinding(binding)
       ? binding
       : parseBinding(binding, {
           get: model.get,
           set: model.set,
+          readOnly,
         });
 
     if (!parsed) {
@@ -103,14 +117,17 @@ export function withParser<Options = unknown>(
 
   return {
     get(binding, options?: Options) {
-      return model.get(maybeParse(binding), options);
+      return model.get(maybeParse(binding, true), options);
     },
     set(transaction, options?: Options) {
       return model.set(
-        transaction.map(([key, val]) => [maybeParse(key), val]),
+        transaction.map(([key, val]) => [maybeParse(key, false), val]),
         options
       );
     },
+    delete(binding, options?: Options) {
+      return model.delete(maybeParse(binding, false), options);
+    },
   };
 }
 
@@ -125,10 +142,33 @@ export function toModel(
   }
 
   return {
-    get: (binding: BindingInstance, options?: DataModelOptions) =>
-      middleware.get(binding, options ?? defaultOptions, next),
-    set: (transaction: BatchSetTransaction, options?: DataModelOptions) =>
-      middleware.set(transaction, options ?? defaultOptions, next),
+    get: (binding: BindingInstance, options?: DataModelOptions) => {
+      const resolvedOptions = options ?? defaultOptions;
+
+      if (middleware.get) {
+        return middleware.get(binding, resolvedOptions, next);
+      }
+
+      return next?.get(binding, resolvedOptions);
+    },
+    set: (transaction: BatchSetTransaction, options?: DataModelOptions) => {
+      const resolvedOptions = options ?? defaultOptions;
+
+      if (middleware.set) {
+        return middleware.set(transaction, resolvedOptions, next);
+      }
+
+      return next?.set(transaction, resolvedOptions);
+    },
+    delete: (binding: BindingInstance, options?: DataModelOptions) => {
+      const resolvedOptions = options ?? defaultOptions;
+
+      if (middleware.delete) {
+        return middleware.delete(binding, resolvedOptions, next);
+      }
+
+      return next?.delete(binding, resolvedOptions);
+    },
   };
 }
 
@@ -145,7 +185,7 @@ export function constructModelForPipeline(
   }
 
   if (pipeline.length === 1) {
-    return pipeline[0];
+    return toModel(pipeline[0]);
   }
 
   /** Default and propagate the options into the nested calls */
@@ -166,6 +206,9 @@ export function constructModelForPipeline(
     set: (transaction, options) => {
       return createModelWithOptions(options)?.set(transaction, options);
     },
+    delete: (binding, options) => {
+      return createModelWithOptions(options)?.delete(binding, options);
+    },
   };
 }
 
@@ -218,4 +261,8 @@ export class PipelinedDataModel implements DataModelImpl {
   public get(binding: BindingInstance, options?: DataModelOptions): any {
     return this.effectiveDataModel.get(binding, options);
   }
+
+  public delete(binding: BindingInstance, options?: DataModelOptions): void {
+    return this.effectiveDataModel.delete(binding, options);
+  }
 }

package/src/data/noop-model.ts

@@ -12,6 +12,8 @@ export class NOOPDataModel implements DataModelImpl {
   set() {
     return [];
   }
+
+  delete() {}
 }
 
 /** You only really need 1 instance of the NOOP model */

package/src/expressions/evaluator-functions.ts

@@ -1,7 +1,11 @@
 import type { Binding } from '@player-ui/types';
 
 import type { BindingLike } from '../binding';
-import type { ExpressionHandler, ExpressionContext } from './types';
+import type {
+  ExpressionHandler,
+  ExpressionContext,
+  ExpressionNode,
+} from './types';
 
 /** Sets a value to the data-model */
 export const setDataVal: ExpressionHandler<[Binding, any], any> = (
@@ -25,5 +29,23 @@ export const deleteDataVal: ExpressionHandler<[Binding], void> = (
   _context: ExpressionContext,
   binding
 ) => {
-  return _context.model.set([[binding as BindingLike, undefined]]);
+  return _context.model.delete(binding);
 };
+
+/** Conditional expression handler */
+export const conditional: ExpressionHandler<
+  [ExpressionNode, ExpressionNode, ExpressionNode?]
+> = (ctx, condition, ifTrue, ifFalse) => {
+  const resolution = ctx.evaluate(condition);
+  if (resolution) {
+    return ctx.evaluate(ifTrue);
+  }
+
+  if (ifFalse) {
+    return ctx.evaluate(ifFalse);
+  }
+
+  return null;
+};
+
+conditional.resolveParams = false;

package/src/expressions/evaluator.ts

@@ -2,6 +2,7 @@ import { SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
 import { parseExpression } from './parser';
 import * as DEFAULT_EXPRESSION_HANDLERS from './evaluator-functions';
 import { isExpressionNode } from './types';
+import { isObjectExpression } from './utils';
 import type {
   ExpressionNode,
   BinaryOperator,
@@ -71,6 +72,11 @@ const DEFAULT_UNARY_OPERATORS: Record<string, UnaryOperator> = {
 export interface HookOptions extends ExpressionContext {
   /** Given an expression node  */
   resolveNode: (node: ExpressionNode) => any;
+
+  /** Enabling this flag skips calling the onError hook, and just throws errors back to the caller.
+   * The caller is responsible for handling the error.
+   */
+  throwErrors?: boolean;
 }
 
 export type ExpressionEvaluatorOptions = Omit<
@@ -92,6 +98,12 @@ export class ExpressionEvaluator {
     /** Resolve an AST node for an expression to a value */
     resolve: new SyncWaterfallHook<[any, ExpressionNode, HookOptions]>(),
 
+    /** Gets the options that will be passed in calls to the resolve hook */
+    resolveOptions: new SyncWaterfallHook<[HookOptions]>(),
+
+    /** Allows users to change the expression to be evaluated before processing */
+    beforeEvaluate: new SyncWaterfallHook<[ExpressionType, HookOptions]>(),
+
     /**
      * An optional means of handling an error in the expression execution
      * Return true if handled, to stop propagation of the error
@@ -128,14 +140,22 @@ export class ExpressionEvaluator {
   }
 
   public evaluate(
-    expression: ExpressionType,
+    expr: ExpressionType,
     options?: ExpressionEvaluatorOptions
   ): any {
-    const opts = {
+    const resolvedOpts = this.hooks.resolveOptions.call({
       ...this.defaultHookOptions,
       ...options,
-      resolveNode: (node: ExpressionNode) => this._execAST(node, opts),
-    };
+      resolveNode: (node: ExpressionNode) => this._execAST(node, resolvedOpts),
+    });
+
+    let expression = this.hooks.beforeEvaluate.call(expr, resolvedOpts) ?? expr;
+
+    // Unwrap any returned expression type
+    // Since this could also be an object type, we need to recurse through it until we find the end
+    while (isObjectExpression(expression)) {
+      expression = expression.value;
+    }
 
     // Check for literals
     if (
@@ -149,21 +169,17 @@ export class ExpressionEvaluator {
 
     // Skip doing anything with objects that are _actually_ just parsed expression nodes
     if (isExpressionNode(expression)) {
-      return this._execAST(expression, opts);
+      return this._execAST(expression, resolvedOpts);
     }
 
-    if (typeof expression === 'object') {
-      const values = Array.isArray(expression)
-        ? expression
-        : Object.values(expression);
-
-      return values.reduce(
+    if (Array.isArray(expression)) {
+      return expression.reduce(
         (_nothing, exp) => this.evaluate(exp, options),
         null
       );
     }
 
-    return this._execString(String(expression), opts);
+    return this._execString(String(expression), resolvedOpts);
   }
 
   public addExpressionFunction<T extends readonly unknown[], R>(
@@ -217,8 +233,8 @@ export class ExpressionEvaluator {
 
       return this._execAST(expAST, options);
     } catch (e: any) {
-      if (!this.hooks.onError.call(e)) {
-        // Only throw the error if it's not handled by the hook
+      if (options.throwErrors || !this.hooks.onError.call(e)) {
+        // Only throw the error if it's not handled by the hook, or throwErrors is true
         throw e;
       }
     }
@@ -305,35 +321,23 @@ export class ExpressionEvaluator {
     if (node.type === 'CallExpression') {
       const expressionName = node.callTarget.name;
 
-      // Treat the conditional operator as special.
-      // Don't exec the arguments that don't apply
-      if (expressionName === 'conditional') {
-        const condition = resolveNode(node.args[0]);
-
-        if (condition) {
-          return resolveNode(node.args[1]);
-        }
-
-        if (node.args[2]) {
-          return resolveNode(node.args[2]);
-        }
-
-        return null;
-      }
-
       const operator = this.operators.expressions.get(expressionName);
 
       if (!operator) {
         throw new Error(`Unknown expression function: ${expressionName}`);
       }
 
+      if ('resolveParams' in operator && operator.resolveParams === false) {
+        return operator(expressionContext, ...node.args);
+      }
+
       const args = node.args.map((n) => resolveNode(n));
 
       return operator(expressionContext, ...args);
     }
 
     if (node.type === 'ModelRef') {
-      return model.get(node.ref);
+      return model.get(node.ref, { context: { model: options.model } });
     }
 
     if (node.type === 'MemberExpression') {

package/src/expressions/types.ts

@@ -1,17 +1,24 @@
 import type { DataModelWithParser } from '../data';
 import type { Logger } from '../logger';
 
+export type ExpressionObjectType = {
+  /** The expression to eval */
+  value: BasicExpressionTypes;
+};
+
 export type ExpressionLiteralType =
   | string
   | number
   | boolean
   | undefined
   | null;
-export type ExpressionType =
-  | object
+
+export type BasicExpressionTypes =
   | ExpressionLiteralType
-  | Array<ExpressionLiteralType>
-  | ExpressionNode;
+  | ExpressionObjectType
+  | Array<ExpressionLiteralType | ExpressionObjectType>;
+
+export type ExpressionType = BasicExpressionTypes | ExpressionNode;
 
 export interface OperatorProcessingOptions {
   /**
@@ -53,7 +60,12 @@ export const ExpNodeOpaqueIdentifier = Symbol('Expression Node ID');
 
 /** Checks if the input is an already processed Expression node */
 export function isExpressionNode(x: any): x is ExpressionNode {
-  return typeof x === 'object' && x.__id === ExpNodeOpaqueIdentifier;
+  return (
+    typeof x === 'object' &&
+    x !== null &&
+    !Array.isArray(x) &&
+    x.__id === ExpNodeOpaqueIdentifier
+  );
 }
 
 export interface NodePosition {

package/src/expressions/utils.ts

@@ -1,6 +1,9 @@
+import { isExpressionNode } from './types';
 import type {
   ExpressionHandler,
   ExpressionNode,
+  ExpressionObjectType,
+  ExpressionType,
   NodeLocation,
   NodePosition,
 } from './types';
@@ -129,3 +132,19 @@ export function findClosestNodeAtPosition(
     return node;
   }
 }
+
+/** Checks if the expression is a simple type */
+export function isObjectExpression(
+  expr: ExpressionType
+): expr is ExpressionObjectType {
+  if (isExpressionNode(expr)) {
+    return false;
+  }
+
+  return (
+    typeof expr === 'object' &&
+    expr !== null &&
+    !Array.isArray(expr) &&
+    'value' in expr
+  );
+}

package/src/player.ts

@@ -1,12 +1,11 @@
 import { setIn } from 'timm';
 import deferred from 'p-defer';
-import queueMicrotask from 'queue-microtask';
 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 { ExpressionHandler } from './expressions';
+import type { ExpressionType } from './expressions';
 import { ExpressionEvaluator } from './expressions';
 import { SchemaController } from './schema';
 import { BindingParser } from './binding';
@@ -31,8 +30,8 @@ import type {
 import { NOT_STARTED_STATE } from './types';
 
 // Variables injected at build time
-const PLAYER_VERSION = '0.4.0-next.8';
-const COMMIT = '766bb5a5d65b00da16285cf36b62c441568ac9a3';
+const PLAYER_VERSION = '0.4.0-next.9';
+const COMMIT = 'e7681a2757fe0ab15d0c0e27c11d0ed33334d63f';
 
 export interface PlayerPlugin {
   /**
@@ -289,10 +288,11 @@ export class Player {
     });
 
     /** Resolve any data references in a string */
-    function resolveStrings<T>(val: T) {
+    function resolveStrings<T>(val: T, formatted?: boolean) {
       return resolveDataRefs(val, {
         model: dataController,
         evaluate: expressionEvaluator.evaluate,
+        formatted,
       });
     }
 
@@ -306,7 +306,7 @@ export class Player {
           if (typeof state.onEnd === 'object' && 'exp' in state.onEnd) {
             expressionEvaluator?.evaluate(state.onEnd.exp);
           } else {
-            expressionEvaluator?.evaluate(state.onEnd);
+            expressionEvaluator?.evaluate(state.onEnd as ExpressionType);
           }
         }
 
@@ -353,7 +353,7 @@ export class Player {
           newState = setIn(
             state,
             ['param'],
-            resolveStrings(state.param)
+            resolveStrings(state.param, false)
           ) as any;
         }
 
@@ -361,26 +361,18 @@ export class Player {
       });
 
       flow.hooks.transition.tap('player', (_oldState, newState) => {
-        if (newState.value.state_type === 'ACTION') {
-          const { exp } = newState.value;
-
-          // The nested transition call would trigger another round of the flow transition hooks to be called.
-          // This created a weird timing where this nested transition would happen before the view had a chance to respond to the first one
-
-          // Additionally, because we are using queueMicrotask, errors could get swallowed in the detached queue
-          // Use a try catch and fail player explicitly if any errors are caught in the nested transition/state
-          queueMicrotask(() => {
-            try {
-              flowController?.transition(
-                String(expressionEvaluator?.evaluate(exp))
-              );
-            } catch (error) {
-              const state = this.getState();
-              if (error instanceof Error && state.status === 'in-progress') {
-                state.fail(error);
-              }
-            }
-          });
+        if (newState.value.state_type !== 'VIEW') {
+          validationController.reset();
+        }
+      });
+
+      flow.hooks.afterTransition.tap('player', (flowInstance) => {
+        const value = flowInstance.currentState?.value;
+        if (value && value.state_type === 'ACTION') {
+          const { exp } = value;
+          flowController?.transition(
+            String(expressionEvaluator?.evaluate(exp))
+          );
         }
 
         expressionEvaluator.reset();
@@ -402,6 +394,11 @@ export class Player {
       parseBinding,
       transition: flowController.transition,
       model: dataController,
+      utils: {
+        findPlugin: <Plugin = unknown>(pluginSymbol: symbol) => {
+          return this.findPlugin(pluginSymbol) as unknown as Plugin;
+        },
+      },
       logger: this.logger,
       flowController,
       schema,
@@ -419,6 +416,7 @@ export class Player {
         ...validationController.forView(parseBinding),
         type: (b) => schema.getType(parseBinding(b)),
       },
+      constants: this.constantsController,
     });
     viewController.hooks.view.tap('player', (view) => {
       validationController.onView(view);
@@ -432,7 +430,7 @@ export class Player {
           .start()
           .then((endState) => {
             const flowResult: FlowResult = {
-              endState: resolveStrings(endState),
+              endState: resolveStrings(endState, false),
               data: dataController.serialize(),
             };
 
@@ -503,7 +501,6 @@ export class Player {
         ref,
         status: 'completed',
         flow: state.flow,
-        dataModel: state.controllers.data.getModel(),
       } as const;
 
       return maybeUpdateState({

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

@@ -3,7 +3,7 @@ import type {
   ExpressionObject,
   NavigationFlowState,
 } from '@player-ui/types';
-import type { ExpressionEvaluator } from '../expressions';
+import type { ExpressionEvaluator, ExpressionType } from '../expressions';
 import type { FlowInstance } from '../controllers';
 import type { Player, PlayerPlugin } from '../player';
 
@@ -28,7 +28,7 @@ export class FlowExpPlugin implements PlayerPlugin {
         if (typeof exp === 'object' && 'exp' in exp) {
           expressionEvaluator?.evaluate(exp.exp);
         } else {
-          expressionEvaluator?.evaluate(exp);
+          expressionEvaluator?.evaluate(exp as ExpressionType);
         }
       }
     };

package/src/string-resolver/index.ts

@@ -17,6 +17,11 @@ export interface Options {
    * Passing `false` will skip trying to evaluate any expressions (@[ foo() ]@)
    */
   evaluate: false | ((exp: Expression) => any);
+
+  /**
+   * Optionaly resolve binding without formatting in case Type format applies
+   */
+  formatted?: boolean;
 }
 
 /** Search the given string for the coordinates of the next expression to resolve */
@@ -116,7 +121,7 @@ export function resolveExpressionsInString(
 
 /** Return a string with all data model references resolved */
 export function resolveDataRefsInString(val: string, options: Options): string {
-  const { model } = options;
+  const { model, formatted = true } = options;
   let workingString = resolveExpressionsInString(val, options);
 
   if (
@@ -144,7 +149,7 @@ export function resolveDataRefsInString(val: string, options: Options): string {
       )
       .trim();
 
-    const evaledVal = model.get(binding, { formatted: true });
+    const evaledVal = model.get(binding, { formatted });
 
     // Exit early if the string is _just_ a model lookup
     // If the result is a string, we may need further processing for nested bindings

package/src/types.ts

@@ -85,10 +85,7 @@ export type InProgressState = BaseFlowState<'in-progress'> &
 /** The flow completed properly */
 export type CompletedState = BaseFlowState<'completed'> &
   PlayerFlowExecutionData &
-  FlowResult & {
-    /** The top-level data-model for the flow */
-    dataModel: DataModelWithParser;
-  };
+  FlowResult;
 
 /** The flow finished but not successfully */
 export type ErrorState = BaseFlowState<'error'> & {

package/src/validator/binding-map-splice.ts

@@ -0,0 +1,59 @@
+import type { BindingInstance } from '../binding';
+
+/**
+ * Remove a binding, and any children from from the map
+ * If the binding is an array-item, then it will be spliced from the array and the others will be shifted down
+ *
+ * @param sourceMap - A map of bindings to values
+ * @param binding - The binding to remove from the map
+ */
+export function removeBindingAndChildrenFromMap<T>(
+  sourceMap: Map<BindingInstance, T>,
+  binding: BindingInstance
+): Map<BindingInstance, T> {
+  const targetMap = new Map(sourceMap);
+
+  const parentBinding = binding.parent();
+  const property = binding.key();
+
+  // Clear out any that are sub-bindings of this binding
+
+  targetMap.forEach((_value, trackedBinding) => {
+    if (binding === trackedBinding || binding.contains(trackedBinding)) {
+      targetMap.delete(trackedBinding);
+    }
+  });
+
+  if (typeof property === 'number') {
+    // Splice out this index from the rest
+
+    // Order matters here b/c we are shifting items in the array
+    // Start with the smallest index and work our way down
+    const bindingsToRewrite = Array.from(sourceMap.keys())
+      .filter((b) => {
+        if (parentBinding.contains(b)) {
+          const [childIndex] = b.relative(parentBinding);
+          return typeof childIndex === 'number' && childIndex > property;
+        }
+
+        return false;
+      })
+      .sort();
+
+    bindingsToRewrite.forEach((trackedBinding) => {
+      // If the tracked binding is a sub-binding of the parent binding, then we need to
+      // update the path to reflect the new index
+
+      const [childIndex, ...childPath] = trackedBinding.relative(parentBinding);
+
+      if (typeof childIndex === 'number') {
+        const newSegments = [childIndex - 1, ...childPath];
+        const newChildBinding = parentBinding.descendent(newSegments);
+        targetMap.set(newChildBinding, targetMap.get(trackedBinding) as T);
+        targetMap.delete(trackedBinding);
+      }
+    });
+  }
+
+  return targetMap;
+}

package/src/validator/index.ts

@@ -1,3 +1,4 @@
 export * from './validation-middleware';
 export * from './types';
 export * from './registry';
+export * from './binding-map-splice';