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

package/dist/index.cjs.js

@@ -847,6 +847,15 @@ function throwError(message, index) {
   err.description = message;
   throw err;
 }
+function createSpanningLocation(start, end) {
+  if (!start || !end) {
+    return;
+  }
+  return {
+    start: start.start,
+    end: end.end
+  };
+}
 function getMaxKeyLen(obj) {
   let maxLen = 0;
   Object.keys(obj).forEach((key) => {
@@ -868,7 +877,7 @@ const thisStr = "this";
 function binaryPrecedence(opVal) {
   return binaryOps[opVal] || 0;
 }
-function createBinaryExpression(operator, left, right) {
+function createBinaryExpression(operator, left, right, location) {
   let type;
   if (operator === "||" || operator === "&&") {
     type = "LogicalExpression";
@@ -884,7 +893,8 @@ function createBinaryExpression(operator, left, right) {
     type,
     operator,
     left,
-    right
+    right,
+    location
   };
 }
 function isDecimalDigit(ch) {
@@ -904,6 +914,16 @@ function parseExpression(expr) {
   const charCodeAtFunc = expr.charCodeAt;
   const { length } = expr;
   let index = 0;
+  const getLocation = (startChar) => {
+    return {
+      start: {
+        character: startChar
+      },
+      end: {
+        character: index
+      }
+    };
+  };
   function exprI(i) {
     return charAtFunc.call(expr, i);
   }
@@ -917,6 +937,7 @@ function parseExpression(expr) {
     let key;
     let value;
     let chCode;
+    const startCharIndex = index;
     ++index;
     while (index < length) {
       gobbleSpaces();
@@ -962,7 +983,8 @@ function parseExpression(expr) {
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: "Object",
-      attributes
+      attributes,
+      location: getLocation(startCharIndex)
     };
   }
   function gobbleSpaces() {
@@ -974,6 +996,7 @@ function parseExpression(expr) {
   function gobbleExpression() {
     const test = gobbleBinaryExpression();
     gobbleSpaces();
+    const startCharIndex = index;
     if (index < length && exprICode(index) === QUMARK_CODE) {
       index++;
       const consequent = gobbleExpression();
@@ -992,7 +1015,8 @@ function parseExpression(expr) {
           type: "ConditionalExpression",
           test,
           consequent,
-          alternate
+          alternate,
+          location: getLocation(startCharIndex)
         };
       }
       throwError("Expected :", index);
@@ -1038,7 +1062,7 @@ function parseExpression(expr) {
         right = stack.pop();
         biop = stack.pop().value;
         left = stack.pop();
-        node = createBinaryExpression(biop, left, right);
+        node = createBinaryExpression(biop, left, right, createSpanningLocation(left.location, right.location));
         stack.push(node);
       }
       node = gobbleToken();
@@ -1051,7 +1075,7 @@ function parseExpression(expr) {
     i = stack.length - 1;
     node = stack[i];
     while (i > 1) {
-      node = createBinaryExpression(stack[i - 1].value, stack[i - 2], node);
+      node = createBinaryExpression(stack[i - 1].value, stack[i - 2], node, createSpanningLocation(stack[i - 2].location, node.location));
       i -= 2;
     }
     return node;
@@ -1059,6 +1083,7 @@ function parseExpression(expr) {
   function gobbleToken() {
     gobbleSpaces();
     const ch = exprICode(index);
+    const startCharIndex = index;
     if (isDecimalDigit(ch) || ch === PERIOD_CODE) {
       return gobbleNumericLiteral();
     }
@@ -1087,7 +1112,8 @@ function parseExpression(expr) {
           type: "UnaryExpression",
           operator: toCheck,
           argument: gobbleToken(),
-          prefix: true
+          prefix: true,
+          location: getLocation(startCharIndex)
         };
       }
       toCheck = toCheck.substr(0, --tcLen);
@@ -1096,6 +1122,7 @@ function parseExpression(expr) {
   }
   function gobbleNumericLiteral() {
     let num = "";
+    const startCharIndex = index;
     while (isDecimalDigit(exprICode(index))) {
       num += exprI(index++);
     }
@@ -1129,13 +1156,15 @@ function parseExpression(expr) {
       __id: ExpNodeOpaqueIdentifier,
       type: "Literal",
       value: parseFloat(num),
-      raw: num
+      raw: num,
+      location: getLocation(startCharIndex)
     };
   }
   function gobbleStringLiteral() {
     const quote = exprI(index++);
     let str = "";
     let closed = false;
+    const startCharIndex = index;
     while (index < length) {
       let ch = exprI(index++);
       if (ch === quote) {
@@ -1175,13 +1204,15 @@ function parseExpression(expr) {
       __id: ExpNodeOpaqueIdentifier,
       type: "Literal",
       value: str,
-      raw: `${quote}${str}${quote}`
+      raw: `${quote}${str}${quote}`,
+      location: getLocation(startCharIndex)
     };
   }
   function gobbleModelRef() {
     let str = "";
     let closed = false;
     let openBraceCount = 1;
+    const startCharIndex = index;
     index += 2;
     while (index < length) {
       const ch = exprI(index++);
@@ -1207,7 +1238,8 @@ function parseExpression(expr) {
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: "ModelRef",
-      ref: str
+      ref: str,
+      location: getLocation(startCharIndex)
     };
   }
   function gobbleIdentifier() {
@@ -1232,19 +1264,22 @@ function parseExpression(expr) {
         __id: ExpNodeOpaqueIdentifier,
         type: "Literal",
         value: literals[identifier],
-        raw: identifier
+        raw: identifier,
+        location: getLocation(start)
       };
     }
     if (identifier === thisStr) {
       return {
         __id: ExpNodeOpaqueIdentifier,
-        type: "ThisExpression"
+        type: "ThisExpression",
+        location: getLocation(start)
       };
     }
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: "Identifier",
-      name: identifier
+      name: identifier,
+      location: getLocation(start)
     };
   }
   function gobbleArguments(termination) {
@@ -1273,6 +1308,7 @@ function parseExpression(expr) {
   function gobbleVariable() {
     let charIndex = exprICode(index);
     let node = charIndex === OPAREN_CODE ? gobbleGroup() : gobbleIdentifier();
+    const startCharIndex = index;
     gobbleSpaces();
     charIndex = exprICode(index);
     while (charIndex === PERIOD_CODE || charIndex === OBRACK_CODE || charIndex === OPAREN_CODE) {
@@ -1284,7 +1320,8 @@ function parseExpression(expr) {
           type: "MemberExpression",
           computed: false,
           object: node,
-          property: gobbleIdentifier()
+          property: gobbleIdentifier(),
+          location: getLocation(startCharIndex)
         };
       } else if (charIndex === OBRACK_CODE) {
         node = {
@@ -1292,7 +1329,8 @@ function parseExpression(expr) {
           type: "MemberExpression",
           computed: true,
           object: node,
-          property: gobbleExpression()
+          property: gobbleExpression(),
+          location: getLocation(startCharIndex)
         };
         gobbleSpaces();
         charIndex = exprICode(index);
@@ -1305,7 +1343,8 @@ function parseExpression(expr) {
           __id: ExpNodeOpaqueIdentifier,
           type: "CallExpression",
           args: gobbleArguments(CPAREN_CODE),
-          callTarget: node
+          callTarget: node,
+          location: getLocation(startCharIndex)
         };
       }
       gobbleSpaces();
@@ -1324,11 +1363,13 @@ function parseExpression(expr) {
     throwError("Unclosed (", index);
   }
   function gobbleArray() {
+    const startCharIndex = index;
     index++;
     return {
       __id: ExpNodeOpaqueIdentifier,
       type: "ArrayExpression",
-      elements: gobbleArguments(CBRACK_CODE)
+      elements: gobbleArguments(CBRACK_CODE),
+      location: getLocation(startCharIndex)
     };
   }
   const nodes = [];
@@ -1351,7 +1392,8 @@ function parseExpression(expr) {
   return {
     __id: ExpNodeOpaqueIdentifier,
     type: "Compound",
-    body: nodes
+    body: nodes,
+    location: getLocation(0)
   };
 }
 
@@ -1629,6 +1671,76 @@ class ExpressionEvaluator {
 function withoutContext(fn) {
   return (_context, ...args) => fn(...args);
 }
+function isInRange(position, location) {
+  return position.character >= location.start.character && position.character <= location.end.character;
+}
+function findClosestNodeAtPosition(node, position) {
+  var _a, _b, _c, _d, _e;
+  switch (node.type) {
+    case "Modification":
+    case "Assignment":
+    case "LogicalExpression":
+    case "BinaryExpression": {
+      const check = (_a = findClosestNodeAtPosition(node.left, position)) != null ? _a : findClosestNodeAtPosition(node.right, position);
+      if (check) {
+        return check;
+      }
+      break;
+    }
+    case "UnaryExpression": {
+      const checkArg = findClosestNodeAtPosition(node.argument, position);
+      if (checkArg) {
+        return checkArg;
+      }
+      break;
+    }
+    case "MemberExpression": {
+      const checkObject = (_b = findClosestNodeAtPosition(node.object, position)) != null ? _b : findClosestNodeAtPosition(node.property, position);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "ConditionalExpression": {
+      const checkObject = (_d = (_c = findClosestNodeAtPosition(node.test, position)) != null ? _c : findClosestNodeAtPosition(node.consequent, position)) != null ? _d : findClosestNodeAtPosition(node.alternate, position);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "ArrayExpression":
+    case "Compound": {
+      const elements = node.type === "ArrayExpression" ? node.elements : node.body;
+      const anyElements = elements.find((e) => findClosestNodeAtPosition(e, position));
+      if (anyElements) {
+        return anyElements;
+      }
+      break;
+    }
+    case "Object": {
+      const checkObject = node.attributes.reduce((found, next) => {
+        var _a2;
+        return (_a2 = found != null ? found : findClosestNodeAtPosition(next.key, position)) != null ? _a2 : findClosestNodeAtPosition(next.value, position);
+      }, void 0);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "CallExpression": {
+      const anyArgs = (_e = node.args.find((arg) => {
+        return findClosestNodeAtPosition(arg, position);
+      })) != null ? _e : findClosestNodeAtPosition(node.callTarget, position);
+      if (anyArgs) {
+        return anyArgs;
+      }
+      break;
+    }
+  }
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}
 
 const severities = ["trace", "debug", "info", "warn", "error"];
 
@@ -1965,6 +2077,8 @@ function traverseObject(val, options) {
       return resolveDataRefsInString(val, options);
     }
     case "object": {
+      if (!val)
+        return val;
       const keys = Object.keys(val);
       let newVal = val;
       if (keys.length > 0) {
@@ -2020,14 +2134,22 @@ class ValidationMiddleware {
       if (validations === void 0) {
         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 {
         (_a = this.logger) == null ? void 0 : _a.debug(`Invalid value for path: ${binding.asString()} - ${validations.severity} - ${validations.message}`);
       }
     });
     if (next && nextTransaction.length > 0) {
       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) => {
       return {
@@ -2693,14 +2815,27 @@ const findBasePath = (node) => {
   return findBasePath(parentNode);
 };
 class StringResolverPlugin {
+  constructor() {
+    this.propertiesToSkipCache = new Map();
+  }
   applyResolver(resolver) {
     resolver.hooks.resolve.tap("string-resolver", (value, node, options) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
       if (node.type === exports.NodeType.Empty || node.type === exports.NodeType.Unknown) {
         return null;
       }
       if (node.type === exports.NodeType.Value || node.type === exports.NodeType.Asset || node.type === exports.NodeType.View) {
-        const propsToSkip = new Set(((_b = (_a = node.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip) ? (_d = (_c = node.plugins) == null ? void 0 : _c.stringResolver) == null ? void 0 : _d.propertiesToSkip : []);
+        let propsToSkip;
+        if (node.type === exports.NodeType.Asset || node.type === exports.NodeType.View) {
+          propsToSkip = new Set((_c = (_b = (_a = node.plugins) == null ? void 0 : _a.stringResolver) == null ? void 0 : _b.propertiesToSkip) != null ? _c : ["exp"]);
+          if ((_d = node.value) == null ? void 0 : _d.id) {
+            this.propertiesToSkipCache.set(node.value.id, propsToSkip);
+          }
+        } else if (((_e = node.parent) == null ? void 0 : _e.type) === exports.NodeType.MultiNode && (((_g = (_f = node.parent) == null ? void 0 : _f.parent) == null ? void 0 : _g.type) === exports.NodeType.Asset || ((_i = (_h = node.parent) == null ? void 0 : _h.parent) == null ? void 0 : _i.type) === exports.NodeType.View) && ((_j = node.parent.parent.value) == null ? void 0 : _j.id) && this.propertiesToSkipCache.has(node.parent.parent.value.id)) {
+          propsToSkip = this.propertiesToSkipCache.get(node.parent.parent.value.id);
+        } else {
+          propsToSkip = new Set(["exp"]);
+        }
         const nodePath = findBasePath(node);
         if (nodePath.length > 0 && nodePath.some((segment) => propsToSkip.has(segment.toString()))) {
           return node.value;
@@ -3526,19 +3661,30 @@ class ValidationController {
   getDataMiddleware() {
     return [
       new ValidationMiddleware((binding) => {
+        var _a;
         if (!this.options) {
           return;
         }
         this.updateValidationsForBinding(binding, "change", this.options);
         const strongValidation = this.getValidationForBinding(binding);
-        if (strongValidation == null ? void 0 : strongValidation.get())
+        if (((_a = strongValidation == null ? void 0 : strongValidation.get()) == null ? void 0 : _a.severity) === "error") {
           return strongValidation.get();
+        }
         const newInvalidBindings = new Set();
-        for (const [, weakValidation] of Array.from(this.validations)) {
-          if (caresAboutDataChanges(new Set([binding]), weakValidation.weakBindings) && (weakValidation == null ? void 0 : weakValidation.get())) {
-            weakValidation == null ? void 0 : weakValidation.weakBindings.forEach(newInvalidBindings.add, newInvalidBindings);
+        this.validations.forEach((weakValidation, strongBinding) => {
+          var _a2;
+          if (caresAboutDataChanges(new Set([binding]), weakValidation.weakBindings) && ((_a2 = weakValidation == null ? void 0 : weakValidation.get()) == null ? void 0 : _a2.severity) === "error") {
+            weakValidation == null ? void 0 : weakValidation.weakBindings.forEach((weakBinding) => {
+              weakBinding === strongBinding ? newInvalidBindings.add({
+                binding: weakBinding,
+                isStrong: true
+              }) : newInvalidBindings.add({
+                binding: weakBinding,
+                isStrong: false
+              });
+            });
           }
-        }
+        });
         if (newInvalidBindings.size > 0) {
           return newInvalidBindings;
         }
@@ -3564,7 +3710,9 @@ class ValidationController {
             ignoreDefaultValue: true
           });
           if (originalValue !== withoutDefault) {
-            this.options.model.set([[binding, originalValue]]);
+            this.options.model.set([[binding, originalValue]], {
+              silent: true
+            });
           }
           this.updateValidationsForBinding(binding, "load", this.options, () => {
             view.update(new Set([binding]));
@@ -3604,7 +3752,7 @@ class ValidationController {
       this.validations.forEach((validation, vBinding) => {
         if (vBinding !== binding && caresAboutDataChanges(new Set([binding]), validation.weakBindings)) {
           validation.update(trigger, true, (validationObj) => {
-            const response = this.validationRunner(validationObj, context, binding);
+            const response = this.validationRunner(validationObj, context, vBinding);
             return response ? { message: response.message } : void 0;
           });
         }
@@ -3691,16 +3839,16 @@ class ValidationController {
     return (_b = (_a = this.tracker) == null ? void 0 : _a.getBindings()) != null ? _b : new Set();
   }
   validateView(trigger = "navigation") {
-    var _a, _b;
     this.updateValidationsForView(trigger);
     const validations = new Map();
-    for (const b of this.getBindings()) {
+    this.getBindings().forEach((b) => {
+      var _a, _b;
       const invalid = (_a = this.getValidationForBinding(b)) == null ? void 0 : _a.get();
       if (invalid) {
         (_b = this.options) == null ? void 0 : _b.logger.debug(`Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(invalid)}`);
         validations.set(b, invalid);
       }
-    }
+    });
     return {
       canTransition: validations.size === 0,
       validations: validations.size ? validations : void 0
@@ -4070,8 +4218,9 @@ class DataController {
       }
     });
     this.hooks.onSet.call(normalizedTransaction);
+    this.hooks.onSet.call(normalizedTransaction);
     if (setUpdates.length > 0) {
-      this.hooks.onUpdate.call(setUpdates);
+      this.hooks.onUpdate.call(setUpdates, options);
     }
     return result;
   }
@@ -4272,8 +4421,8 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const PLAYER_VERSION = "0.3.1-next.1";
-const COMMIT = "b51603be07572111ca68e73d1b710ed2d0aa9412";
+const PLAYER_VERSION = "0.4.0-next.1";
+const COMMIT = "f66def4fd8f14f4898927c9ff6061d6094b7b250";
 const _Player = class {
   constructor(config) {
     this.logger = new TapableLogger();
@@ -4400,17 +4549,18 @@ const _Player = class {
     }
     flowController.hooks.flow.tap("player", (flow) => {
       flow.hooks.beforeTransition.tap("player", (state, transitionVal) => {
-        if (state.onEnd && (state.transitions[transitionVal] || state.transitions["*"])) {
+        const computedTransitionVal = state.transitions[transitionVal] ? transitionVal : "*";
+        if (state.onEnd && state.transitions[computedTransitionVal]) {
           if (typeof state.onEnd === "object" && "exp" in state.onEnd) {
             expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(state.onEnd.exp);
           } else {
             expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(state.onEnd);
           }
         }
-        if (!("transitions" in state) || !state.transitions[transitionVal]) {
+        if (!("transitions" in state) || !state.transitions[computedTransitionVal]) {
           return state;
         }
-        return timm.setIn(state, ["transitions", transitionVal], resolveStrings(state.transitions[transitionVal]));
+        return timm.setIn(state, ["transitions", computedTransitionVal], resolveStrings(state.transitions[computedTransitionVal]));
       });
       flow.hooks.skipTransition.tap("validation", (currentState) => {
         var _a;
@@ -4438,7 +4588,14 @@ const _Player = class {
         if (newState.value.state_type === "ACTION") {
           const { exp } = newState.value;
           queueMicrotask__default["default"](() => {
-            flowController == null ? void 0 : flowController.transition(String(expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp)));
+            try {
+              flowController == null ? void 0 : flowController.transition(String(expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp)));
+            } catch (error) {
+              const state = this.getState();
+              if (error instanceof Error && state.status === "in-progress") {
+                state.fail(error);
+              }
+            }
           });
         }
         expressionEvaluator.reset();
@@ -4604,6 +4761,7 @@ exports.ViewController = ViewController;
 exports.ViewInstance = ViewInstance;
 exports.caresAboutDataChanges = caresAboutDataChanges;
 exports.constructModelForPipeline = constructModelForPipeline;
+exports.findClosestNodeAtPosition = findClosestNodeAtPosition;
 exports.findInArray = findInArray;
 exports.findNextExp = findNextExp;
 exports.getBindingSegments = getBindingSegments;

package/dist/index.d.ts

@@ -165,6 +165,10 @@ interface DataModelOptions {
      * A flag to set to ignore any default value in the schema, and just use the raw value
      */
     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 */
@@ -370,11 +374,23 @@ declare type ExpressionHandler<T extends readonly unknown[] = unknown[], R = voi
 declare const ExpNodeOpaqueIdentifier: unique symbol;
 /** Checks if the input is an already processed Expression node */
 declare function isExpressionNode(x: any): x is ExpressionNode;
+interface NodePosition {
+    /** The character location */
+    character: number;
+}
+interface NodeLocation {
+    /** The start of the node */
+    start: NodePosition;
+    /** The end of the node */
+    end: NodePosition;
+}
 interface BaseNode<T> {
     /** The thing to discriminate the AST type on */
     type: T;
     /** How to tell this apart from other objects */
     __id: typeof ExpNodeOpaqueIdentifier;
+    /** The location of the node in the source expression string */
+    location?: NodeLocation;
 }
 /** A helper interface for nodes that container left and right children */
 interface DirectionalNode {
@@ -393,11 +409,7 @@ interface BinaryNode extends BaseNode<'BinaryExpression'>, DirectionalNode {
     /** The operation to perform on the nodes */
     operator: string;
 }
-interface LogicalNode extends BaseNode<'LogicalExpression'> {
-    /** The left hand side of the equation */
-    left: any;
-    /** The right hand side of the equation */
-    right: any;
+interface LogicalNode extends BaseNode<'LogicalExpression'>, DirectionalNode {
     /** The logical operation to perform on the nodes */
     operator: string;
 }
@@ -405,7 +417,7 @@ interface UnaryNode extends BaseNode<'UnaryExpression'> {
     /** The operation to perform on the node */
     operator: string;
     /** The single argument that the operation should be performed on */
-    argument: any;
+    argument: ExpressionNode;
 }
 declare type ThisNode = BaseNode<'ThisExpression'>;
 interface ModelRefNode extends BaseNode<'ModelRef'> {
@@ -416,9 +428,9 @@ interface ObjectNode extends BaseNode<'Object'> {
     /**  */
     attributes: Array<{
         /** The property name of the object */
-        key: any;
+        key: ExpressionNode;
         /** the associated value */
-        value: any;
+        value: ExpressionNode;
     }>;
 }
 interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
@@ -443,13 +455,13 @@ interface CompoundNode extends BaseNode<'Compound'> {
 }
 interface CallExpressionNode extends BaseNode<'CallExpression'> {
     /** The arguments to the function */
-    args: any[];
+    args: ExpressionNode[];
     /** The function name */
     callTarget: IdentifierNode;
 }
 interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
     /** The items in an array */
-    elements: any[];
+    elements: ExpressionNode[];
 }
 interface IdentifierNode extends BaseNode<'Identifier'> {
     /** The variable name */
@@ -505,6 +517,8 @@ declare class ExpressionEvaluator {
 
 /** Generates a function by removing the first context argument */
 declare function withoutContext<T extends unknown[], Return>(fn: (...args: T) => Return): ExpressionHandler<T, Return>;
+/** Get the node in the expression that's closest to the desired position */
+declare function findClosestNodeAtPosition(node: ExpressionNode, position: NodePosition): ExpressionNode | undefined;
 
 declare type FormatOptions = Omit<Formatting.Reference, 'type'>;
 /**
@@ -961,6 +975,8 @@ declare class TemplatePlugin implements ViewPlugin {
 
 /** A plugin that resolves all string references for each node */
 declare class StringResolverPlugin implements ViewPlugin {
+    private propertiesToSkipCache;
+    constructor();
     applyResolver(resolver: Resolver): void;
     apply(view: View): void;
 }
@@ -1275,7 +1291,7 @@ declare class DataController implements DataModelWithParser<DataModelOptions> {
         onDelete: SyncHook<[any], Record<string, any>>;
         onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
         onGet: SyncHook<[any, any], Record<string, any>>;
-        onUpdate: SyncHook<[Updates], Record<string, any>>;
+        onUpdate: SyncHook<[Updates, DataModelOptions | undefined], Record<string, any>>;
         format: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
         deformat: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
         serialize: SyncWaterfallHook<[any], Record<string, any>>;
@@ -1434,10 +1450,19 @@ interface ValidatorContext {
 }
 declare type ValidatorFunction<Options = unknown> = (context: ValidatorContext, value: any, options?: Options) => Omit<BaseValidationResponse, 'severity'> | undefined;
 
+/**
+ * A BindingInstance with an indicator of whether or not it's a strong binding
+ */
+declare 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
  */
-declare type MiddlewareChecker = (binding: BindingInstance, model: DataModelImpl) => ValidationResponse | Set<BindingInstance> | undefined;
+declare type MiddlewareChecker = (binding: BindingInstance, model: DataModelImpl) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
 /**
  * Middleware for the data-model that caches the results of invalid data
  */
@@ -1611,4 +1636,4 @@ declare class FlowExpPlugin implements PlayerPlugin {
     apply(player: Player): void;
 }
 
-export { AnyAssetType, ApplicabilityPlugin, ArrayExpressionNode, AssetTransformCorePlugin, AssignmentNode, BaseFlowState, BaseNode, BatchSetTransaction, BeforeTransformFunction, BinaryNode, BinaryOperator, BinaryOperatorAdvanced, BinaryOperatorBasic, BindingFactory, BindingInstance, BindingLike, BindingParser, BindingParserOptions, BindingTracker, Builder, CallExpressionNode, CompletedState, CompoundNode, ConditionalExpressionNode, ConsoleLogger, ConstantsController, ConstantsProvider, ControllerState, DataController, DataModelImpl, DataModelMiddleware, DataModelOptions, DataModelWithParser, DataPipeline, DependencyMiddleware, DependencyModel, DependencySets, DependencyTracker, DirectionalNode, EMPTY_NODE, ErrorState, ErrorValidationResponse, ExpNodeOpaqueIdentifier, ExpressionContext, ExpressionEvaluator, ExpressionEvaluatorFunction, ExpressionEvaluatorOptions, ExpressionHandler, ExpressionLiteralType, ExpressionNode, ExpressionNodeType, ExpressionType, FlowController, FlowExpPlugin, FlowInstance, FormatDefinition, FormatFunction, FormatHandler, FormatOptions, FormatType, Getter, HookOptions, IdentifierNode, InProgressState, LiteralNode, LocalModel, LocalStateStore, LogFn, Logger, LoggerProvider, LogicalNode, MemberExpressionNode, MiddlewareChecker, ModelRefNode, ModificationNode, NOOPDataModel, NOOP_MODEL, NOT_STARTED_STATE, NamedState, Node, NodeType, NoopLogger, NotStartedState, ObjectNode, OperatorProcessingOptions, Options, ParseObjectOptions, Parser, PipelinedDataModel, Player, PlayerConfigOptions, PlayerFlowExecutionData, PlayerFlowState, PlayerFlowStatus, PlayerInfo, PlayerPlugin, ProxyLogger, ROOT_BINDING, RawBinding, RawBindingSegment, RawSetTransaction, RawSetType, Resolve, Resolver, SIMPLE_BINDING_REGEX, SchemaController, Severity, StatefulValidationObject, Store, StringResolverPlugin, SwitchPlugin, TapableLogger, TemplatePlugin, ThisNode, TransformFunction, TransformFunctions, TransformRegistry, TransitionFunction, TransitionOptions, UnaryNode, UnaryOperator, Updates, ValidationBindingTrackerViewPlugin, ValidationController, ValidationMiddleware, ValidationObject, ValidationProvider, ValidationResponse, ValidatorContext, ValidatorFunction, ValidatorRegistry, ViewController, ViewControllerOptions, ViewInstance, ViewPlugin, WarningValidationResponse, caresAboutDataChanges, constructModelForPipeline, findInArray, findNextExp, getBindingSegments, isBinding, isExpressionNode, maybeConvertToNum, parse, resolveDataRefs, resolveDataRefsInString, resolveExpressionsInString, severities, toModel, toNodeResolveOptions, withParser, withoutContext };
+export { AnyAssetType, ApplicabilityPlugin, ArrayExpressionNode, AssetTransformCorePlugin, AssignmentNode, BaseFlowState, BaseNode, BatchSetTransaction, BeforeTransformFunction, BinaryNode, BinaryOperator, BinaryOperatorAdvanced, BinaryOperatorBasic, BindingFactory, BindingInstance, BindingLike, BindingParser, BindingParserOptions, BindingTracker, Builder, CallExpressionNode, CompletedState, CompoundNode, ConditionalExpressionNode, ConsoleLogger, ConstantsController, ConstantsProvider, ControllerState, DataController, DataModelImpl, DataModelMiddleware, DataModelOptions, DataModelWithParser, DataPipeline, DependencyMiddleware, DependencyModel, DependencySets, DependencyTracker, DirectionalNode, EMPTY_NODE, ErrorState, ErrorValidationResponse, ExpNodeOpaqueIdentifier, ExpressionContext, ExpressionEvaluator, ExpressionEvaluatorFunction, ExpressionEvaluatorOptions, ExpressionHandler, ExpressionLiteralType, ExpressionNode, ExpressionNodeType, ExpressionType, FlowController, FlowExpPlugin, FlowInstance, FormatDefinition, FormatFunction, FormatHandler, FormatOptions, FormatType, Getter, HookOptions, IdentifierNode, InProgressState, LiteralNode, LocalModel, LocalStateStore, LogFn, Logger, LoggerProvider, LogicalNode, MemberExpressionNode, MiddlewareChecker, ModelRefNode, ModificationNode, NOOPDataModel, NOOP_MODEL, NOT_STARTED_STATE, NamedState, Node, NodeLocation, NodePosition, NodeType, NoopLogger, NotStartedState, ObjectNode, OperatorProcessingOptions, Options, ParseObjectOptions, Parser, PipelinedDataModel, Player, PlayerConfigOptions, PlayerFlowExecutionData, PlayerFlowState, PlayerFlowStatus, PlayerInfo, PlayerPlugin, ProxyLogger, ROOT_BINDING, RawBinding, RawBindingSegment, RawSetTransaction, RawSetType, Resolve, Resolver, SIMPLE_BINDING_REGEX, SchemaController, Severity, StatefulValidationObject, Store, StringResolverPlugin, StrongOrWeakBinding, SwitchPlugin, TapableLogger, TemplatePlugin, ThisNode, TransformFunction, TransformFunctions, TransformRegistry, TransitionFunction, TransitionOptions, UnaryNode, UnaryOperator, Updates, ValidationBindingTrackerViewPlugin, ValidationController, ValidationMiddleware, ValidationObject, ValidationProvider, ValidationResponse, ValidatorContext, ValidatorFunction, ValidatorRegistry, ViewController, ViewControllerOptions, ViewInstance, ViewPlugin, WarningValidationResponse, caresAboutDataChanges, constructModelForPipeline, findClosestNodeAtPosition, findInArray, findNextExp, getBindingSegments, isBinding, isExpressionNode, maybeConvertToNum, parse, resolveDataRefs, resolveDataRefsInString, resolveExpressionsInString, severities, toModel, toNodeResolveOptions, withParser, withoutContext };