@2112-lab/central-plant 0.3.34 → 0.3.35

package/dist/esm/src/managers/behaviors/IoBehaviorManager.js

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray, toConsumableArray as _toConsumableArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray, objectSpread2 as _objectSpread2, toConsumableArray as _toConsumableArray, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { BaseDisposable } from '../../core/baseDisposable.js';
 
@@ -18,6 +18,24 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
      * }>
      */
     _this._entries = new Map();
+    _this._crossComponentBehaviors = [];
+
+    /**
+     * Map: `${componentUuid}` → Array<{ id, input, outputs }>
+     * Component-level behaviors for intra-component io-device linking
+     */
+    _this._componentBehaviors = new Map();
+
+    /**
+     * Injected by the host application to read and write I/O device state.
+     * Set via configure(). Shape:
+     *   {
+     *     getState(attachmentId, dataPointId) -> value | null,
+     *     setState(attachmentId, dataPointId, value) -> void
+     *   }
+     * @type {{ getState: Function, setState: Function } | null}
+     */
+    _this._stateAdapter = null;
     return _this;
   }
 
@@ -115,29 +133,485 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "triggerState",
     value: function triggerState(attachmentId, dataPointId, value, parentUuid) {
-      var _iterator2 = _createForOfIteratorHelper(this._entries.values()),
-        _step2;
-      try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var entries = _step2.value;
-          var _iterator3 = _createForOfIteratorHelper(entries),
-            _step3;
+      var _this$_crossComponent;
+      console.log("[Behavior] triggerState called:", {
+        attachmentId: attachmentId,
+        dataPointId: dataPointId,
+        value: value,
+        parentUuid: parentUuid
+      });
+      if (parentUuid) {
+        var key = this._key(parentUuid, attachmentId);
+        var entries = this._entries.get(key);
+        if (entries) {
+          var _iterator2 = _createForOfIteratorHelper(entries),
+            _step2;
           try {
-            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-              var entry = _step3.value;
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var entry = _step2.value;
               if (entry.anim.stateVariable !== dataPointId) continue;
               this._applyAnimation(entry, value);
             }
           } catch (err) {
-            _iterator3.e(err);
+            _iterator2.e(err);
           } finally {
-            _iterator3.f();
+            _iterator2.f();
+          }
+        }
+      } else {
+        // Fallback when parentUuid is not provided: match by attachmentId suffix or exact key match
+        var suffix = "::".concat(attachmentId);
+        var _iterator3 = _createForOfIteratorHelper(this._entries.entries()),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var _step3$value = _slicedToArray(_step3.value, 2),
+              _key2 = _step3$value[0],
+              _entries = _step3$value[1];
+            if (_key2 === attachmentId || _key2.endsWith(suffix)) {
+              var _iterator4 = _createForOfIteratorHelper(_entries),
+                _step4;
+              try {
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  var _entry = _step4.value;
+                  if (_entry.anim.stateVariable !== dataPointId) continue;
+                  this._applyAnimation(_entry, value);
+                }
+              } catch (err) {
+                _iterator4.e(err);
+              } finally {
+                _iterator4.f();
+              }
+            }
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+
+      // Evaluate component-level behaviors (intra-component io-device linking)
+      if (parentUuid && this._componentBehaviors.has(parentUuid)) {
+        var componentBehaviors = this._componentBehaviors.get(parentUuid);
+        console.log("[Behavior] Checking component-level behaviors for ".concat(parentUuid, " (count: ").concat(componentBehaviors.length, ")"));
+        this.triggerCrossComponentBehaviors(componentBehaviors, parentUuid, attachmentId, dataPointId, value);
+      }
+
+      // Evaluate cross-component behaviors if any are registered
+      console.log("[Behavior] Checking cross-component behaviors (count: ".concat(((_this$_crossComponent = this._crossComponentBehaviors) === null || _this$_crossComponent === void 0 ? void 0 : _this$_crossComponent.length) || 0, ")"));
+      if (this._crossComponentBehaviors && this._crossComponentBehaviors.length > 0) {
+        this.triggerCrossComponentBehaviors(this._crossComponentBehaviors, parentUuid, attachmentId, dataPointId, value);
+      }
+    }
+
+    /**
+     * Register the root-level cross-component behaviors from the scene.
+     * Normalizes shorthand syntax to full format.
+     *
+     * @param {Array} behaviors
+     */
+  }, {
+    key: "setCrossComponentBehaviors",
+    value: function setCrossComponentBehaviors(behaviors) {
+      var _this2 = this;
+      this._crossComponentBehaviors = (behaviors || []).map(function (b) {
+        return _this2._normalizeBehavior(b);
+      });
+      console.log("[Behavior] Loaded ".concat(this._crossComponentBehaviors.length, " cross-component behavior(s)"), this._crossComponentBehaviors);
+    }
+
+    /**
+     * Register component-level behaviors (intra-component io-device linking).
+     * These behaviors are defined in the smart component's JSON and link devices within the same component instance.
+     *
+     * @param {string} componentUuid - The UUID of the component
+     * @param {Array} behaviors - Array of behaviors in shorthand format
+     */
+  }, {
+    key: "registerComponentBehaviors",
+    value: function registerComponentBehaviors(componentUuid, behaviors) {
+      var _this3 = this;
+      if (!behaviors || behaviors.length === 0) return;
+      var normalized = behaviors.map(function (b) {
+        return _this3._normalizeBehavior(b);
+      });
+      this._componentBehaviors.set(componentUuid, normalized);
+      console.log("[Behavior] Registered ".concat(normalized.length, " component-level behavior(s) for component ").concat(componentUuid), normalized);
+    }
+
+    /**
+     * Normalize behavior from shorthand to full format.
+     * Supports:
+     *   - input: "attachment.state" → { attachment, state }
+     *   - outputs: ["attachment.state", ...] → converted to individual behaviors
+     *
+     * @param {Object} behavior - Raw behavior from scene JSON
+     * @returns {Object} Normalized behavior
+     */
+  }, {
+    key: "_normalizeBehavior",
+    value: function _normalizeBehavior(behavior) {
+      var normalized = _objectSpread2({}, behavior);
+
+      // Parse shorthand input: "attachment.state"
+      if (typeof behavior.input === 'string') {
+        var _behavior$input$split = behavior.input.split('.'),
+          _behavior$input$split2 = _slicedToArray(_behavior$input$split, 2),
+          attachment = _behavior$input$split2[0],
+          state = _behavior$input$split2[1];
+        normalized.input = {
+          attachment: attachment,
+          state: state
+        };
+      }
+
+      // Parse shorthand output/outputs
+      if (behavior.outputs) {
+        // Multiple outputs - expand to array
+        normalized._outputs = behavior.outputs.map(function (out) {
+          if (typeof out === 'string') {
+            var _out$split = out.split('.'),
+              _out$split2 = _slicedToArray(_out$split, 2),
+              _attachment = _out$split2[0],
+              _state = _out$split2[1];
+            return {
+              attachment: _attachment,
+              state: _state
+            };
+          }
+          return out;
+        });
+        delete normalized.outputs;
+      } else if (typeof behavior.output === 'string') {
+        // Single output string
+        var _behavior$output$spli = behavior.output.split('.'),
+          _behavior$output$spli2 = _slicedToArray(_behavior$output$spli, 2),
+          _attachment2 = _behavior$output$spli2[0],
+          _state2 = _behavior$output$spli2[1];
+        normalized.output = {
+          attachment: _attachment2,
+          state: _state2
+        };
+      }
+      return normalized;
+    }
+
+    /**
+     * Find the parent component UUID for a given attachment ID.
+     * Searches the scene tree for the io-device with this attachment ID,
+     * then returns its parentComponentId.
+     *
+     * @param {string} attachmentId
+     * @returns {string|null} Component UUID or null if not found
+     */
+  }, {
+    key: "_findComponentByAttachment",
+    value: function _findComponentByAttachment(attachmentId) {
+      var _this$sceneViewer;
+      if (!((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.scene)) return null;
+      var scene = this.sceneViewer.scene;
+      var found = null;
+      scene.traverse(function (obj) {
+        var _obj$userData, _obj$userData2;
+        if (found) return;
+        // Find the io-device object with this attachmentId
+        if (((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType) === 'io-device' && ((_obj$userData2 = obj.userData) === null || _obj$userData2 === void 0 ? void 0 : _obj$userData2.attachmentId) === attachmentId) {
+          found = obj.userData.parentComponentId;
+        }
+      });
+      if (!found) {
+        console.warn("[Behavior] Could not find parent component for attachment \"".concat(attachmentId, "\""));
+      }
+      return found;
+    }
+
+    /**
+     * Inject a state adapter so cross-component behaviors can write I/O device state.
+     * Call this once after the host application's state store is ready.
+     *
+     * @param {{ getState: Function, setState: Function }} stateAdapter
+     *   - getState(attachmentId, dataPointId) -> current value (any) | null
+     *   - setState(attachmentId, dataPointId, value) -> void
+     *
+     * @example
+     * // Sandbox (Vuex)
+     * ioBehaviorManager.configure({
+     *   getState: (attId, dpId) =>
+     *     store.getters['assetManagerStore/ioDeviceState'](attId)(dpId) ?? null,
+     *   setState: (attId, dpId, value) =>
+     *     store.dispatch('assetManagerStore/setIoDeviceState',
+     *       { attachmentId: attId, dataPointId: dpId, value })
+     * })
+     */
+  }, {
+    key: "configure",
+    value: function configure(stateAdapter) {
+      this._stateAdapter = stateAdapter || null;
+      console.log('[Behavior] State adapter configured:', !!this._stateAdapter);
+    }
+
+    /**
+     * Evaluate and apply cross-component behaviors loaded from the scene JSON.
+     *
+     * @param {Array} behaviors - Root-level behaviors array from the scene JSON
+     * @param {string} triggerParentUuid - Parent component UUID of the triggering device
+     * @param {string} triggerAttachmentId - Attachment ID of the triggering device
+     * @param {string} triggerStateId - The state variable ID that changed
+     * @param {*} value - The new state value
+     */
+  }, {
+    key: "triggerCrossComponentBehaviors",
+    value: function triggerCrossComponentBehaviors(behaviors, triggerParentUuid, triggerAttachmentId, triggerStateId, value) {
+      if (!behaviors || !Array.isArray(behaviors)) {
+        console.log('[Behavior] No behaviors to evaluate');
+        return;
+      }
+      console.log("[Behavior] Evaluating ".concat(behaviors.length, " behavior(s) for trigger: ").concat(triggerParentUuid, ".").concat(triggerAttachmentId, ".").concat(triggerStateId, " = ").concat(value));
+      var _iterator5 = _createForOfIteratorHelper(behaviors),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var behavior = _step5.value;
+          var input = behavior.input,
+            output = behavior.output,
+            _outputs = behavior._outputs,
+            conditions = behavior.conditions;
+          if (!input || !output && !_outputs) {
+            console.warn('[Behavior] Skipping behavior - missing input or output(s):', behavior);
+            continue;
+          }
+
+          // Auto-lookup component if not specified
+          var inputComponent = input.component || this._findComponentByAttachment(input.attachment);
+          console.log("[Behavior] Checking behavior \"".concat(behavior.id, "\":"), {
+            inputMatch: inputComponent === triggerParentUuid,
+            attachmentMatch: input.attachment === triggerAttachmentId,
+            stateMatch: input.state === triggerStateId,
+            expected: {
+              component: inputComponent,
+              attachment: input.attachment,
+              state: input.state
+            },
+            actual: {
+              component: triggerParentUuid,
+              attachment: triggerAttachmentId,
+              state: triggerStateId
+            }
+          });
+
+          // Verify that the input matches the triggering source
+          if (inputComponent === triggerParentUuid && input.attachment === triggerAttachmentId && input.state === triggerStateId) {
+            console.log("[Behavior] \u2713 Behavior \"".concat(behavior.id, "\" matched!"));
+
+            // Collect all outputs (single or multiple)
+            var outputs = _outputs || (output ? [output] : []);
+
+            // Process each output
+            var _iterator6 = _createForOfIteratorHelper(outputs),
+              _step6;
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var out = _step6.value;
+                // NEW: State-to-state pass-through pattern
+                if (out.state) {
+                  // Auto-lookup output component if not specified
+                  var outputComponent = out.component || this._findComponentByAttachment(out.attachment);
+
+                  // Direct state mapping without conditions
+                  if (this._stateAdapter) {
+                    console.log("[Behavior] Dispatching state-to-state: ".concat(out.attachment, ".").concat(out.state, " = ").concat(value));
+                    this._stateAdapter.setState(out.attachment, out.state, value);
+                    console.log("[Behavior] \u2713 State-to-state triggered: ".concat(input.attachment, ".").concat(input.state, " (").concat(value, ") \u2192 ").concat(out.attachment, ".").concat(out.state));
+
+                    // Trigger animations on the output component
+                    // triggerState(attachmentId, dataPointId, value, parentUuid)
+                    if (outputComponent) {
+                      console.log("[Behavior] Triggering animations on output component: ".concat(outputComponent, ".").concat(out.attachment, ".").concat(out.state));
+                      this.triggerState(out.attachment, out.state, value, outputComponent);
+                    } else {
+                      console.warn("[Behavior] Could not find component for attachment \"".concat(out.attachment, "\""));
+                    }
+                  } else {
+                    console.warn('[Behavior] ✗ State adapter not configured for state-to-state behavior');
+                  }
+                }
+                // LEGACY: Mesh-based pattern with conditions
+                else if (conditions && out.child) {
+                  console.log('[Behavior] Using legacy mesh-based pattern with conditions');
+                  // Evaluate conditions
+                  var _iterator7 = _createForOfIteratorHelper(conditions),
+                    _step7;
+                  try {
+                    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                      var condition = _step7.value;
+                      if (this._evaluateCondition(condition.when, value)) {
+                        // Apply actions to the target output component/attachment/child mesh
+                        this._applyCrossComponentActions(out, condition.actions);
+                      }
+                    }
+                  } catch (err) {
+                    _iterator7.e(err);
+                  } finally {
+                    _iterator7.f();
+                  }
+                } else {
+                  console.warn('[Behavior] Output has neither state nor (child + conditions):', out);
+                }
+              } // end outputs loop
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+    }
+
+    /**
+     * Safely evaluate a condition expression.
+     */
+  }, {
+    key: "_evaluateCondition",
+    value: function _evaluateCondition(whenExpr, value) {
+      try {
+        var fn = new Function('state', "return (".concat(whenExpr, ");"));
+        return fn({
+          value: value
+        });
+      } catch (err) {
+        console.warn("[IoBehaviorManager] Failed to evaluate condition: \"".concat(whenExpr, "\""), err);
+        return false;
+      }
+    }
+
+    /**
+     * Resolve target output mesh and apply actions.
+     */
+  }, {
+    key: "_applyCrossComponentActions",
+    value: function _applyCrossComponentActions(output, actions) {
+      var _this$sceneViewer2;
+      if (!actions || !Array.isArray(actions)) return;
+
+      // 1. Resolve output component
+      var scene = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.scene;
+      if (!scene) return;
+      var componentModel = scene.getObjectByProperty('uuid', output.component) || scene.getObjectByProperty('name', output.component);
+      if (!componentModel) {
+        console.warn("[IoBehaviorManager] Output component \"".concat(output.component, "\" not found in scene"));
+        return;
+      }
+
+      // 2. Resolve attachment model under the component
+      var deviceRoot = null;
+      componentModel.traverse(function (obj) {
+        var _obj$userData3;
+        if (!deviceRoot && ((_obj$userData3 = obj.userData) === null || _obj$userData3 === void 0 ? void 0 : _obj$userData3.attachmentId) === output.attachment) {
+          deviceRoot = obj;
+        }
+      });
+      if (!deviceRoot) {
+        console.warn("[IoBehaviorManager] Output attachment \"".concat(output.attachment, "\" not found on component \"").concat(output.component, "\""));
+        return;
+      }
+
+      // 3. Resolve child mesh if specified
+      var targetObj = deviceRoot;
+      if (output.child) {
+        var foundChild = null;
+        deviceRoot.traverse(function (obj) {
+          if (!foundChild && obj.name === output.child) {
+            foundChild = obj;
           }
+        });
+        if (foundChild) {
+          targetObj = foundChild;
+        } else {
+          console.warn("[IoBehaviorManager] Child \"".concat(output.child, "\" not found under attachment \"").concat(output.attachment, "\" on component \"").concat(output.component, "\""));
+          return;
+        }
+      }
+
+      // 4. Apply actions to targetObj
+      var _iterator8 = _createForOfIteratorHelper(actions),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var action = _step8.value;
+          this._applyCrossComponentAction(targetObj, action);
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator2.f();
+        _iterator8.f();
+      }
+    }
+
+    /**
+     * Apply a single action to the target mesh.
+     */
+  }, {
+    key: "_applyCrossComponentAction",
+    value: function _applyCrossComponentAction(targetObj, action) {
+      var set = action.set,
+        value = action.value;
+      if (!set) return;
+      if (set.startsWith('material.')) {
+        var prop = set.slice(9);
+        targetObj.traverse(function (obj) {
+          if (!obj.isMesh || !obj.material) return;
+          if (!obj.userData._materialCloned) {
+            obj.material = obj.material.clone();
+            obj.userData._materialCloned = true;
+          }
+          try {
+            if (prop === 'color') {
+              obj.material.color.set(value);
+            } else {
+              if (prop in obj.material) {
+                if (obj.material[prop] && typeof obj.material[prop].set === 'function') {
+                  obj.material[prop].set(value);
+                } else {
+                  obj.material[prop] = value;
+                }
+              }
+            }
+          } catch (err) {
+            console.warn("[IoBehaviorManager] Failed to set material property \"".concat(prop, "\""), err);
+          }
+        });
+      } else if (set === 'visible') {
+        targetObj.visible = !!value;
+      } else {
+        // General fallback path parsing (e.g. position.z)
+        var parts = set.split('.');
+        var current = targetObj;
+        for (var i = 0; i < parts.length - 1; i++) {
+          if (current && current[parts[i]]) {
+            current = current[parts[i]];
+          } else {
+            current = null;
+            break;
+          }
+        }
+        if (current) {
+          var lastPart = parts[parts.length - 1];
+          try {
+            if (current[lastPart] && typeof current[lastPart].set === 'function') {
+              current[lastPart].set(value);
+            } else {
+              current[lastPart] = value;
+            }
+          } catch (err) {
+            console.warn("[IoBehaviorManager] Failed to set property \"".concat(set, "\""), err);
+          }
+        }
       }
     }
 
@@ -167,7 +641,7 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "getAnimationDataPoints",
     value: function getAnimationDataPoints(parentUuid, attachmentId) {
-      var _this2 = this;
+      var _this4 = this;
       var hitMesh = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
       var key = this._key(parentUuid, attachmentId);
       var entries = this._entries.get(key);
@@ -179,35 +653,35 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       var filtered = entries;
       if (hitMesh) {
         var matching = entries.filter(function (e) {
-          return _this2._isMeshOrDescendant(hitMesh, e.mesh);
+          return _this4._isMeshOrDescendant(hitMesh, e.mesh);
         });
         if (matching.length > 0) filtered = matching;
       }
 
       // Collapse multiple mesh entries that share the same stateVariable
       var seen = new Map(); // stateVariable → anim
-      var _iterator4 = _createForOfIteratorHelper(filtered),
-        _step4;
+      var _iterator9 = _createForOfIteratorHelper(filtered),
+        _step9;
       try {
-        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-          var anim = _step4.value.anim;
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var anim = _step9.value.anim;
           if (!seen.has(anim.stateVariable)) {
             seen.set(anim.stateVariable, anim);
           }
         }
       } catch (err) {
-        _iterator4.e(err);
+        _iterator9.e(err);
       } finally {
-        _iterator4.f();
+        _iterator9.f();
       }
       var dps = [];
-      var _iterator5 = _createForOfIteratorHelper(seen),
-        _step5;
+      var _iterator0 = _createForOfIteratorHelper(seen),
+        _step0;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var _step5$value = _slicedToArray(_step5.value, 2),
-            stateVar = _step5$value[0],
-            _anim = _step5$value[1];
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+          var _step0$value = _slicedToArray(_step0.value, 2),
+            stateVar = _step0$value[0],
+            _anim = _step0$value[1];
           // Normalise stateType from AnimateDevicesDialog variants
           var stateType = void 0;
           var raw = (_anim.stateType || '').toLowerCase();
@@ -258,9 +732,9 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
           });
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator0.e(err);
       } finally {
-        _iterator5.f();
+        _iterator0.f();
       }
       return dps;
     }
