targetj 1.0.238 → 1.0.239

package/build/AnimationUtil.js

@@ -8,7 +8,20 @@ var _TargetUtil = require("./TargetUtil.js");
 var _TargetData = require("./TargetData.js");
 var _TModelUtil = require("./TModelUtil.js");
 var _App = require("./App.js");
+var _ScheduleUtil = require("./ScheduleUtil.js");
+var _TUtil = require("./TUtil.js");
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
 function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
 function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
@@ -22,6 +35,15 @@ var AnimationUtil = exports.AnimationUtil = /*#__PURE__*/function () {
     _classCallCheck(this, AnimationUtil);
   }
   return _createClass(AnimationUtil, null, [{
+    key: "emptyBatch",
+    value: function emptyBatch() {
+      return {
+        frames: [],
+        keyMap: {},
+        totalDuration: 0
+      };
+    }
+  }, {
     key: "overrideAnimatedKeyWithSnap",
     value: function overrideAnimatedKeyWithSnap(tmodel, keys, values) {
       var keyList = Array.isArray(keys) ? keys : [keys];
@@ -38,7 +60,7 @@ var AnimationUtil = exports.AnimationUtil = /*#__PURE__*/function () {
         var key = keyList[i];
         needsAnimation = true;
         var value = valueList[i];
-        var targetValue = tmodel.targetValues[key];
+        var targetValue = tmodel.targetValues[key] || _TargetUtil.TargetUtil.emptyValue();
         var cleanKey = _TargetUtil.TargetUtil.getTargetName(key);
         if (_TargetData.TargetData.isTransformKey(cleanKey)) {
           tfMap0[cleanKey] = value;
@@ -56,12 +78,10 @@ var AnimationUtil = exports.AnimationUtil = /*#__PURE__*/function () {
           interval: 1
         });
         (keyMap[cleanKey] = new Set()).add(key);
-        if (targetValue) {
-          targetValue.value = value;
-          targetValue.steps = 1;
-          targetValue.interval = 0;
-          targetValue.snapAnimation = true;
-        }
+        targetValue.value = value;
+        targetValue.steps = 1;
+        targetValue.interval = 0;
+        targetValue.snapAnimation = true;
       }
       if (!needsAnimation) {
         return;
@@ -149,7 +169,7 @@ var AnimationUtil = exports.AnimationUtil = /*#__PURE__*/function () {
     value: function getAnimationHooks() {
       return {
         morph: function morph(tm, key, from, to, step, steps) {
-          return _TModelUtil.TModelUtil.morph(tm, key, from, to, step, steps);
+          return _TModelUtil.TModelUtil.easingMorph(tm, key, from, to, step, steps);
         },
         fireOnStep: function fireOnStep(tm, key, step) {
           return (0, _App.getTargetManager)().fireOnStep(tm, key, step);
@@ -159,5 +179,533 @@ var AnimationUtil = exports.AnimationUtil = /*#__PURE__*/function () {
         }
       };
     }
+  }, {
+    key: "addToUpdatingTargets",
+    value: function addToUpdatingTargets(tmodel, originalKeys) {
+      var recordMap = (0, _App.getAnimationManager)().recordMap;
+      var records = [];
+      var _iterator = _createForOfIteratorHelper(recordMap),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            _record = _step$value[1];
+          if (_record.tmodel !== tmodel) {
+            continue;
+          }
+          if (originalKeys && !originalKeys.has(_record.originalKey)) {
+            continue;
+          }
+          records.push(_record);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      for (var _i3 = 0, _records = records; _i3 < _records.length; _i3++) {
+        var _tmodel$noDomUpdating, _tmodel$noDomUpdating2;
+        var record = _records[_i3];
+        var originalKey = record.originalKey;
+        var targetValue = tmodel.targetValues[originalKey];
+        if (!targetValue) {
+          continue;
+        }
+        (_tmodel$noDomUpdating = tmodel.noDomUpdatingTargets) === null || _tmodel$noDomUpdating === void 0 || _tmodel$noDomUpdating.delete(originalKey);
+        if (((_tmodel$noDomUpdating2 = tmodel.noDomUpdatingTargets) === null || _tmodel$noDomUpdating2 === void 0 ? void 0 : _tmodel$noDomUpdating2.size) === 0) {
+          tmodel.noDomUpdatingTargets = undefined;
+        }
+        tmodel.setTargetStatus(originalKey, 'updating');
+        tmodel.removeFromAnimatingMap(originalKey);
+      }
+    }
+  }, {
+    key: "addToNODomUpdatingTargets",
+    value: function addToNODomUpdatingTargets(tmodel, originalKeys) {
+      var recordMap = (0, _App.getAnimationManager)().recordMap;
+      var records = [];
+      var _iterator2 = _createForOfIteratorHelper(recordMap),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            _record2 = _step2$value[1];
+          if (_record2.tmodel !== tmodel) {
+            continue;
+          }
+          if (originalKeys && !originalKeys.has(_record2.originalKey)) {
+            continue;
+          }
+          records.push(_record2);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var now = _TUtil.TUtil.now();
+      for (var _i4 = 0, _records2 = records; _i4 < _records2.length; _i4++) {
+        var record = _records2[_i4];
+        var originalKey = record.originalKey;
+        var targetValue = tmodel.targetValues[originalKey];
+        if (!targetValue) {
+          continue;
+        }
+        targetValue.catchupAt = now;
+        tmodel.removeFromAnimatingMap(originalKey);
+        (tmodel.noDomUpdatingTargets || (tmodel.noDomUpdatingTargets = new Set())).add(originalKey);
+      }
+    }
+  }, {
+    key: "removeKeysFromBatch",
+    value: function removeKeysFromBatch(batch, originalKeys) {
+      if (!batch || !(originalKeys !== null && originalKeys !== void 0 && originalKeys.size)) {
+        return;
+      }
+      var _iterator3 = _createForOfIteratorHelper(batch.frames),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var frame = _step3.value;
+          var _iterator5 = _createForOfIteratorHelper(originalKeys),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var originalKey = _step5.value;
+              var cleanKey = _TargetUtil.TargetUtil.getTargetName(originalKey);
+              delete frame.styleMap[cleanKey];
+              delete frame.tfMap[cleanKey];
+              if (frame.keyMeta) {
+                frame.keyMeta.delete(cleanKey);
+              }
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var _iterator4 = _createForOfIteratorHelper(originalKeys),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _originalKey = _step4.value;
+          var _cleanKey = _TargetUtil.TargetUtil.getTargetName(_originalKey);
+          delete batch.keyMap[_cleanKey];
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      batch.frames = batch.frames.filter(function (frame) {
+        return Object.keys(frame.styleMap).length || Object.keys(frame.tfMap).length;
+      });
+      batch.totalDuration = batch.frames.length ? batch.frames[batch.frames.length - 1].keyTime : 0;
+    }
+  }, {
+    key: "updateTModelFromRecord",
+    value: function updateTModelFromRecord(record) {
+      var tmodel = record.tmodel,
+        originalKey = record.originalKey,
+        cleanKey = record.cleanKey;
+      if (!tmodel.hasDom()) {
+        return;
+      }
+      var result = AnimationUtil.getValueFromAnim(record);
+      if (!result) {
+        return;
+      }
+      var value = result.value,
+        step = result.step,
+        steps = result.steps,
+        cycle = result.cycle,
+        valuePointer = result.valuePointer;
+      (0, _App.getAnimationManager)().setAt(tmodel, cleanKey, value);
+      tmodel.val(originalKey, value);
+      var targetValue = tmodel.targetValues[originalKey];
+      if (targetValue) {
+        if (_TUtil.TUtil.isDefined(step) && _TUtil.TUtil.isDefined(steps) && steps > 0) {
+          targetValue.step = step;
+        }
+        if (_TUtil.TUtil.isDefined(valuePointer)) {
+          targetValue.valuePointer = valuePointer;
+        }
+        if (_TUtil.TUtil.isDefined(cycle)) {
+          targetValue.cycle = cycle;
+        }
+        tmodel.setActual(originalKey, value);
+        var fireKey = "".concat(cycle, ":").concat(valuePointer, ":").concat(step);
+        if (record.needsFireOnStep && step > 0 && steps > 0 && record.lastFireOnStepKey !== fireKey) {
+          record.lastFireOnStepKey = fireKey;
+          var needsRefire = record.hooks.fireOnStep(tmodel, originalKey, step);
+          if (!needsRefire) {
+            record.needsFireOnStep = false;
+          }
+        }
+      }
+      return result;
+    }
+  }, {
+    key: "getValueFromAnim",
+    value: function getValueFromAnim(record) {
+      var _anim$effect, _anim$effect$getCompu, _right$segmentSteps, _ref3, _right$valuePointer2, _ref4, _right$cycle2;
+      var originalKey = record.originalKey,
+        anim = record.anim,
+        frames = record.frames;
+      if (!frames) {
+        return;
+      }
+      var ct = (_anim$effect = anim.effect) === null || _anim$effect === void 0 || (_anim$effect$getCompu = _anim$effect.getComputedTiming) === null || _anim$effect$getCompu === void 0 ? void 0 : _anim$effect$getCompu.call(_anim$effect);
+      if (!ct) {
+        return;
+      }
+      var p = _TUtil.TUtil.isDefined(ct.progress) ? _TUtil.TUtil.limit(ct.progress, 0, 1) : 1;
+      var last = frames.length - 1;
+      var framePointer = 0;
+      if (p <= frames[0].offset) {
+        framePointer = 0;
+      } else if (p >= frames[last].offset) {
+        framePointer = last - 1;
+      } else {
+        for (var i = 0; i < last; i++) {
+          if (p >= frames[i].offset && p < frames[i + 1].offset) {
+            framePointer = i;
+            break;
+          }
+        }
+      }
+      var left = frames[framePointer];
+      var right = frames[framePointer + 1];
+      var from = left.value;
+      var to = right.value;
+      var segStart = left.offset;
+      var segEnd = right.offset;
+      var segSpan = segEnd - segStart;
+      if (segSpan <= 0) {
+        return;
+      }
+      var u = _TUtil.TUtil.limit((p - segStart) / segSpan, 0, 1);
+      var value = _TModelUtil.TModelUtil.morph(originalKey, from, to, u);
+      var remainingSteps = right.steps;
+      if (!_TUtil.TUtil.isDefined(remainingSteps) || remainingSteps <= 0) {
+        var _ref, _right$valuePointer, _ref2, _right$cycle;
+        return {
+          value: value,
+          framePointer: framePointer,
+          step: right.segmentSteps,
+          steps: right.segmentSteps,
+          from: from,
+          to: to,
+          valuePointer: (_ref = (_right$valuePointer = right.valuePointer) !== null && _right$valuePointer !== void 0 ? _right$valuePointer : left.valuePointer) !== null && _ref !== void 0 ? _ref : 0,
+          cycle: (_ref2 = (_right$cycle = right.cycle) !== null && _right$cycle !== void 0 ? _right$cycle : left.cycle) !== null && _ref2 !== void 0 ? _ref2 : 0,
+          status: right.done ? "finished" : "playing"
+        };
+      }
+      var localStep = Math.round(u * remainingSteps);
+      localStep = _TUtil.TUtil.limit(localStep, 0, remainingSteps);
+      var stepOffset = right.stepOffset || 0;
+      var segmentSteps = (_right$segmentSteps = right.segmentSteps) !== null && _right$segmentSteps !== void 0 ? _right$segmentSteps : stepOffset + remainingSteps;
+      var step = _TUtil.TUtil.limit(stepOffset + localStep, 0, segmentSteps);
+      var status = right.done ? "finished" : "playing";
+      return {
+        value: value,
+        step: step,
+        steps: segmentSteps,
+        valuePointer: (_ref3 = (_right$valuePointer2 = right.valuePointer) !== null && _right$valuePointer2 !== void 0 ? _right$valuePointer2 : left.valuePointer) !== null && _ref3 !== void 0 ? _ref3 : 0,
+        cycle: (_ref4 = (_right$cycle2 = right.cycle) !== null && _right$cycle2 !== void 0 ? _right$cycle2 : left.cycle) !== null && _ref4 !== void 0 ? _ref4 : 0,
+        from: from,
+        to: to,
+        status: status
+      };
+    }
+  }, {
+    key: "detachAnimationsOnDeleteDom",
+    value: function detachAnimationsOnDeleteDom(tmodel) {
+      var recordMap = (0, _App.getAnimationManager)().recordMap;
+      var pauseKeys = new Set();
+      var catchupKeys = new Set();
+      var _iterator6 = _createForOfIteratorHelper(recordMap),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var _step6$value = _slicedToArray(_step6.value, 2),
+            record = _step6$value[1];
+          if (record.tmodel !== tmodel) {
+            continue;
+          }
+          if (_ScheduleUtil.ScheduleUtil.shouldPauseTarget(tmodel, record.originalKey)) {
+            pauseKeys.add(record.originalKey);
+          } else {
+            catchupKeys.add(record.originalKey);
+          }
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      if (pauseKeys.size) {
+        AnimationUtil.addToUpdatingTargets(tmodel, pauseKeys);
+      }
+      if (catchupKeys.size) {
+        AnimationUtil.addToNODomUpdatingTargets(tmodel, catchupKeys);
+      }
+      AnimationUtil.deleteDetachedRecords(tmodel, new Set([].concat(_toConsumableArray(pauseKeys), _toConsumableArray(catchupKeys))));
+    }
+  }, {
+    key: "deleteDetachedRecords",
+    value: function deleteDetachedRecords(tmodel, keys) {
+      var recordMap = (0, _App.getAnimationManager)().recordMap;
+      var _iterator7 = _createForOfIteratorHelper(recordMap),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _step7$value = _slicedToArray(_step7.value, 2),
+            recId = _step7$value[0],
+            record = _step7$value[1];
+          if (record.tmodel !== tmodel) {
+            continue;
+          }
+          if (!keys.has(record.originalKey)) {
+            continue;
+          }
+          record.status = 'detached';
+          try {
+            record.anim.cancel();
+          } catch (_unused) {}
+          tmodel.removeFromAnimatingMap(record.originalKey);
+          recordMap.delete(recId);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      tmodel.clearAnimatingMap();
+      tmodel.lastBatch = undefined;
+      tmodel.finalKeyframe = undefined;
+      tmodel.finalRawFrame = undefined;
+    }
+  }, {
+    key: "rebaseCutBatchMeta",
+    value: function rebaseCutBatchMeta(tmodel, batch) {
+      var _batch$frames;
+      if (!batch || !((_batch$frames = batch.frames) !== null && _batch$frames !== void 0 && _batch$frames.length)) {
+        return;
+      }
+      for (var _i5 = 0, _Object$entries = Object.entries(batch.keyMap); _i5 < _Object$entries.length; _i5++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i5], 2),
+          cleanKey = _Object$entries$_i[0],
+          originalKeys = _Object$entries$_i[1];
+        var _iterator8 = _createForOfIteratorHelper(originalKeys),
+          _step8;
+        try {
+          for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+            var originalKey = _step8.value;
+            var targetValue = tmodel.targetValues[originalKey];
+            if (!targetValue) {
+              continue;
+            }
+            var currentStep = targetValue.step || 0;
+            for (var i = 1; i < batch.frames.length; i++) {
+              var _frame$keyMeta;
+              var frame = batch.frames[i];
+              if ((0, _App.getAnimationManager)().getAt(frame, cleanKey) === undefined) {
+                continue;
+              }
+              var meta = (_frame$keyMeta = frame.keyMeta) === null || _frame$keyMeta === void 0 ? void 0 : _frame$keyMeta.get(cleanKey);
+              if (!meta || !_TUtil.TUtil.isDefined(meta.steps)) {
+                continue;
+              }
+              var oldOffset = meta.stepOffset || 0;
+              var oldTotal = oldOffset + meta.steps;
+              if (currentStep > oldOffset && currentStep < oldTotal) {
+                meta.stepOffset = currentStep;
+                meta.steps = oldTotal - currentStep;
+              }
+              break;
+            }
+          }
+        } catch (err) {
+          _iterator8.e(err);
+        } finally {
+          _iterator8.f();
+        }
+      }
+    }
+  }, {
+    key: "removeCleanKeyFromBatch",
+    value: function removeCleanKeyFromBatch(batch, cleanKey) {
+      if (!batch) {
+        return false;
+      }
+      var previousDuration = batch.totalDuration || 0;
+      var removed = false;
+      var _iterator9 = _createForOfIteratorHelper(batch.frames),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _frame$keyMeta2;
+          var frame = _step9.value;
+          if (frame.tfMap[cleanKey] !== undefined || frame.styleMap[cleanKey] !== undefined) {
+            removed = true;
+          }
+          delete frame.tfMap[cleanKey];
+          delete frame.styleMap[cleanKey];
+          (_frame$keyMeta2 = frame.keyMeta) === null || _frame$keyMeta2 === void 0 || _frame$keyMeta2.delete(cleanKey);
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+      delete batch.keyMap[cleanKey];
+      batch.frames = batch.frames.filter(function (frame) {
+        return Object.keys(frame.tfMap).length || Object.keys(frame.styleMap).length;
+      });
+      batch.frames.sort(function (a, b) {
+        return a.keyTime - b.keyTime;
+      });
+      batch.totalDuration = batch.frames.length ? Math.max.apply(Math, [previousDuration].concat(_toConsumableArray(batch.frames.map(function (frame) {
+        return frame.keyTime;
+      })))) : 0;
+      return removed;
+    }
+  }, {
+    key: "handleWebAnimationAPI",
+    value: function handleWebAnimationAPI(tmodel, cleanKey, key, targetValue, from, to, valuePointer, step, steps, interval, timeShift) {
+      var _batch$keyMap;
+      var skipStartFrame = arguments.length > 11 && arguments[11] !== undefined ? arguments[11] : false;
+      var replaceExistingKey = arguments.length > 12 && arguments[12] !== undefined ? arguments[12] : true;
+      var batch = tmodel.waapiBatch || (tmodel.waapiBatch = {
+        frames: [],
+        easing: undefined,
+        keyMap: {},
+        totalDuration: 0
+      });
+      var replacedExistingKey = false;
+      if (replaceExistingKey) {
+        replacedExistingKey = AnimationUtil.removeCleanKeyFromBatch(batch, cleanKey);
+        if (replacedExistingKey) {
+          timeShift = 0;
+        }
+      }
+      var isTransform = _TargetData.TargetData.isTransformKey(cleanKey);
+      var getFrameAtTime = function getFrameAtTime(t) {
+        var shifted = Math.max(0, t + timeShift);
+        for (var i = 0; i < batch.frames.length; i++) {
+          var _frame = batch.frames[i];
+          if (Math.abs(_frame.keyTime - shifted) < 0.0001) {
+            return _frame;
+          }
+        }
+        var frame = {
+          keyTime: shifted,
+          tfMap: {},
+          styleMap: {},
+          keyMeta: new Map()
+        };
+        batch.frames.push(frame);
+        return frame;
+      };
+      var setFrameValue = function setFrameValue(frame, value) {
+        if (isTransform) {
+          frame.tfMap[cleanKey] = value;
+        } else {
+          frame.styleMap[cleanKey] = value;
+        }
+      };
+      var keyDuration = 0;
+      if (targetValue.valueList && targetValue.valueList.length) {
+        var _targetValue$cycles, _targetValue$cycle;
+        var valueList = targetValue.valueList;
+        var stepList = targetValue.stepList || [1];
+        var intervalList = targetValue.intervalList || [interval || 8];
+        var cycles = (_targetValue$cycles = targetValue.cycles) !== null && _targetValue$cycles !== void 0 ? _targetValue$cycles : 1;
+        var cycle = (_targetValue$cycle = targetValue.cycle) !== null && _targetValue$cycle !== void 0 ? _targetValue$cycle : 0;
+        var pointer = valuePointer;
+        if (!skipStartFrame) {
+          var _ref5, _targetValue$cycle2;
+          var frame0 = getFrameAtTime(0);
+          setFrameValue(frame0, from);
+          frame0.keyMeta.set(cleanKey, {
+            steps: 0,
+            segmentSteps: steps || targetValue.steps || 0,
+            interval: interval || targetValue.interval || 8,
+            stepOffset: step || 0,
+            valuePointer: (_ref5 = valuePointer !== null && valuePointer !== void 0 ? valuePointer : targetValue.valuePointer) !== null && _ref5 !== void 0 ? _ref5 : 1,
+            cycle: (_targetValue$cycle2 = targetValue.cycle) !== null && _targetValue$cycle2 !== void 0 ? _targetValue$cycle2 : 0
+          });
+        }
+        while (cycle < cycles) {
+          for (var i = pointer; i < valueList.length; i++) {
+            var _targetValue$cycle3;
+            var segmentSteps = stepList[(i - 1) % stepList.length];
+            var intervalValue = intervalList[(i - 1) % intervalList.length] || 8;
+            var stepOffset = cycle === ((_targetValue$cycle3 = targetValue.cycle) !== null && _targetValue$cycle3 !== void 0 ? _targetValue$cycle3 : 0) && i === valuePointer ? step : 0;
+            var remainingSteps = Math.max(segmentSteps - stepOffset, 0);
+            if (remainingSteps <= 0) {
+              continue;
+            }
+            var duration = remainingSteps * intervalValue;
+            keyDuration += duration;
+            var frame = getFrameAtTime(keyDuration);
+            setFrameValue(frame, valueList[i]);
+            frame.keyMeta.set(cleanKey, {
+              steps: remainingSteps,
+              segmentSteps: segmentSteps,
+              interval: intervalValue,
+              stepOffset: stepOffset,
+              valuePointer: i,
+              cycle: cycle
+            });
+          }
+          cycle++;
+          pointer = 1;
+        }
+      } else {
+        var _targetValue$cycle4;
+        interval = interval || 8;
+        var _remainingSteps = Math.max(steps - step, 0);
+        if (_remainingSteps <= 0) {
+          tmodel.val(key, to);
+          targetValue.step = steps;
+          return 0;
+        }
+        keyDuration = _remainingSteps * interval;
+        if (!skipStartFrame) {
+          var _frame2 = getFrameAtTime(0);
+          setFrameValue(_frame2, from);
+        }
+        var frame1 = getFrameAtTime(keyDuration);
+        setFrameValue(frame1, to);
+        frame1.keyMeta.set(cleanKey, {
+          steps: _remainingSteps,
+          segmentSteps: steps,
+          interval: interval,
+          stepOffset: step,
+          valuePointer: 0,
+          cycle: (_targetValue$cycle4 = targetValue.cycle) !== null && _targetValue$cycle4 !== void 0 ? _targetValue$cycle4 : 0
+        });
+      }
+      if (keyDuration <= 0) {
+        tmodel.removeFromUpdatingTargets(key);
+        return 0;
+      }
+      if (tmodel.getTargetEasing(key)) {
+        batch.easing = tmodel.getTargetEasing(key);
+      }
+      batch.totalDuration = Math.max(0, batch.totalDuration, timeShift + keyDuration);
+      ((_batch$keyMap = batch.keyMap)[cleanKey] || (_batch$keyMap[cleanKey] = new Set())).add(key);
+      tmodel.removeFromUpdatingTargets(key);
+      tmodel.addToAnimatingMap(key);
+      return keyDuration;
+    }
   }]);
 }();