@player-ui/player 0.4.0 → 0.4.1-next.1

package/src/controllers/view/asset-transform.ts

@@ -92,7 +92,10 @@ export class AssetTransformCorePlugin {
             const transform = this.registry.get(node.value);
 
             if (transform?.beforeResolve) {
-              const store = getStore(node, this.beforeResolveSymbol);
+              const store = getStore(
+                options.node ?? node,
+                this.beforeResolveSymbol
+              );
 
               return transform.beforeResolve(node, options, store);
             }

package/src/controllers/view/controller.ts

@@ -8,7 +8,7 @@ import type { Resolve } from '../../view';
 import { ViewInstance } from '../../view';
 import type { Logger } from '../../logger';
 import type { FlowInstance, FlowController } from '../flow';
-import type { DataController } from '../data';
+import type { DataController } from '../data/controller';
 import { AssetTransformCorePlugin } from './asset-transform';
 import type { TransformRegistry } from './types';
 import type { BindingInstance } from '../../binding';
@@ -75,14 +75,31 @@ export class ViewController {
       }
     );
 
-    options.model.hooks.onUpdate.tap('viewController', (updates) => {
+    /** Trigger a view update */
+    const update = (updates: Set<BindingInstance>) => {
       if (this.currentView) {
         if (this.optimizeUpdates) {
-          this.queueUpdate(new Set(updates.map((t) => t.binding)));
+          this.queueUpdate(updates);
         } else {
           this.currentView.update();
         }
       }
+    };
+
+    options.model.hooks.onUpdate.tap('viewController', (updates) => {
+      update(new Set(updates.map((t) => t.binding)));
+    });
+
+    options.model.hooks.onDelete.tap('viewController', (binding) => {
+      const parentBinding = binding.parent();
+      const property = binding.key();
+
+      // Deleting an array item will trigger an update for the entire array
+      if (typeof property === 'number' && parentBinding) {
+        update(new Set([parentBinding]));
+      } else {
+        update(new Set([binding]));
+      }
     });
   }
 

package/src/data/dependency-tracker.ts

@@ -157,6 +157,15 @@ export class DependencyMiddleware
 
     return next?.get(binding, options);
   }
+
+  public delete(
+    binding: BindingInstance,
+    options?: DataModelOptions,
+    next?: DataModelImpl | undefined
+  ) {
+    this.addWriteDep(binding);
+    return next?.delete(binding, options);
+  }
 }
 
 /** A data-model that tracks dependencies of read/written data */
@@ -184,4 +193,9 @@ export class DependencyModel<Options = DataModelOptions>
 
     return this.rootModel.get(binding, options);
   }
+
+  public delete(binding: BindingInstance, options?: Options) {
+    this.addWriteDep(binding);
+    return this.rootModel.delete(binding, options);
+  }
 }

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

@@ -1,7 +1,8 @@
 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 { 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>(
@@ -212,13 +228,13 @@ 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);
     } 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/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

@@ -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 {
@@ -81,6 +93,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/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
+  );
+}