targetj 1.0.260 → 1.1.1

package/build/TargetManager.js

@@ -77,7 +77,7 @@ var TargetManager = /*#__PURE__*/function () {
       tmodel.resetScheduleTimeStamp(key);
       TargetExecutor.prepareTarget(tmodel, key);
       TargetExecutor.executeDeclarativeTarget(tmodel, key);
-      if (!TUtil.isDefined(target.fetchAction)) {
+      if (!TargetUtil.hasFetchAction(tmodel, key)) {
         TargetUtil.shouldActivateNextTarget(tmodel, key);
       }
     }
@@ -99,7 +99,7 @@ var TargetManager = /*#__PURE__*/function () {
           }
           schedulePeriod = ScheduleUtil.scheduleExecution(tmodel, key);
           if (schedulePeriod > 0) {
-            getRunScheduler().schedule(schedulePeriod, "setActualValues-".concat(tmodel.oid, "-").concat(key));
+            getRunScheduler().scheduleOnlyIfEarlier(schedulePeriod, "setActualValues-".concat(tmodel.oid, "-").concat(key));
           } else {
             tmodel.resetScheduleTimeStamp(key);
             this.setActualValue(tmodel, key);
@@ -225,30 +225,20 @@ var TargetManager = /*#__PURE__*/function () {
   }, {
     key: "calculateTargetStatus",
     value: function calculateTargetStatus(tmodel, key) {
-      var targetValue = tmodel.targetValues[key];
-      if (!targetValue) {
-        return;
+      if (TargetUtil.isTargetUpdating(tmodel, key)) {
+        return 'updating';
       }
-      var valuePointer = tmodel.getValueListPointer(key);
       var cycle = tmodel.getTargetCycle(key);
       var cycles = tmodel.getTargetCycles(key);
-      var step = tmodel.getTargetStep(key);
-      var steps = tmodel.getTargetSteps(key);
-      if (Array.isArray(targetValue.valueList) && valuePointer < targetValue.valueList.length) {
-        return 'updating';
-      } else if (tmodel.isTargetImperative(key) && cycle < cycles - 1) {
-        return 'updating';
-      } else if (step < steps) {
-        return 'updating';
-      } else if (tmodel.isTargetInLoop(key) || cycle < cycles - 1) {
+      if (tmodel.isTargetInLoop(key) || cycle < cycles - 1) {
         return 'active';
-      } else {
-        return 'done';
       }
+      return 'done';
     }
   }, {
     key: "catchupTargetByElapsed",
     value: function catchupTargetByElapsed(tmodel, key) {
+      var _targetValue$valueLis4;
       var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
         _ref$fireEnd = _ref.fireEnd,
         fireEnd = _ref$fireEnd === void 0 ? false : _ref$fireEnd;
@@ -262,17 +252,16 @@ var TargetManager = /*#__PURE__*/function () {
       var step = progress.step;
       var valuePointer = progress.valuePointer;
       var cycle = progress.cycle;
-      var theValue = tmodel.getTargetValue(key);
-      var steps = tmodel.getTargetSteps(key);
       var cycles = tmodel.getTargetCycles(key);
       if (progress.done) {
-        var _targetValue$valueLis, _targetValue$valueLis2, _targetValue$valueLis3;
-        var finalValue = (_targetValue$valueLis = targetValue.valueList) !== null && _targetValue$valueLis !== void 0 && _targetValue$valueLis.length ? targetValue.valueList[targetValue.valueList.length - 1] : theValue;
+        var _targetValue$valueLis, _progress$steps, _targetValue$valueLis2, _targetValue$valueLis3;
+        var finalValue = (_targetValue$valueLis = targetValue.valueList) !== null && _targetValue$valueLis !== void 0 && _targetValue$valueLis.length ? targetValue.valueList[targetValue.valueList.length - 1] : tmodel.getTargetValue(key);
         tmodel.val(key, finalValue);
         tmodel.setActual(key, finalValue);
         tmodel.addToStyleTargetList(key);
-        targetValue.step = steps;
+        targetValue.step = (_progress$steps = progress.steps) !== null && _progress$steps !== void 0 ? _progress$steps : tmodel.getTargetSteps(key);
         targetValue.valuePointer = (_targetValue$valueLis2 = (_targetValue$valueLis3 = targetValue.valueList) === null || _targetValue$valueLis3 === void 0 ? void 0 : _targetValue$valueLis3.length) !== null && _targetValue$valueLis2 !== void 0 ? _targetValue$valueLis2 : valuePointer;
+        targetValue.value = finalValue;
         targetValue.cycle = cycles;
         delete targetValue.catchupAt;
         if (fireEnd) {
@@ -280,11 +269,23 @@ var TargetManager = /*#__PURE__*/function () {
         }
         return {
           done: true,
-          step: steps,
+          step: targetValue.step,
           cycle: cycles,
           valuePointer: targetValue.valuePointer
         };
       }
+      if ((_targetValue$valueLis4 = targetValue.valueList) !== null && _targetValue$valueLis4 !== void 0 && _targetValue$valueLis4.length) {
+        targetValue.valuePointer = valuePointer;
+        targetValue.initialValue = targetValue.valueList[valuePointer - 1];
+        targetValue.value = targetValue.valueList[valuePointer];
+        targetValue.steps = targetValue.stepList[(valuePointer - 1) % targetValue.stepList.length];
+        targetValue.interval = Array.isArray(targetValue.intervalList) ? targetValue.intervalList[(valuePointer - 1) % targetValue.intervalList.length] : targetValue.interval;
+        targetValue.easing = targetValue.easingList[(valuePointer - 1) % targetValue.easingList.length];
+      }
+      targetValue.step = step;
+      targetValue.cycle = cycle;
+      var theValue = tmodel.getTargetValue(key);
+      var steps = tmodel.getTargetSteps(key);
       var initialValue = tmodel.getTargetInitialValue(key);
       if (!TUtil.isDefined(initialValue)) {
         initialValue = this.resolveInitialValue(tmodel, key, theValue);
@@ -294,9 +295,6 @@ var TargetManager = /*#__PURE__*/function () {
       tmodel.val(key, value);
       tmodel.setActual(key, value);
       tmodel.addToStyleTargetList(key);
-      targetValue.step = step;
-      targetValue.valuePointer = valuePointer;
-      targetValue.cycle = cycle;
       return {
         done: false,
         step: step,
@@ -332,7 +330,7 @@ var TargetManager = /*#__PURE__*/function () {
       if (tmodel.canBeAnimated(state.cleanKey)) {
         this.animateActualValue(tmodel, key, targetValue, state, step, valuePointer);
       } else {
-        this.updateActualValue(tmodel, key, targetValue, state, step, valuePointer);
+        this.updateActualValue(tmodel, key, targetValue, state, step);
       }
     }
   }, {
@@ -372,20 +370,26 @@ var TargetManager = /*#__PURE__*/function () {
   }, {
     key: "animateActualValue",
     value: function animateActualValue(tmodel, key, targetValue, state, step, valuePointer) {
+      var _targetValue$valueLis5;
       if (!tmodel.hasDom()) {
         tmodel.addToNoDomUpdatingTargets(key);
         return;
       }
       var newValue = step > 0 ? TModelUtil.easingMorph(tmodel, key, state.initialValue, state.theValue, step, state.steps) : state.initialValue;
-      var cycles = tmodel.isTargetImperative(key) ? tmodel.getTargetCycles(key) : 0;
       var cycleDuration = AnimationUtil.handleWebAnimationAPI(tmodel, state.cleanKey, key, targetValue, newValue, state.theValue, valuePointer, step, state.steps, state.interval, 0, false, true);
+
+      // AnimationUtil already expands all cycles for value lists.
+      if ((_targetValue$valueLis5 = targetValue.valueList) !== null && _targetValue$valueLis5 !== void 0 && _targetValue$valueLis5.length) {
+        return;
+      }
+      var cycles = tmodel.isTargetImperative(key) ? tmodel.getTargetCycles(key) : 1;
       for (var c = 1; c < cycles; c++) {
         AnimationUtil.handleWebAnimationAPI(tmodel, state.cleanKey, key, targetValue, newValue, state.theValue, valuePointer, step, state.steps, state.interval, c * cycleDuration, true, false);
       }
     }
   }, {
     key: "updateActualValue",
-    value: function updateActualValue(tmodel, key, targetValue, state, step, valuePointer) {
+    value: function updateActualValue(tmodel, key, targetValue, state, step) {
       if (step <= state.steps) {
         tmodel.incrementTargetStep(key, state.now, state.lastUpdateTime, state.interval, state.steps);
         var newValue = TModelUtil.easingMorph(tmodel, key, state.initialValue, state.theValue, step, state.steps);
@@ -398,27 +402,31 @@ var TargetManager = /*#__PURE__*/function () {
           return;
         }
       }
-      this.finishCurrentSegment(tmodel, key, targetValue, state, valuePointer);
+      this.finishCurrentSegment(tmodel, key, targetValue, state);
     }
   }, {
     key: "finishCurrentSegment",
-    value: function finishCurrentSegment(tmodel, key, targetValue, state, valuePointer) {
+    value: function finishCurrentSegment(tmodel, key, targetValue, state) {
       tmodel.val(key, state.theValue);
       tmodel.setActual(key, state.theValue);
       tmodel.addToStyleTargetList(key);
       targetValue.step = state.steps;
       tmodel.setLastUpdate(key);
       var scheduleTime = 1;
-      if (targetValue.valueList && valuePointer < targetValue.valueList.length) {
+      if (targetValue.valueList) {
         tmodel.incrementValueListPointer(key);
         var nextPointer = tmodel.getValueListPointer(key);
-        tmodel.resetTargetStep(key);
-        targetValue.initialValue = targetValue.value;
-        targetValue.value = targetValue.valueList[nextPointer];
-        targetValue.steps = targetValue.stepList[(nextPointer - 1) % targetValue.stepList.length];
-        targetValue.interval = Array.isArray(targetValue.intervalList) ? targetValue.intervalList[(nextPointer - 1) % targetValue.intervalList.length] : 0;
-        targetValue.easing = targetValue.easingList[(nextPointer - 1) % targetValue.easingList.length];
-        scheduleTime = state.interval;
+        if (nextPointer < targetValue.valueList.length) {
+          tmodel.resetTargetStep(key);
+          targetValue.initialValue = targetValue.value;
+          targetValue.value = targetValue.valueList[nextPointer];
+          targetValue.steps = targetValue.stepList[(nextPointer - 1) % targetValue.stepList.length];
+          targetValue.interval = Array.isArray(targetValue.intervalList) ? targetValue.intervalList[(nextPointer - 1) % targetValue.intervalList.length] : 0;
+          targetValue.easing = targetValue.easingList[(nextPointer - 1) % targetValue.easingList.length];
+          scheduleTime = state.interval;
+        } else {
+          this.fireOnEnd(tmodel, key);
+        }
       } else {
         this.fireOnEnd(tmodel, key);
       }

package/build/TargetParser.js

@@ -1,3 +1,9 @@
+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 _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 _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 _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 _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); } }
@@ -9,6 +15,7 @@ import { TargetData } from './TargetData.js';
 import { TUtil } from './TUtil.js';
 import { TModel } from "./TModel.js";
 import { Easing } from "./Easing.js";
+import { getEvents } from "./App.js";
 
 /**
  * It provides helper functions for classify target types
@@ -26,8 +33,11 @@ var TargetParser = /*#__PURE__*/function () {
     key: "hasLifecycle",
     value: function hasLifecycle(object) {
       for (var key in object) {
-        var value = object[key];
-        if (typeof value === 'function' && TargetData.isLifeCycleMethod(key)) {
+        // Event handlers are not target lifecycle callbacks.
+        if (TargetData.eventSet.has(key)) {
+          continue;
+        }
+        if (typeof object[key] === 'function' && TargetData.isLifeCycleMethod(key)) {
           return true;
         }
       }
@@ -114,7 +124,25 @@ var TargetParser = /*#__PURE__*/function () {
   }, {
     key: "getInstanceTargetValue",
     value: function getInstanceTargetValue(tmodel, key, target, cycle, lastValue, instance) {
-      return TUtil.runTargetValue(tmodel, target, key, cycle, lastValue, instance);
+      return TargetParser.runTargetValue(tmodel, target, key, cycle, lastValue, instance);
+    }
+  }, {
+    key: "runTargetValue",
+    value: function runTargetValue(tmodel, target, key, cycle, lastValue) {
+      var instance = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+      var cleanKey = TargetUtil.getTargetName(key);
+      var isExternalEvent = TargetData.allEventMap[cleanKey];
+      var instanceArgs = TUtil.isDefined(instance) ? [instance] : [];
+      if (isExternalEvent) {
+        var _target$value;
+        return typeof target.value === 'function' ? (_target$value = target.value).call.apply(_target$value, [tmodel].concat(instanceArgs, [getEvents().getCurrentOriginalEvent(), cycle, lastValue])) : TUtil.isDefined(target.value) ? target.value : target;
+      } else if (tmodel.val("___".concat(key))) {
+        var _target$value2;
+        return typeof target.value === 'function' ? (_target$value2 = target.value).call.apply(_target$value2, [tmodel].concat(instanceArgs, [tmodel.val("___".concat(key)), cycle, lastValue])) : TUtil.isDefined(target.value) ? target.value : target;
+      } else {
+        var _target$value3;
+        return typeof target.value === 'function' ? (_target$value3 = target.value).call.apply(_target$value3, [tmodel].concat(instanceArgs, [cycle, lastValue])) : TUtil.isDefined(target.value) ? target.value : target;
+      }
     }
   }, {
     key: "isChildrenTarget",
@@ -273,7 +301,7 @@ var TargetParser = /*#__PURE__*/function () {
 
         // Plain objects: compute value + params (steps/interval/easing/cycles)
         if (_typeof(target) === "object" && target !== null && Object.getPrototypeOf(target) === Object.prototype) {
-          var valueResult = TUtil.runTargetValue(tmodel, target, key, cycle, lastValue, instance);
+          var valueResult = TargetParser.runTargetValue(tmodel, target, key, cycle, lastValue, instance);
           if (TargetParser.isPrimitiveArray(valueResult) && (TUtil.isDefined(target.steps) || TUtil.isDefined(target.interval) || TUtil.isDefined(target.easing) || TUtil.isDefined(target.cycles))) {
             value = {
               list: valueResult
@@ -305,6 +333,31 @@ var TargetParser = /*#__PURE__*/function () {
       }
       return getValue(_target);
     }
+  }, {
+    key: "getInitialTargetValue",
+    value: function getInitialTargetValue(tmodel, key, target) {
+      var cycle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+      if (typeof target === "function") {
+        return TargetParser.getInitialTargetValue(tmodel, key, target.call(tmodel, cycle, tmodel.val(key)), cycle);
+      }
+      if (TargetParser.isPlainObject(target)) {
+        if (TUtil.isDefined(target.initialValue)) {
+          return TargetParser.getInitialTargetValue(tmodel, key, target.initialValue, cycle);
+        }
+        if (typeof target.value === "function") {
+          return TargetParser.getInitialTargetValue(tmodel, key, target.value.call(tmodel, cycle, tmodel.val(key)), cycle);
+        }
+      }
+      var _TargetParser$getValu = TargetParser.getValueStepsCycles(tmodel, key, target, cycle),
+        _TargetParser$getValu2 = _slicedToArray(_TargetParser$getValu, 1),
+        value = _TargetParser$getValu2[0];
+      return TargetParser.isListTarget(value) ? value.list[0] : value;
+    }
+  }, {
+    key: "isExplodeChildrenTarget",
+    value: function isExplodeChildrenTarget(key) {
+      return TargetUtil.getTargetName(key) === "explodeChildren";
+    }
   }]);
 }();
 export { TargetParser };