targetj 1.0.238 → 1.0.239

package/build/TModelManager.js

@@ -9,6 +9,7 @@ var _TUtil = require("./TUtil.js");
 var _App = require("./App.js");
 var _TModelUtil = require("./TModelUtil.js");
 var _TargetUtil = require("./TargetUtil.js");
+var _AnimationUtil = require("./AnimationUtil.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."); }
@@ -140,6 +141,11 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
               this.lists.activeTargets = [].concat(_toConsumableArray(this.lists.activeTargets), _toConsumableArray(state.activeTargetList));
             }
           }
+          if (preserveDom && !visible && !tmodel.isActivated()) {
+            if (this.needsRestyle(tmodel)) {
+              this.lists.restyle.push(tmodel);
+            }
+          }
           if (visible || tmodel.isActivated()) {
             if (this.needsRerender(tmodel)) {
               this.lists.rerender.push(tmodel);
@@ -420,14 +426,8 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
     key: "deleteDom",
     value: function deleteDom(tmodel) {
       if (tmodel.hasAnimatingTargets()) {
-        (0, _App.getAnimationManager)().pauseTModel(tmodel);
+        _AnimationUtil.AnimationUtil.detachAnimationsOnDeleteDom(tmodel);
       }
-      Object.keys(tmodel.targetValues).forEach(function (key) {
-        var targetValue = tmodel.targetValues[key];
-        if (targetValue.status === 'updating' && tmodel.updatingTargetList.indexOf(key) === -1) {
-          tmodel.setTargetStatus('active');
-        }
-      });
       var domParent = tmodel.getDomParent();
       if (domParent && domParent.$dom) {
         domParent.$dom.removeElement(tmodel.$dom.element);
@@ -473,17 +473,46 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
   }, {
     key: "activatePendingTargetsAfterDom",
     value: function activatePendingTargetsAfterDom(tmodels) {
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref$restoredDoneTarg = _ref.restoredDoneTargets,
+        restoredDoneTargets = _ref$restoredDoneTarg === void 0 ? false : _ref$restoredDoneTarg;
       var _iterator8 = _createForOfIteratorHelper(tmodels),
         _step8;
       try {
         for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
           var tmodel = _step8.value;
-          var pending = tmodel.pendingTargets;
-          if (pending !== null && pending !== void 0 && pending.size) {
-            for (var _i = 0, _arr = _toConsumableArray(pending); _i < _arr.length; _i++) {
+          if (!tmodel.hasDom()) {
+            continue;
+          }
+          if (tmodel.noDomUpdatingTargets) {
+            for (var _i = 0, _arr = _toConsumableArray(tmodel.noDomUpdatingTargets); _i < _arr.length; _i++) {
               var target = _arr[_i];
-              _TargetUtil.TargetUtil.cleanupTarget(tmodel, target);
-              _TargetUtil.TargetUtil.shouldActivateNextTarget(tmodel, target);
+              tmodel.addTargetToStatusList(target);
+            }
+            tmodel.noDomUpdatingTargets = undefined;
+          }
+          var pending = tmodel.pendingTargets;
+          if (pending) {
+            for (var _i2 = 0, _arr2 = _toConsumableArray(pending); _i2 < _arr2.length; _i2++) {
+              var key = _arr2[_i2];
+              _TargetUtil.TargetUtil.cleanupTarget(tmodel, key);
+              _TargetUtil.TargetUtil.shouldActivateNextTarget(tmodel, key);
+            }
+            tmodel.pendingTargets = undefined;
+          }
+          if (restoredDoneTargets) {
+            for (var _i3 = 0, _Object$keys = Object.keys(tmodel.targetValues); _i3 < _Object$keys.length; _i3++) {
+              var _key = _Object$keys[_i3];
+              var targetValue = tmodel.targetValues[_key];
+              if (targetValue.status !== 'done') {
+                continue;
+              }
+              if (tmodel.isTargetInLoop(_key) || tmodel.isTargetPassiveLoop(_key)) {
+                continue;
+              }
+              if (_TargetUtil.TargetUtil.cleanupTarget(tmodel, _key)) {
+                _TargetUtil.TargetUtil.shouldActivateNextTarget(tmodel, _key);
+              }
             }
           }
         }
@@ -493,6 +522,20 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
         _iterator8.f();
       }
     }
+  }, {
+    key: "catchupNoDomTargetsBeforeStyle",
+    value: function catchupNoDomTargetsBeforeStyle(tmodel) {
+      var _tmodel$noDomUpdating;
+      if (!((_tmodel$noDomUpdating = tmodel.noDomUpdatingTargets) !== null && _tmodel$noDomUpdating !== void 0 && _tmodel$noDomUpdating.size)) {
+        return;
+      }
+      for (var _i4 = 0, _arr3 = _toConsumableArray(tmodel.noDomUpdatingTargets); _i4 < _arr3.length; _i4++) {
+        var key = _arr3[_i4];
+        var newStatus = (0, _App.getTargetManager)().calculateTargetStatus(tmodel, key);
+        tmodel.setTargetStatus(key, newStatus);
+      }
+      tmodel.noDomUpdatingTargets = undefined;
+    }
   }, {
     key: "createDoms",
     value: function createDoms() {
@@ -535,9 +578,8 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
       } finally {
         _iterator9.f();
       }
-      this.activatePendingTargetsAfterDom(this.lists.noDom);
-      for (var _i2 = 0, _needsDom = needsDom; _i2 < _needsDom.length; _i2++) {
-        var tmodel = _needsDom[_i2];
+      for (var _i5 = 0, _needsDom = needsDom; _i5 < _needsDom.length; _i5++) {
+        var tmodel = _needsDom[_i5];
         var domHolder = tmodel.getDomHolder();
         if (!domHolder) {
           tmodel.markLayoutDirty('noDomHolder');
@@ -580,8 +622,20 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
       } finally {
         _iterator10.f();
       }
-      for (var _i3 = 0, _styleBatch = styleBatch; _i3 < _styleBatch.length; _i3++) {
-        var _tmodel = _styleBatch[_i3];
+      var _iterator11 = _createForOfIteratorHelper(this.lists.noDom),
+        _step11;
+      try {
+        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+          var _tmodel3 = _step11.value;
+          this.catchupNoDomTargetsBeforeStyle(_tmodel3);
+        }
+      } catch (err) {
+        _iterator11.e(err);
+      } finally {
+        _iterator11.f();
+      }
+      for (var _i6 = 0, _styleBatch = styleBatch; _i6 < _styleBatch.length; _i6++) {
+        var _tmodel = _styleBatch[_i6];
         if (_tmodel.hasDom()) {
           _tmodel.hasDomNow = true;
           _tmodel.markLayoutDirty('hasDomNow');
@@ -590,7 +644,7 @@ var TModelManager = exports.TModelManager = /*#__PURE__*/function () {
         _TModelUtil.TModelUtil.fixStyle(_tmodel);
         _TModelUtil.TModelUtil.fixAsyncStyle(_tmodel);
       }
-      this.activatePendingTargetsAfterDom(styleBatch);
+      this.activatePendingTargetsAfterDom(this.lists.noDom);
       (0, _App.getEvents)().attachEvents(this.lists.noDom.filter(function (t) {
         var _t$externalEventMap;
         return ((_t$externalEventMap = t.externalEventMap) === null || _t$externalEventMap === void 0 ? void 0 : _t$externalEventMap.size) > 0;

package/build/TUtil.js

@@ -232,58 +232,6 @@ var TUtil = exports.TUtil = /*#__PURE__*/function () {
       }
       return false;
     }
-  }, {
-    key: "scheduleExecution",
-    value: function scheduleExecution(tmodel, key) {
-      var interval = tmodel.getTargetInterval(key);
-      var now = TUtil.now();
-      if (interval <= 0) {
-        return 0;
-      }
-      if (tmodel.isTargetImperative(key) && tmodel.getTargetStep(key) === 0) {
-        tmodel.setScheduleTimeStamp(key, now);
-        return 0;
-      }
-      var remaining = tmodel.getScheduleRemainingTime(key);
-      if (TUtil.isDefined(remaining)) {
-        tmodel.setScheduleTimeStamp(key, now - Math.max(interval - remaining, 0));
-        tmodel.resetScheduleRemainingTime(key);
-        return remaining;
-      }
-      var lastScheduledTime = tmodel.getScheduleTimeStamp(key);
-      if (TUtil.isDefined(lastScheduledTime)) {
-        var elapsed = now - lastScheduledTime;
-        return Math.max(interval - elapsed, 0);
-      }
-      tmodel.setScheduleTimeStamp(key, now);
-      return interval;
-    }
-  }, {
-    key: "pauseSchedule",
-    value: function pauseSchedule(tmodel, key) {
-      var interval = tmodel.getTargetInterval(key);
-      var lastScheduledTime = tmodel.getScheduleTimeStamp(key);
-      if (interval <= 0 || !TUtil.isDefined(lastScheduledTime)) {
-        return;
-      }
-      var now = TUtil.now();
-      var elapsed = now - lastScheduledTime;
-      var remaining = Math.max(interval - elapsed, 0);
-      tmodel.setScheduleRemainingTime(key, remaining);
-      tmodel.resetScheduleTimeStamp(key);
-    }
-  }, {
-    key: "resumeSchedule",
-    value: function resumeSchedule(tmodel, key) {
-      var remaining = tmodel.getScheduleRemainingTime(key);
-      if (!TUtil.isDefined(remaining)) {
-        return;
-      }
-      var now = TUtil.now();
-      var interval = tmodel.getTargetInterval(key);
-      tmodel.setScheduleTimeStamp(key, now - Math.max(interval - remaining, 0));
-      tmodel.resetScheduleRemainingTime(key);
-    }
   }, {
     key: "runTargetValue",
     value: function runTargetValue(tmodel, target, key, cycle, lastValue) {
@@ -368,5 +316,146 @@ var TUtil = exports.TUtil = /*#__PURE__*/function () {
       }
       return cloned;
     }
+  }, {
+    key: "advanceTargetByElapsed",
+    value: function advanceTargetByElapsed(tmodel, key) {
+      var _targetValue$valueLis2;
+      var targetValue = tmodel.targetValues[key];
+      if (!targetValue) {
+        return {
+          step: 0,
+          cycle: 0,
+          valuePointer: 1,
+          done: false
+        };
+      }
+      if (!targetValue.catchupAt) {
+        var _targetValue$valueLis;
+        return {
+          step: tmodel.getTargetStep(key),
+          cycle: tmodel.getTargetCycle(key),
+          valuePointer: (_targetValue$valueLis = targetValue.valueList) !== null && _targetValue$valueLis !== void 0 && _targetValue$valueLis.length ? tmodel.getValueListPointer(key) : 0,
+          done: tmodel.getTargetStep(key) >= tmodel.getTargetSteps(key)
+        };
+      }
+      var elapsedMs = TUtil.now() - targetValue.catchupAt;
+      if ((_targetValue$valueLis2 = targetValue.valueList) !== null && _targetValue$valueLis2 !== void 0 && _targetValue$valueLis2.length) {
+        return TUtil.advanceValueListTargetByElapsed(tmodel, key, elapsedMs);
+      } else {
+        return TUtil.advanceSimpleTargetByElapsed(tmodel, key, elapsedMs);
+      }
+    }
+  }, {
+    key: "advanceSimpleTargetByElapsed",
+    value: function advanceSimpleTargetByElapsed(tmodel, key, elapsedMs) {
+      var steps = tmodel.getTargetSteps(key);
+      var interval = tmodel.getTargetInterval(key) || 8;
+      var cycles = tmodel.getTargetCycles(key);
+      var step = tmodel.getTargetStep(key);
+      var cycle = tmodel.getTargetCycle(key);
+      if (steps <= 0) {
+        return {
+          step: steps,
+          valuePointer: 0,
+          cycle: cycles,
+          done: true
+        };
+      }
+      var remainingMs = elapsedMs;
+      while (remainingMs > 0 && cycle < cycles) {
+        var remainingSteps = Math.max(steps - step, 0);
+        var remainingSegmentMs = remainingSteps * interval;
+        if (remainingMs >= remainingSegmentMs) {
+          remainingMs -= remainingSegmentMs;
+          cycle++;
+          if (cycle >= cycles) {
+            return {
+              step: steps,
+              valuePointer: 0,
+              cycle: cycles,
+              done: true
+            };
+          }
+          step = 0;
+          continue;
+        }
+        var advancedSteps = TUtil.limit(Math.floor(remainingMs / interval), 0, remainingSteps);
+        step += advancedSteps;
+        return {
+          step: step,
+          steps: steps,
+          valuePointer: 0,
+          cycle: cycle,
+          done: false
+        };
+      }
+      return {
+        step: step,
+        steps: steps,
+        valuePointer: 0,
+        cycle: cycle,
+        done: cycle >= cycles
+      };
+    }
+  }, {
+    key: "advanceValueListTargetByElapsed",
+    value: function advanceValueListTargetByElapsed(tmodel, key, elapsedMs) {
+      var targetValue = tmodel.targetValues[key];
+      var valueList = targetValue.valueList;
+      var stepList = targetValue.stepList || [1];
+      var intervalList = targetValue.intervalList || [targetValue.interval || 8];
+      var cycles = tmodel.getTargetCycles(key);
+      var cycle = tmodel.getTargetCycle(key);
+      var valuePointer = tmodel.getValueListPointer(key);
+      var step = tmodel.getTargetStep(key);
+      var remainingMs = elapsedMs;
+      while (remainingMs > 0 && cycle < cycles) {
+        while (remainingMs > 0 && valuePointer < valueList.length) {
+          var segmentSteps = stepList[(valuePointer - 1) % stepList.length];
+          var interval = intervalList[(valuePointer - 1) % intervalList.length] || 8;
+          step = TUtil.limit(step, 0, segmentSteps);
+          var remainingSteps = Math.max(segmentSteps - step, 0);
+          var remainingSegmentMs = remainingSteps * interval;
+          if (remainingMs >= remainingSegmentMs) {
+            remainingMs -= remainingSegmentMs;
+            valuePointer++;
+            step = 0;
+            continue;
+          }
+          var advancedSteps = TUtil.limit(Math.floor(remainingMs / interval), 0, remainingSteps);
+          step += advancedSteps;
+          return {
+            step: step,
+            steps: segmentSteps,
+            valuePointer: valuePointer,
+            cycle: cycle,
+            done: false
+          };
+        }
+        cycle++;
+        if (cycle >= cycles) {
+          var finalPointer = valueList.length;
+          var finalStepIndex = Math.max(0, valueList.length - 2);
+          var finalSteps = stepList[finalStepIndex % stepList.length];
+          return {
+            step: finalSteps,
+            steps: finalSteps,
+            valuePointer: finalPointer,
+            cycle: cycles,
+            done: true
+          };
+        }
+        valuePointer = 1;
+        step = 0;
+      }
+      var currentSteps = stepList[(valuePointer - 1) % stepList.length];
+      return {
+        step: step,
+        steps: currentSteps,
+        valuePointer: valuePointer,
+        cycle: cycle,
+        done: cycle >= cycles
+      };
+    }
   }]);
 }();

package/build/TargetExecutor.js

@@ -39,8 +39,8 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
     value: function prepareTarget(tmodel, key) {
       _TargetUtil.TargetUtil.currentTargetName = key;
       _TargetUtil.TargetUtil.currentTModel = tmodel;
-      if (tmodel.isExecuted(key) && tmodel.getTargetCycles(key) > 1) {
-        if (tmodel.getTargetCycle(key) < tmodel.getTargetCycles(key) - 1) {
+      if (tmodel.isExecuted(key)) {
+        if (tmodel.getTargetCycles(key) > 1 && tmodel.getTargetCycle(key) < tmodel.getTargetCycles(key) - 1) {
           tmodel.incrementTargetCycle(key);
         } else {
           tmodel.resetTargetCycle(key);
@@ -72,10 +72,22 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
       }
       return targetValue;
     }
+  }, {
+    key: "resetImperativeProgress",
+    value: function resetImperativeProgress(targetValue) {
+      targetValue.step = 0;
+      targetValue.cycle = 0;
+      if (Array.isArray(targetValue.valueList)) {
+        targetValue.valuePointer = 1;
+      } else {
+        targetValue.valuePointer = 0;
+      }
+    }
   }, {
     key: "executeImperativeTarget",
     value: function executeImperativeTarget(tmodel, key, value, steps, interval, easing, originalTargetName, originalTModel) {
       var cycles = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1;
+      var options = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : {};
       var targetValue;
       if (typeof key === 'string') {
         var cleanKey = _TargetUtil.TargetUtil.getTargetName(key);
@@ -90,6 +102,7 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
         targetValue = TargetExecutor.assignImperativeTargetValue(tmodel, key, originalTargetName, originalTModel);
         TargetExecutor.assignListTarget(tmodel, key, targetValue, value.list, value.list[0], vSteps, vInterval, vEasing, vCycles);
       } else if (_TargetParser.TargetParser.isTargetSpecObject(value)) {
+        var _options = TargetExecutor.getTargetOptions(value);
         var valueArray = _TargetParser.TargetParser.getValueStepsCycles(tmodel, key, value);
         var newValue = valueArray[0];
         var newSteps = valueArray[1];
@@ -100,7 +113,7 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
         interval = _TUtil.TUtil.isDefined(newInterval) ? newInterval : interval;
         easing = _TUtil.TUtil.isDefined(newEasing) ? newEasing : easing;
         cycles = _TUtil.TUtil.isDefined(newCycles) ? newCycles : cycles;
-        TargetExecutor.executeImperativeTarget(tmodel, key, newValue, steps, interval, easing, originalTargetName, originalTModel, cycles);
+        TargetExecutor.executeImperativeTarget(tmodel, key, newValue, steps, interval, easing, originalTargetName, originalTModel, cycles, _options);
         return;
       } else if (_TargetParser.TargetParser.isObjectTarget(key, value)) {
         var completeValue = _TargetData.TargetData.cssFunctionMap[key] ? _objectSpread(_objectSpread({}, _TargetData.TargetData.cssFunctionMap[key]), value) : value;
@@ -110,7 +123,9 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
           var newInterval = interval;
           var newEasing = easing;
           var newCycles = cycles;
+          var newOptions = options;
           if (_typeof(newValue) === 'object' && !_TargetParser.TargetParser.isListTarget(newValue)) {
+            newOptions = TargetExecutor.getTargetOptions(newValue);
             var _valueArray = _TargetParser.TargetParser.getValueStepsCycles(tmodel, objectKey, completeValue[objectKey]);
             newValue = _valueArray[0];
             newSteps = _TUtil.TUtil.isDefined(_valueArray[1]) ? _valueArray[1] : steps;
@@ -118,7 +133,7 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
             newEasing = _TUtil.TUtil.isDefined(_valueArray[3]) ? _valueArray[3] : easing;
             newCycles = _TUtil.TUtil.isDefined(_valueArray[4]) ? _valueArray[4] : cycles;
           }
-          TargetExecutor.executeImperativeTarget(tmodel, objectKey, newValue, newSteps, newInterval, newEasing, originalTargetName, originalTModel, newCycles);
+          TargetExecutor.executeImperativeTarget(tmodel, objectKey, newValue, newSteps, newInterval, newEasing, originalTargetName, originalTModel, newCycles, newOptions);
         });
       } else {
         if (_typeof(value) === 'object' && !_TargetParser.TargetParser.isListTarget(value)) {
@@ -129,21 +144,19 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
             interval = _TUtil.TUtil.isDefined(_valueArray2[2]) ? _valueArray2[2] : interval;
             easing = _TUtil.TUtil.isDefined(_valueArray2[3]) ? _valueArray2[3] : easing;
             cycles = _TUtil.TUtil.isDefined(_valueArray2[4]) ? _valueArray2[4] : cycles;
-            TargetExecutor.executeImperativeTarget(tmodel, key, value, steps, interval, easing, originalTargetName, originalTModel, cycles);
+            TargetExecutor.executeImperativeTarget(tmodel, key, value, steps, interval, easing, originalTargetName, originalTModel, cycles, options);
           } else {
             targetValue = TargetExecutor.assignImperativeTargetValue(tmodel, key, originalTargetName, originalTModel, cycles);
             TargetExecutor.assignSingleTarget(targetValue, value, undefined, steps, cycles, interval, easing);
-            targetValue.step = 0;
-            targetValue.cycle = 0;
           }
         } else {
           targetValue = TargetExecutor.assignImperativeTargetValue(tmodel, key, originalTargetName, originalTModel, cycles);
           TargetExecutor.assignSingleTarget(targetValue, value, undefined, steps, cycles, interval, easing);
-          targetValue.step = 0;
-          targetValue.cycle = 0;
         }
       }
       if (targetValue) {
+        TargetExecutor.resetImperativeProgress(targetValue);
+        TargetExecutor.assignTargetOptions(targetValue, options);
         TargetExecutor.updateTarget(tmodel, targetValue, key, true);
         if (tmodel.isTargetDone(key)) {
           _TargetUtil.TargetUtil.shouldActivateNextTarget(tmodel, key);
@@ -158,7 +171,10 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
         TargetExecutor.snapActualToTarget(tmodel, key);
       }
       targetValue.executionFlag = true;
-      targetValue.executionCount++, tmodel.addToStyleTargetList(key, enforce);
+      targetValue.executionCount++;
+      if (!targetValue.snapAnimation) {
+        tmodel.addToStyleTargetList(key, enforce);
+      }
       tmodel.setTargetMethodName(key, 'value');
       var newStatus = TargetExecutor.calculateTargetStatus(tmodel, targetValue, key);
       tmodel.setTargetStatus(key, newStatus);
@@ -244,6 +260,30 @@ var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
       }
       _AnimationUtil.AnimationUtil.overrideAnimatedKeyWithSnap(tmodel, key, newValue);
     }
+  }, {
+    key: "getTargetOptions",
+    value: function getTargetOptions(value) {
+      var options = {};
+      if (!value || _typeof(value) !== 'object') {
+        return options;
+      }
+      if (Object.prototype.hasOwnProperty.call(value, 'pauseOn')) {
+        options.pauseOn = value.pauseOn;
+      }
+      return options;
+    }
+  }, {
+    key: "assignTargetOptions",
+    value: function assignTargetOptions(targetValue, options) {
+      if (!options) {
+        return;
+      }
+      if (Object.prototype.hasOwnProperty.call(options, 'pauseOn')) {
+        targetValue.pauseOn = options.pauseOn;
+      } else {
+        delete targetValue.pauseOn;
+      }
+    }
   }, {
     key: "resolveTargetValue",
     value: function resolveTargetValue(tmodel, key) {