@player-ui/player 0.3.1-next.1 → 0.4.0-next.0

package/src/player.ts

@@ -30,8 +30,8 @@ import type {
 import { NOT_STARTED_STATE } from './types';
 
 // Variables injected at build time
-const PLAYER_VERSION = '0.3.1-next.1';
-const COMMIT = 'b51603be07572111ca68e73d1b710ed2d0aa9412';
+const PLAYER_VERSION = '0.4.0-next.0';
+const COMMIT = '6f7a8b3424cb819dfcbe830586a92711adf130ba';
 
 export interface PlayerPlugin {
   /**
@@ -286,10 +286,11 @@ export class Player {
 
     flowController.hooks.flow.tap('player', (flow: FlowInstance) => {
       flow.hooks.beforeTransition.tap('player', (state, transitionVal) => {
-        if (
-          state.onEnd &&
-          (state.transitions[transitionVal] || state.transitions['*'])
-        ) {
+        /** 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) {
             expressionEvaluator?.evaluate(state.onEnd.exp);
           } else {
@@ -297,14 +298,19 @@ export class Player {
           }
         }
 
-        if (!('transitions' in state) || !state.transitions[transitionVal]) {
+        /** If the transition does not exist, then do not resolve any expressions */
+        if (
+          !('transitions' in state) ||
+          !state.transitions[computedTransitionVal]
+        ) {
           return state;
         }
 
+        /** resolves and sets the transition to the computed exp */
         return setIn(
           state,
-          ['transitions', transitionVal],
-          resolveStrings(state.transitions[transitionVal])
+          ['transitions', computedTransitionVal],
+          resolveStrings(state.transitions[computedTransitionVal])
         ) as any;
       });
 
@@ -348,11 +354,20 @@ export class Player {
 
           // 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
-          // Use a queueMicrotask to make sure the expression transition is outside the scope of the flow hook
+
+          // 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(() => {
-            flowController?.transition(
-              String(expressionEvaluator?.evaluate(exp))
-            );
+            try {
+              flowController?.transition(
+                String(expressionEvaluator?.evaluate(exp))
+              );
+            } catch (error) {
+              const state = this.getState();
+              if (error instanceof Error && state.status === 'in-progress') {
+                state.fail(error);
+              }
+            }
           });
         }
 

package/src/string-resolver/index.ts

@@ -160,6 +160,7 @@ function traverseObject<T>(val: T, options: Options): T {
     }
 
     case 'object': {
+      if (!val) return val;
       // TODO: Do we care refs in keys?
       const keys = Object.keys(val);
       let newVal = val;

package/src/validator/validation-middleware.ts

@@ -12,13 +12,23 @@ import type { Logger } from '../logger';
 
 import type { ValidationResponse } from './types';
 
+/**
+ * A BindingInstance with an indicator of whether or not it's a strong binding
+ */
+export type StrongOrWeakBinding = {
+  /** BindingInstance in question */
+  binding: BindingInstance;
+  /** Boolean indicating whether the relevant BindingInstance is a strong binding */
+  isStrong: boolean;
+};
+
 /**
  * Returns a validation object if the data is invalid or an set of BindingsInstances if the binding itself is a weak ref of another invalid validation
  */
 export type MiddlewareChecker = (
   binding: BindingInstance,
   model: DataModelImpl
-) => ValidationResponse | Set<BindingInstance> | undefined;
+) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
 
 /**
  * Middleware for the data-model that caches the results of invalid data
@@ -60,7 +70,12 @@ export class ValidationMiddleware implements DataModelMiddleware {
       if (validations === undefined) {
         nextTransaction.push([binding, value]);
       } else if (validations instanceof Set) {
-        invalidBindings.push(...validations);
+        validations.forEach((validation) => {
+          invalidBindings.push(validation.binding);
+          if (!validation.isStrong) {
+            nextTransaction.push([validation.binding, value]);
+          }
+        });
       } else {
         this.logger?.debug(
           `Invalid value for path: ${binding.asString()} - ${
@@ -75,7 +90,10 @@ export class ValidationMiddleware implements DataModelMiddleware {
       nextTransaction.forEach(([binding]) =>
         this.shadowModelPaths.delete(binding)
       );
-      return next.set(nextTransaction, options);
+      const result = next.set(nextTransaction, options);
+      if (invalidBindings.length === 0) {
+        return result;
+      }
     }
 
     return invalidBindings.map((binding) => {

package/src/view/plugins/string-resolver.ts

@@ -108,6 +108,12 @@ const findBasePath = (node: Node.Node): Node.PathSegment[] => {
 
 /** A plugin that resolves all string references for each node */
 export default class StringResolverPlugin implements ViewPlugin {
+  private propertiesToSkipCache: Map<string, Set<string>>;
+
+  constructor() {
+    this.propertiesToSkipCache = new Map();
+  }
+
   applyResolver(resolver: Resolver) {
     resolver.hooks.resolve.tap('string-resolver', (value, node, options) => {
       if (node.type === NodeType.Empty || node.type === NodeType.Unknown) {
@@ -120,11 +126,27 @@ export default class StringResolverPlugin implements ViewPlugin {
         node.type === NodeType.View
       ) {
         /** Use specified properties to skip during string resolution, or default */
-        const propsToSkip = new Set<string>(
-          node.plugins?.stringResolver?.propertiesToSkip
-            ? node.plugins?.stringResolver?.propertiesToSkip
-            : []
-        );
+        let propsToSkip: Set<string>;
+        if (node.type === NodeType.Asset || node.type === NodeType.View) {
+          propsToSkip = new Set(
+            node.plugins?.stringResolver?.propertiesToSkip ?? ['exp']
+          );
+          if (node.value?.id) {
+            this.propertiesToSkipCache.set(node.value.id, propsToSkip);
+          }
+        } else if (
+          node.parent?.type === NodeType.MultiNode &&
+          (node.parent?.parent?.type === NodeType.Asset ||
+            node.parent?.parent?.type === NodeType.View) &&
+          node.parent.parent.value?.id &&
+          this.propertiesToSkipCache.has(node.parent.parent.value.id)
+        ) {
+          propsToSkip = this.propertiesToSkipCache.get(
+            node.parent.parent.value.id
+          ) as Set<string>;
+        } else {
+          propsToSkip = new Set(['exp']);
+        }
 
         const nodePath = findBasePath(node);