@@ -295,19 +769,19 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
     key: "unloadForComponent",
     value: function unloadForComponent(parentUuid) {
       var prefix = "".concat(parentUuid, "::");
-      var _iterator6 = _createForOfIteratorHelper(this._entries.keys()),
-        _step6;
+      var _iterator1 = _createForOfIteratorHelper(this._entries.keys()),
+        _step1;
       try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var key = _step6.value;
+        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+          var key = _step1.value;
           if (key.startsWith(prefix)) {
             this._entries.delete(key);
           }
         }
       } catch (err) {
-        _iterator6.e(err);
+        _iterator1.e(err);
       } finally {
-        _iterator6.f();
+        _iterator1.f();
       }
     }
   }, {
@@ -391,11 +865,11 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
       var mapping = this._resolveMapping(anim, value);
       if (!mapping) return;
       var types = anim.transformTypes || [];
-      var _iterator7 = _createForOfIteratorHelper(types),
-        _step7;
+      var _iterator10 = _createForOfIteratorHelper(types),
+        _step10;
       try {
-        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-          var type = _step7.value;
+        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+          var type = _step10.value;
           if (type === 'translation') {
             this._applyTranslation(mesh, origPos, mapping.transform);
           } else if (type === 'rotation') {
@@ -405,9 +879,9 @@ var IoBehaviorManager = /*#__PURE__*/function (_BaseDisposable) {
           }
         }
       } catch (err) {
-        _iterator7.e(err);
+        _iterator10.e(err);
       } finally {
-        _iterator7.f();
+        _iterator10.f();
       }
     }