targetj 1.0.74 → 1.0.76

package/build/TUtil.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TUtil = void 0;
+var _$Dom = require("./$Dom.js");
+var _App = require("./App.js");
+var _SearchUtil = require("./SearchUtil.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 _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; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var TUtil = exports.TUtil = /*#__PURE__*/function () {
+  function TUtil() {
+    _classCallCheck(this, TUtil);
+  }
+  return _createClass(TUtil, null, [{
+    key: "getBoundingRect",
+    value: function getBoundingRect(tmodel) {
+      var left, top, right, bottom, oid;
+      if (tmodel.actualValues.domHolder && tmodel.actualValues.domHolder.exists()) {
+        var rect = tmodel.actualValues.domHolder.getBoundingClientRect();
+        left = rect.left;
+        top = rect.top;
+        right = rect.right;
+        bottom = rect.bottom;
+        oid = tmodel.actualValues.domHolder.attr('id');
+      } else {
+        var parent = tmodel.getDomParent() ? tmodel.getDomParent() : _SearchUtil.SearchUtil.findParentByTarget(tmodel, 'domHolder');
+        if (parent) {
+          left = parent.absX;
+          top = parent.absY;
+          var width = parent.getWidth();
+          var height = parent.getHeight();
+          right = left + width;
+          bottom = top + height;
+          oid = parent.oid;
+        } else {
+          left = 0;
+          top = 0;
+          right = (0, _App.getScreenWidth)();
+          bottom = (0, _App.getScreenHeight)();
+          oid = 'screen';
+        }
+      }
+      return {
+        left: left,
+        top: top,
+        right: right,
+        bottom: bottom,
+        oid: oid
+      };
+    }
+  }, {
+    key: "initDoms",
+    value: function initDoms(visibleList) {
+      var elements = _$Dom.$Dom.findByClass('tgt');
+      visibleList.forEach(function (tmodel) {
+        tmodel.$dom = null;
+      });
+      var visibleMap = TUtil.list2map(visibleList.filter(function (item) {
+        return item.type !== 'BI';
+      }));
+      var _iterator = _createForOfIteratorHelper(elements),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var element = _step.value;
+          var id = element.getAttribute("id");
+          var tmodel = visibleMap[id];
+          if (tmodel && !tmodel.hasDom()) {
+            tmodel.$dom = new _$Dom.$Dom("#".concat(id));
+          } else {
+            _$Dom.$Dom.detach(element);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "list2map",
+    value: function list2map(list, defaultValue) {
+      return list.reduce(function (map, item) {
+        map[item.oid] = TUtil.isDefined(defaultValue) ? defaultValue : item;
+        return map;
+      }, {});
+    }
+  }, {
+    key: "getDeepList",
+    value: function getDeepList(parent) {
+      var deepList = [];
+      function traverse(tmodel) {
+        if (tmodel && tmodel.hasChildren()) {
+          var list = tmodel.getChildren();
+          deepList.push.apply(deepList, _toConsumableArray(list));
+          list.forEach(traverse);
+        }
+      }
+      traverse(parent);
+      return deepList;
+    }
+  }, {
+    key: "areEqual",
+    value: function areEqual(a, b, deepEquality) {
+      if (deepEquality) {
+        return JSON.stringify(a) === JSON.stringify(b);
+      } else {
+        return a === b;
+      }
+    }
+  }, {
+    key: "momentum",
+    value: function momentum(past, current) {
+      var time = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var distance = current - past;
+      var speed = Math.abs(distance) / time;
+      var duration = Math.floor(speed * 5000);
+      var momentumDistance = 5 * duration;
+      var adjustedDistance = distance > 0 ? distance + momentumDistance : distance - momentumDistance;
+      return {
+        distance: Math.round(adjustedDistance) / 50,
+        duration: duration,
+        momentumDistance: time,
+        time: time * 5
+      };
+    }
+  }, {
+    key: "isDefined",
+    value: function isDefined(obj) {
+      return typeof obj !== "undefined" && obj !== null;
+    }
+  }, {
+    key: "isNumber",
+    value: function isNumber(num) {
+      return typeof num === 'number' && !isNaN(num);
+    }
+  }, {
+    key: "limit",
+    value: function limit(num, low, high) {
+      num = TUtil.isDefined(num) ? num : low;
+      num = num > high ? high : num;
+      num = num < low ? low : num;
+      return num;
+    }
+  }, {
+    key: "formatNum",
+    value: function formatNum(num, precision) {
+      if (!num) {
+        return 0;
+      }
+      var n = parseFloat(num.toString());
+      return n.toFixed(precision);
+    }
+  }, {
+    key: "distance",
+    value: function distance(x1, y1, x2, y2) {
+      return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+    }
+  }, {
+    key: "getFullLink",
+    value: function getFullLink(link) {
+      if (!TUtil.isDefined(link)) {
+        return;
+      }
+      if (link.startsWith('http')) {
+        return link;
+      } else {
+        var protocol = window.location.protocol;
+        protocol += protocol.endsWith(":") ? "//" : "://";
+        var base = "".concat(protocol).concat(window.location.hostname);
+        return link.startsWith("/") ? base + link : "".concat(base, "/").concat(link);
+      }
+    }
+  }]);
+}();

package/build/TargetExecutor.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TargetExecutor = void 0;
+var _TargetUtil = require("./TargetUtil.js");
+var _TUtil = require("./TUtil.js");
+var _Easing = require("./Easing.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 _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; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var TargetExecutor = exports.TargetExecutor = /*#__PURE__*/function () {
+  function TargetExecutor() {
+    _classCallCheck(this, TargetExecutor);
+  }
+  return _createClass(TargetExecutor, null, [{
+    key: "executeDeclarativeTarget",
+    value: function executeDeclarativeTarget(tmodel, key) {
+      TargetExecutor.resolveTargetValue(tmodel, key);
+      TargetExecutor.updateTarget(tmodel, tmodel.targetValues[key], key);
+    }
+  }, {
+    key: "executeImperativeTarget",
+    value: function executeImperativeTarget(tmodel, key, value, steps, interval, easing, originalTargetName) {
+      tmodel.targetValues[key] = tmodel.targetValues[key] || _TargetUtil.TargetUtil.emptyValue();
+      var targetValue = tmodel.targetValues[key];
+      targetValue.isImperative = true;
+      targetValue.originalTargetName = originalTargetName;
+      if (_TargetUtil.TargetUtil.isAddChildTarget(key, value)) {
+        tmodel.addChild(value);
+      } else if (_TargetUtil.TargetUtil.isListTarget(value)) {
+        TargetExecutor.assignListTarget(targetValue, value.list, value.list[0], steps, interval, easing);
+      } else {
+        TargetExecutor.assignSingleTarget(targetValue, value, undefined, steps, 0, interval, easing);
+        targetValue.step = 0;
+      }
+      TargetExecutor.updateTarget(tmodel, targetValue, key);
+    }
+  }, {
+    key: "updateTarget",
+    value: function updateTarget(tmodel, targetValue, key) {
+      targetValue.executionCount++;
+      targetValue.executionFlag = true;
+      tmodel.addToStyleTargetList(key);
+      tmodel.setTargetMethodName(key, 'value');
+      if (tmodel.getTargetSteps(key) === 0) {
+        TargetExecutor.snapActualToTarget(tmodel, key);
+      }
+      tmodel.updateTargetStatus(key);
+    }
+  }, {
+    key: "assignListTarget",
+    value: function assignListTarget(targetValue, valueList, initialValue, steps, interval, easing) {
+      targetValue.valueList = valueList;
+      targetValue.stepList = Array.isArray(steps) ? steps : _TUtil.TUtil.isDefined(steps) ? [steps] : [1];
+      targetValue.intervalList = Array.isArray(interval) ? interval : _TUtil.TUtil.isDefined(interval) ? [interval] : [0];
+      targetValue.easingList = Array.isArray(easing) ? easing : _TUtil.TUtil.isDefined(easing) ? [easing] : [_Easing.Easing.linear];
+      targetValue.cycle = 1;
+      targetValue.value = valueList[1];
+      targetValue.initialValue = initialValue;
+      targetValue.steps = targetValue.stepList[0];
+      targetValue.interval = targetValue.intervalList[0];
+      targetValue.easing = targetValue.easingList[0];
+      targetValue.step = 0;
+      targetValue.cycles = 0;
+    }
+  }, {
+    key: "assignSingleTarget",
+    value: function assignSingleTarget(targetValue, value, initialValue, steps, cycles, interval, easing) {
+      delete targetValue.valueList;
+      delete targetValue.stepList;
+      delete targetValue.intervalList;
+      delete targetValue.easingList;
+      targetValue.initialValue = initialValue;
+      targetValue.value = value;
+      targetValue.steps = steps || 0;
+      targetValue.cycles = cycles || 0;
+      targetValue.interval = interval || 0;
+      targetValue.easing = easing;
+    }
+  }, {
+    key: "snapActualToTarget",
+    value: function snapActualToTarget(tmodel, key) {
+      var oldValue = tmodel.actualValues[key];
+      var value = tmodel.targetValues[key].value;
+      tmodel.actualValues[key] = typeof value === 'function' ? value.call(tmodel) : value;
+      tmodel.setActualValueLastUpdate(key);
+      _TargetUtil.TargetUtil.handleValueChange(tmodel, key, tmodel.actualValues[key], oldValue, 0, 0);
+    }
+  }, {
+    key: "resolveTargetValue",
+    value: function resolveTargetValue(tmodel, key) {
+      var targetInitial = !tmodel.targetValues[key] && _TUtil.TUtil.isDefined(tmodel.targets[key].initialValue) ? tmodel.targets[key].initialValue : undefined;
+      var valueArray = _TargetUtil.TargetUtil.getValueStepsCycles(tmodel, key);
+      var newValue = valueArray[0];
+      var newSteps = valueArray[1] || 0;
+      var newInterval = valueArray[2] || 0;
+      var newCycles = valueArray[3] || 0;
+      var targetValue = tmodel.targetValues[key] || _TargetUtil.TargetUtil.emptyValue();
+      var theValue = targetValue.value;
+      tmodel.targetValues[key] = targetValue;
+      var easing = _TUtil.TUtil.isDefined(tmodel.targets[key].easing) ? tmodel.targets[key].easing : undefined;
+      if (_TargetUtil.TargetUtil.isListTarget(newValue)) {
+        TargetExecutor.assignListTarget(targetValue, newValue.list, newValue.list[0], newSteps, newInterval, easing);
+      } else {
+        TargetExecutor.assignSingleTarget(targetValue, newValue, targetInitial, newSteps, newCycles, newInterval, easing);
+        if (newSteps > 0 && _TUtil.TUtil.areEqual(theValue, newValue, tmodel.targets[key] ? !!tmodel.targets[key].deepEquality : false)) {
+          tmodel.resetTargetStep(key);
+        }
+      }
+    }
+  }]);
+}();

package/build/TargetManager.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TargetManager = void 0;
+var _TUtil = require("./TUtil.js");
+var _TargetUtil = require("./TargetUtil.js");
+var _TargetExecutor = require("./TargetExecutor.js");
+var _SearchUtil = require("./SearchUtil.js");
+var _App = require("./App.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 _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; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var TargetManager = exports.TargetManager = /*#__PURE__*/function () {
+  function TargetManager() {
+    _classCallCheck(this, TargetManager);
+  }
+  return _createClass(TargetManager, [{
+    key: "applyTargetValues",
+    value: function applyTargetValues(tmodel) {
+      tmodel.targetMethodMap = {};
+      var activeList = tmodel.activeTargetList.slice(0);
+      var _iterator = _createForOfIteratorHelper(activeList),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          if (!tmodel.isTargetImperative(key)) {
+            this.applyTargetValue(tmodel, key);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "applyTargetValue",
+    value: function applyTargetValue(tmodel, key) {
+      var target = tmodel.targets[key];
+      if (!_TUtil.TUtil.isDefined(target)) {
+        tmodel.removeFromActiveTargets(key);
+        return;
+      }
+      if (typeof target.enabledOn === 'function') {
+        tmodel.setTargetMethodName(key, 'enabledOn');
+      }
+      if (!tmodel.isTargetEnabled(key)) {
+        _App.tApp.manager.scheduleRun(10, "applyTargetValue-disabled-".concat(tmodel.oid, "__").concat(key));
+        return;
+      }
+      if (tmodel.isExecuted(key) && tmodel.getTargetStep(key) === tmodel.getTargetSteps(key)) {
+        if (_TargetUtil.TargetUtil.scheduleExecution(tmodel, key) > 0) {
+          return;
+        }
+      }
+      tmodel.resetScheduleTimeStamp(key);
+      if (tmodel.isExecuted(key) && tmodel.getTargetCycle(key) < tmodel.getTargetCycles(key)) {
+        tmodel.incrementTargetCycle(key, tmodel.getTargetCycle(key));
+        tmodel.resetTargetStep(key);
+        tmodel.resetTargetInitialValue(key);
+      }
+      _TargetExecutor.TargetExecutor.executeDeclarativeTarget(tmodel, key);
+      var schedulePeriod = _TargetUtil.TargetUtil.scheduleExecution(tmodel, key);
+      if (schedulePeriod > 0) {
+        _App.tApp.manager.scheduleRun(schedulePeriod, "actualInterval__".concat(tmodel.oid, "__").concat(key));
+      }
+    }
+  }, {
+    key: "setActualValues",
+    value: function setActualValues(tmodel) {
+      var updatingList = tmodel.updatingTargetList.slice(0);
+      var schedulePeriod = 0;
+      var _iterator2 = _createForOfIteratorHelper(updatingList),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          schedulePeriod = _TargetUtil.TargetUtil.scheduleExecution(tmodel, key);
+          if (schedulePeriod === 0) {
+            tmodel.addToStyleTargetList(key);
+            this.setActualValue(tmodel, key);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  }, {
+    key: "setActualValue",
+    value: function setActualValue(tmodel, key) {
+      var targetValue = tmodel.targetValues[key];
+      if (!targetValue) {
+        return;
+      }
+      if (!tmodel.isTargetEnabled(key)) {
+        _App.tApp.manager.scheduleRun(10, "setActualValue-disabled-".concat(tmodel.oid, "__").concat(key));
+        return;
+      }
+      var theValue = tmodel.getTargetValue(key);
+      var step = tmodel.getTargetStep(key);
+      var steps = tmodel.getTargetSteps(key);
+      var cycle = tmodel.getTargetCycle(key);
+      var interval = tmodel.getTargetInterval(key) || 0;
+      var oldValue = tmodel.actualValues[key];
+      var oldStep = step;
+      var oldCycle = cycle;
+      var initialValue = tmodel.getTargetInitialValue(key);
+      var originalTargetName, originalTarget, originalTModel;
+      if (step <= steps) {
+        if (!_TUtil.TUtil.isDefined(initialValue)) {
+          initialValue = tmodel.actualValues[key];
+          tmodel.setTargetInitialValue(key, initialValue);
+        }
+        tmodel.actualValues[key] = _TargetUtil.TargetUtil.morph(tmodel, key, initialValue, theValue, step, steps);
+        tmodel.setActualValueLastUpdate(key);
+        if (tmodel.isTargetImperative(key)) {
+          originalTargetName = targetValue.originalTargetName;
+          originalTarget = tmodel.targets[targetValue.originalTargetName];
+          originalTModel = tmodel;
+          if (!originalTarget) {
+            originalTModel = _SearchUtil.SearchUtil.findParentByTarget(tmodel, originalTargetName);
+            originalTarget = originalTModel.targets[targetValue.originalTargetName];
+          }
+          if (originalTarget && typeof originalTarget.onImperativeStep === 'function') {
+            originalTarget.onImperativeStep.call(originalTModel, key, originalTModel.actualValues[key], step, steps);
+            originalTModel.setTargetMethodName(originalTargetName, 'onImperativeStep');
+          }
+        } else {
+          _TargetUtil.TargetUtil.handleValueChange(tmodel, key, tmodel.actualValues[key], oldValue, oldStep, oldCycle);
+        }
+        tmodel.incrementTargetStep(key);
+        tmodel.resetScheduleTimeStamp(key);
+        tmodel.updateTargetStatus(key);
+        if (tmodel.isTargetUpdating(key)) {
+          _App.tApp.manager.scheduleRun(interval, "".concat(tmodel.oid, "---").concat(key, "-").concat(step, "/").concat(steps, "-").concat(cycle, "-").concat(interval));
+          return;
+        }
+      }
+      tmodel.actualValues[key] = theValue;
+      tmodel.setActualValueLastUpdate(key);
+      step = tmodel.getTargetStep(key);
+      var scheduleTime = 0;
+      if (targetValue.valueList && cycle < targetValue.valueList.length - 1) {
+        tmodel.incrementTargetCycle(key, tmodel.getTargetCycle(key));
+        cycle = tmodel.getTargetCycle(key);
+        tmodel.resetTargetStep(key);
+        targetValue.initialValue = targetValue.value;
+        targetValue.value = targetValue.valueList[cycle];
+        targetValue.steps = targetValue.stepList[(cycle - 1) % targetValue.stepList.length];
+        targetValue.interval = targetValue.intervalList[(cycle - 1) % targetValue.intervalList.length];
+        targetValue.easing = targetValue.easingList[(cycle - 1) % targetValue.easingList.length];
+        scheduleTime = interval;
+      } else {
+        if (tmodel.isTargetImperative(key)) {
+          originalTargetName = targetValue.originalTargetName;
+          originalTarget = tmodel.targets[targetValue.originalTargetName];
+          originalTModel = tmodel;
+          if (!originalTarget) {
+            originalTModel = _SearchUtil.SearchUtil.findParentByTarget(tmodel, originalTargetName);
+            originalTarget = originalTModel.targets[targetValue.originalTargetName];
+          }
+          if (originalTarget && typeof originalTarget.onImperativeStep === 'function') {
+            originalTarget.onImperativeStep.call(originalTModel, key, originalTModel.actualValues[key], step, steps);
+            originalTModel.setTargetMethodName(originalTargetName, 'onImperativeStep');
+          }
+          if (originalTarget && typeof originalTarget.onImperativeEnd === 'function') {
+            originalTarget.onImperativeEnd.call(originalTModel, key, originalTModel.actualValues[key]);
+            originalTModel.setTargetMethodName(originalTargetName, 'onImperativeEnd');
+          }
+        } else {
+          if (tmodel.getTargetCycle(key) < tmodel.getTargetCycles(key)) {
+            tmodel.incrementTargetCycle(key, tmodel.getTargetCycle(key));
+            tmodel.resetTargetStep(key).resetTargetInitialValue(key).resetTargetExecutionFlag(key);
+            _TargetExecutor.TargetExecutor.executeDeclarativeTarget(tmodel, key);
+          }
+          if (_typeof(tmodel.targets[key]) === 'object' && typeof tmodel.targets[key].onStepsEnd === 'function') {
+            tmodel.targets[key].onStepsEnd.call(tmodel, cycle);
+            tmodel.setTargetMethodName(key, 'onStepsEnd');
+          }
+        }
+      }
+      tmodel.updateTargetStatus(key);
+      _App.tApp.manager.scheduleRun(scheduleTime, "".concat(tmodel.oid, "---").concat(key, "-").concat(step, "/").concat(steps, "-").concat(cycle, "-").concat(interval));
+    }
+  }]);
+}();