@player-ui/player 0.3.1-next.1 → 0.3.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

@@ -41,6 +41,11 @@ export interface DataModelOptions {
    */
   ignoreDefaultValue?: boolean;
 
+  /**
+   * A flag to indicate that this update should happen silently
+   */
+  silent?: boolean;
+
   /** Other context associated with this request */
   context?: {
     /** The data model to use when getting other data from the context of this request */
@@ -51,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 {
@@ -67,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;
 }
 
@@ -81,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) {
@@ -98,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);
+    },
   };
 }
 
@@ -120,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);
+    },
   };
 }
 
@@ -140,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 */
@@ -161,6 +206,9 @@ export function constructModelForPipeline(
     set: (transaction, options) => {
       return createModelWithOptions(options)?.set(transaction, options);
     },
+    delete: (binding, options) => {
+      return createModelWithOptions(options)?.delete(binding, options);
+    },
   };
 }
 
@@ -213,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,6 +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,
@@ -9,7 +11,6 @@ import type {
   ExpressionContext,
   ExpressionHandler,
 } from './types';
-import { isExpressionNode } from '.';
 
 /** a && b -- but handles short cutting if the first value is false */
 const andandOperator: BinaryOperator = (ctx, a, b) => {
@@ -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';