targetj 1.0.74 → 1.0.76

package/build/TModel.js

@@ -0,0 +1,1000 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TModel = void 0;
+var _App = require("./App.js");
+var _Browser = require("./Browser.js");
+var _SearchUtil = require("./SearchUtil.js");
+var _TUtil = require("./TUtil.js");
+var _TargetUtil = require("./TargetUtil.js");
+var _TargetExecutor = require("./TargetExecutor.js");
+var _Viewport = require("./Viewport.js");
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+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 TModel = exports.TModel = /*#__PURE__*/function () {
+  function TModel(type, targets) {
+    _classCallCheck(this, TModel);
+    if (arguments.length === 1 && _typeof(type) === 'object') {
+      targets = type;
+      type = "";
+    }
+    this.type = type || 'blank';
+    this.targets = Object.assign({}, targets);
+    this.activeTargetList = [];
+    this.activeTargetMap = {};
+    var uniqueId = _App.App.getOid(this.type);
+    this.oid = uniqueId.oid;
+    this.oidNum = uniqueId.num;
+    this.targetValues = {};
+    this.actualValues = {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      leftMargin: 0,
+      rightMargin: 0,
+      topMargin: 0,
+      bottomMargin: 0,
+      innerWidth: undefined,
+      innerHeight: undefined,
+      opacity: 1,
+      zIndex: 1,
+      scale: 1,
+      rotate: 0,
+      scrollLeft: 0,
+      scrollTop: 0,
+      textOnly: true,
+      html: undefined,
+      css: '',
+      style: null,
+      borderRadius: 0,
+      children: [],
+      addedChildren: [],
+      allChildren: [],
+      isInFlow: true,
+      canHaveDom: true,
+      canHandleEvents: false,
+      widthFromDom: false,
+      heightFromDom: false,
+      keepEventDefault: false,
+      isIncluded: true,
+      canBeBracketed: true,
+      isDomDeletable: true,
+      calculateChildren: undefined,
+      isVisible: undefined
+    };
+    this.updatingTargetList = [];
+    this.updatingTargetMap = {};
+    this.styleTargetList = [];
+    this.styleTargetMap = {};
+    this.updatingChildrenList = [];
+    this.updatingChildrenMap = {};
+    this.targetMethodMap = {};
+    this.parent = null;
+    this.$dom = null;
+    this.visibilityStatus = {
+      top: false,
+      right: false,
+      bottom: false,
+      left: false
+    };
+    this.visible = false;
+    this.domHeight = undefined;
+    this.domWidth = undefined;
+    this.innerContentWidth = 0;
+    this.innerContentHeight = 0;
+    this.contentWidth = 0;
+    this.contentHeight = 0;
+    this.x = 0;
+    this.y = 0;
+    this.absX = 0;
+    this.absY = 0;
+    this.inFlowVisibles = [];
+    this.domValues = {};
+    this.initTargets();
+  }
+  return _createClass(TModel, [{
+    key: "getParent",
+    value: function getParent() {
+      return this.parent;
+    }
+  }, {
+    key: "getRealParent",
+    value: function getRealParent() {
+      return this.parent;
+    }
+  }, {
+    key: "getDomParent",
+    value: function getDomParent() {
+      return this.actualValues.domParent ? this.actualValues.domParent : null;
+    }
+  }, {
+    key: "getDomHolder",
+    value: function getDomHolder() {
+      return this.actualValues.domHolder ? this.actualValues.domHolder : this.getDomParent() ? this.getDomParent().$dom : _SearchUtil.SearchUtil.findParentByTarget(this, 'domHolder') ? _SearchUtil.SearchUtil.findParentByTarget(this, 'domHolder').$dom : null;
+    }
+  }, {
+    key: "addToStyleTargetList",
+    value: function addToStyleTargetList(key) {
+      if (!_TargetUtil.TargetUtil.styleTargetMap[key]) {
+        return;
+      }
+      key = _TargetUtil.TargetUtil.transformMap[key] ? 'transform' : _TargetUtil.TargetUtil.dimMap[key] ? 'dim' : key;
+      if (!this.styleTargetMap[key]) {
+        this.styleTargetList.push(key);
+        this.styleTargetMap[key] = true;
+      }
+    }
+  }, {
+    key: "bug",
+    value: function bug() {
+      return [{
+        visible: this.isVisible()
+      }, {
+        visibilityStatus: this.visibilityStatus
+      }, {
+        hasDom: this.hasDom()
+      }, {
+        x: this.getX()
+      }, {
+        y: this.getY()
+      }, {
+        width: this.getWidth()
+      }, {
+        height: this.getHeight()
+      }, {
+        activeTargetList: this.activeTargetList
+      }, {
+        updatingTargetList: this.updatingTargetList
+      }, {
+        styleTargetList: this.styleTargetList
+      }, {
+        children: this.getChildren()
+      }, {
+        targetValues: this.targetValues
+      }, {
+        actualValues: this.actualValues
+      }];
+    }
+  }, {
+    key: "initTargets",
+    value: function initTargets() {
+      var _this = this;
+      this.targetValues = {};
+      this.activeTargetMap = {};
+      this.activeTargetList = [];
+      Object.keys(this.targets).forEach(function (key) {
+        _this.processNewTarget(key);
+      });
+    }
+  }, {
+    key: "processNewTarget",
+    value: function processNewTarget(key) {
+      _TargetUtil.TargetUtil.bindTargetName(this.targets, key);
+      if (_TUtil.TUtil.isDefined(this.targets[key].initialValue)) {
+        this.actualValues[key] = this.targets[key].initialValue;
+        this.addToStyleTargetList(key);
+      }
+      if (this.targets[key].active !== false) {
+        this.addToActiveTargets(key);
+      }
+    }
+  }, {
+    key: "hasDomHolderChanged",
+    value: function hasDomHolderChanged() {
+      return this.getDomHolder() && this.getDomHolder().exists() && this.$dom.parent().getAttribute("id") !== this.getDomHolder().attr("id");
+    }
+  }, {
+    key: "hasDom",
+    value: function hasDom() {
+      return !!this.$dom && this.$dom.exists();
+    }
+  }, {
+    key: "hasChildren",
+    value: function hasChildren() {
+      return this.getChildren().length > 0;
+    }
+  }, {
+    key: "getChildren",
+    value: function getChildren() {
+      var _this2 = this;
+      var lastUpdateAllChildren = this.getActualValueLastUpdate('allChildren');
+      var lastUpdateChildren = this.getActualValueLastUpdate('children');
+      var lastUpdateAddedChildren = this.getActualValueLastUpdate('addedChildren');
+      if (!lastUpdateAllChildren || lastUpdateChildren >= lastUpdateAllChildren || lastUpdateAddedChildren >= lastUpdateAllChildren) {
+        var children = this.actualValues.children;
+        var addedChildren = this.actualValues.addedChildren;
+        this.actualValues.allChildren = [].concat(children, addedChildren);
+        if (children && children.length > 0) {
+          children.forEach(function (t) {
+            return t.parent = _this2;
+          });
+          this.actualValues.allChildren.sort(function (a, b) {
+            return !a.canBeBracketed() && b.canBeBracketed() ? -1 : 1;
+          });
+        }
+        if (this.targetValues['allChildren']) {
+          this.setActualValueLastUpdate('allChildren');
+        } else {
+          this.setTarget('allChildren', this.actualValues.allChildren);
+        }
+      }
+      return this.actualValues.allChildren;
+    }
+  }, {
+    key: "getLastChild",
+    value: function getLastChild() {
+      return this.hasChildren() ? this.getChildren()[this.getChildren().length - 1] : undefined;
+    }
+  }, {
+    key: "getFirstChild",
+    value: function getFirstChild() {
+      return this.hasChildren() ? this.getChildren()[0] : undefined;
+    }
+  }, {
+    key: "getChild",
+    value: function getChild(index) {
+      return this.hasChildren() ? this.getChildren()[index] : undefined;
+    }
+  }, {
+    key: "getChildIndex",
+    value: function getChildIndex(child) {
+      return this.getChildren().indexOf(child);
+    }
+  }, {
+    key: "getChildrenOids",
+    value: function getChildrenOids() {
+      return this.getChildren().oids();
+    }
+  }, {
+    key: "filterChildren",
+    value: function filterChildren(type) {
+      return this.getChildren().filter(function (tmodel) {
+        return Array.isArray(type) ? type.includes(tmodel.type) : typeof type === 'function' ? type.call(tmodel) : tmodel.type === type;
+      });
+    }
+  }, {
+    key: "findChild",
+    value: function findChild(type) {
+      return this.getChildren().find(function (child) {
+        return typeof type === 'function' ? type.call(child) : child.type === type;
+      });
+    }
+  }, {
+    key: "findLastChild",
+    value: function findLastChild(type) {
+      return this.getChildren().findLast(function (child) {
+        return typeof type === 'function' ? type.call(child) : child.type === type;
+      });
+    }
+  }, {
+    key: "getParentValue",
+    value: function getParentValue(targetName) {
+      var parent = _SearchUtil.SearchUtil.findParentByTarget(this, targetName);
+      return parent ? parent.val(targetName) : undefined;
+    }
+  }, {
+    key: "getContentHeight",
+    value: function getContentHeight() {
+      return this.contentHeight;
+    }
+  }, {
+    key: "getInnerContentHeight",
+    value: function getInnerContentHeight() {
+      return 0;
+    }
+  }, {
+    key: "getInnerHeight",
+    value: function getInnerHeight() {
+      return _TUtil.TUtil.isDefined(this.actualValues.innerHeight) ? this.actualValues.innerHeight : this.getHeight();
+    }
+  }, {
+    key: "getInnerWidth",
+    value: function getInnerWidth() {
+      return _TUtil.TUtil.isDefined(this.actualValues.innerWidth) ? this.actualValues.innerWidth : this.getWidth();
+    }
+  }, {
+    key: "getInnerXEast",
+    value: function getInnerXEast() {
+      return this.absX + this.getInnerWidth();
+    }
+  }, {
+    key: "getOuterXEast",
+    value: function getOuterXEast() {
+      return this.absX + this.getInnerWidth();
+    }
+  }, {
+    key: "getContentWidth",
+    value: function getContentWidth() {
+      return this.contentWidth;
+    }
+  }, {
+    key: "getUIDepth",
+    value: function getUIDepth() {
+      var depth = 0;
+      var node = this.parent;
+      while (node) {
+        depth++;
+        node = node.parent;
+      }
+      return depth;
+    }
+  }, {
+    key: "addToParentVisibleList",
+    value: function addToParentVisibleList() {
+      if (this.isVisible() && this.isInFlow() && this.getParent()) {
+        this.getParent().inFlowVisibles.push(this);
+      }
+    }
+  }, {
+    key: "isVisible",
+    value: function isVisible() {
+      return _TUtil.TUtil.isDefined(this.actualValues.isVisible) ? this.actualValues.isVisible : this.visible;
+    }
+  }, {
+    key: "shouldCalculateChildren",
+    value: function shouldCalculateChildren() {
+      return _TUtil.TUtil.isDefined(this.actualValues.calculateChildren) ? this.actualValues.calculateChildren : this.isVisible() && this.isIncluded() && (this.hasChildren() || this.getContentHeight() > 0);
+    }
+  }, {
+    key: "createViewport",
+    value: function createViewport() {
+      this.viewport = this.viewport ? this.viewport.reset() : new _Viewport.Viewport(this);
+      return this.viewport;
+    }
+  }, {
+    key: "setLocation",
+    value: function setLocation(viewport) {
+      this.x = viewport.getXNext();
+      this.y = viewport.getYNext();
+    }
+  }, {
+    key: "calculateAbsolutePosition",
+    value: function calculateAbsolutePosition(x, y) {
+      var rect = this.getBoundingRect();
+      this.absX = rect.left + x;
+      this.absY = rect.top + y;
+    }
+  }, {
+    key: "getBoundingRect",
+    value: function getBoundingRect() {
+      return _TUtil.TUtil.getBoundingRect(this);
+    }
+  }, {
+    key: "isMarkedDeleted",
+    value: function isMarkedDeleted() {
+      return this.val('tmodelDeletedFlag') === true;
+    }
+  }, {
+    key: "markAsDeleted",
+    value: function markAsDeleted() {
+      this.val('tmodelDeletedFlag', true);
+      this.getChildren().forEach(function (tmodel) {
+        return tmodel.markAsDeleted();
+      });
+    }
+  }, {
+    key: "isTextOnly",
+    value: function isTextOnly() {
+      return this.actualValues.textOnly;
+    }
+  }, {
+    key: "getHtml",
+    value: function getHtml() {
+      return this.actualValues.html;
+    }
+  }, {
+    key: "isInFlow",
+    value: function isInFlow() {
+      return this.actualValues.isInFlow;
+    }
+  }, {
+    key: "canHandleEvents",
+    value: function canHandleEvents(eventName) {
+      var events = this.actualValues.canHandleEvents;
+      return events === eventName || Array.isArray(events) && events.includes(eventName);
+    }
+  }, {
+    key: "keepEventDefault",
+    value: function keepEventDefault() {
+      return this.actualValues.keepEventDefault;
+    }
+  }, {
+    key: "canBeBracketed",
+    value: function canBeBracketed() {
+      return this.actualValues.canBeBracketed;
+    }
+  }, {
+    key: "isIncluded",
+    value: function isIncluded() {
+      return this.actualValues.isIncluded;
+    }
+  }, {
+    key: "canHaveDom",
+    value: function canHaveDom() {
+      return this.actualValues.canHaveDom;
+    }
+  }, {
+    key: "isDomDeletable",
+    value: function isDomDeletable() {
+      return this.actualValues.isDomDeletable;
+    }
+  }, {
+    key: "getOpacity",
+    value: function getOpacity() {
+      return this.actualValues.opacity;
+    }
+  }, {
+    key: "getX",
+    value: function getX() {
+      return this.actualValues.x;
+    }
+  }, {
+    key: "getY",
+    value: function getY() {
+      return this.actualValues.y;
+    }
+  }, {
+    key: "getZIndex",
+    value: function getZIndex() {
+      return this.actualValues.zIndex;
+    }
+  }, {
+    key: "getScale",
+    value: function getScale() {
+      return this.actualValues.scale;
+    }
+  }, {
+    key: "getMeasuringScale",
+    value: function getMeasuringScale() {
+      return this.actualValues.scale;
+    }
+  }, {
+    key: "getTopMargin",
+    value: function getTopMargin() {
+      return this.actualValues.topMargin;
+    }
+  }, {
+    key: "getLeftMargin",
+    value: function getLeftMargin() {
+      return this.actualValues.leftMargin;
+    }
+  }, {
+    key: "getRightMargin",
+    value: function getRightMargin() {
+      return this.actualValues.rightMargin;
+    }
+  }, {
+    key: "getBottomMargin",
+    value: function getBottomMargin() {
+      return this.actualValues.bottomMargin;
+    }
+  }, {
+    key: "getRotate",
+    value: function getRotate() {
+      return this.actualValues.rotate;
+    }
+  }, {
+    key: "getWidth",
+    value: function getWidth() {
+      return this.actualValues.width;
+    }
+  }, {
+    key: "getHeight",
+    value: function getHeight() {
+      return this.actualValues.height;
+    }
+  }, {
+    key: "getScrollTop",
+    value: function getScrollTop() {
+      return Math.floor(this.actualValues.scrollTop);
+    }
+  }, {
+    key: "getScrollLeft",
+    value: function getScrollLeft() {
+      return Math.floor(this.actualValues.scrollLeft);
+    }
+  }, {
+    key: "getCss",
+    value: function getCss() {
+      return this.actualValues.css.includes('tgt') ? this.actualValues.css : !this.actualValues.css ? 'tgt' : 'tgt ' + this.actualValues.css;
+    }
+  }, {
+    key: "getStyle",
+    value: function getStyle() {
+      return this.actualValues.style;
+    }
+  }, {
+    key: "getScaledWidth",
+    value: function getScaledWidth() {
+      return this.getWidth() * this.getScale();
+    }
+  }, {
+    key: "getScaledHeight",
+    value: function getScaledHeight() {
+      return this.getHeight() * this.getScale();
+    }
+  }, {
+    key: "getTargetStepPercent",
+    value: function getTargetStepPercent(key, step) {
+      var steps = this.getTargetSteps(key);
+      step = !_TUtil.TUtil.isDefined(step) ? this.getTargetStep(key) : step;
+      return steps ? step / steps : 1;
+    }
+  }, {
+    key: "resetTargetStep",
+    value: function resetTargetStep(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].step = 0;
+      }
+      return this;
+    }
+  }, {
+    key: "resetTargetExecutionFlag",
+    value: function resetTargetExecutionFlag(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].executionFlag = false;
+      }
+      return this;
+    }
+  }, {
+    key: "resetTargetCycle",
+    value: function resetTargetCycle(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].cycle = 0;
+      }
+      return this;
+    }
+  }, {
+    key: "resetScheduleTimeStamp",
+    value: function resetScheduleTimeStamp(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].scheduleTimeStamp = undefined;
+      }
+      return this;
+    }
+  }, {
+    key: "resetTargetInitialValue",
+    value: function resetTargetInitialValue(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].initialValue = undefined;
+      }
+      return this;
+    }
+  }, {
+    key: "updateTargetStatus",
+    value: function updateTargetStatus(key) {
+      var targetValue = this.targetValues[key];
+      if (!targetValue) {
+        return;
+      }
+      var cycle = this.getTargetCycle(key);
+      var cycles = this.getTargetCycles(key);
+      var step = this.getTargetStep(key);
+      var steps = this.getTargetSteps(key);
+      if (this.isExecuted(key) && step < steps) {
+        this.targetValues[key].status = 'updating';
+      } else if (Array.isArray(targetValue.valueList) && cycle < targetValue.valueList.length - 1) {
+        this.targetValues[key].status = 'updating';
+      } else if (!this.isExecuted(key) || this.isTargetInLoop(key) || cycle < cycles) {
+        this.targetValues[key].status = 'active';
+      } else {
+        this.targetValues[key].status = 'done';
+      }
+      if (this.isTargetUpdating(key)) {
+        this.addToUpdatingTargets(key);
+        this.removeFromActiveTargets(key);
+      } else if (this.isTargetActive(key)) {
+        this.addToActiveTargets(key);
+        this.removeFromUpdatingTargets(key);
+      } else {
+        this.removeFromActiveTargets(key);
+        this.removeFromUpdatingTargets(key);
+        _App.tApp.manager.doneTargets.push({
+          tmodel: this,
+          key: key
+        });
+      }
+      return this.targetValues[key].status;
+    }
+  }, {
+    key: "getTargetStatus",
+    value: function getTargetStatus(key) {
+      return this.targetValues[key] ? this.targetValues[key].status : '';
+    }
+  }, {
+    key: "isTargetActive",
+    value: function isTargetActive(key) {
+      return this.targetValues[key] && this.targetValues[key].status === 'active';
+    }
+  }, {
+    key: "isTargetUpdating",
+    value: function isTargetUpdating(key) {
+      return this.targetValues[key] && this.targetValues[key].status === 'updating';
+    }
+  }, {
+    key: "isTargetDone",
+    value: function isTargetDone(key) {
+      return this.targetValues[key] && this.targetValues[key].status === 'done';
+    }
+  }, {
+    key: "isTargetComplete",
+    value: function isTargetComplete(key) {
+      return this.targetValues[key] && this.targetValues[key].status === 'complete';
+    }
+  }, {
+    key: "isExecuted",
+    value: function isExecuted(key) {
+      return this.targetValues[key] && this.targetValues[key].executionFlag;
+    }
+  }, {
+    key: "isTargetImperative",
+    value: function isTargetImperative(key) {
+      return this.targetValues[key] ? this.targetValues[key].isImperative : false;
+    }
+  }, {
+    key: "getTargetExecutionCount",
+    value: function getTargetExecutionCount(key) {
+      return this.targetValues[key] ? this.targetValues[key].executionCount : 0;
+    }
+  }, {
+    key: "setTargetComplete",
+    value: function setTargetComplete(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].status = 'complete';
+      }
+    }
+  }, {
+    key: "isTargetEnabled",
+    value: function isTargetEnabled(key) {
+      if (this.isTargetImperative(key)) {
+        return true;
+      }
+      var target = this.targets[key];
+      if (!_TUtil.TUtil.isDefined(target)) {
+        return false;
+      }
+      return typeof target.enabledOn === 'function' ? target.enabledOn.call(this) : true;
+    }
+  }, {
+    key: "isTargetInLoop",
+    value: function isTargetInLoop(key) {
+      return this.targets[key] ? typeof this.targets[key].loop === 'function' ? this.targets[key].loop.call(this, key) : this.targets[key].loop : false;
+    }
+  }, {
+    key: "doesTargetEqualActual",
+    value: function doesTargetEqualActual(key) {
+      if (this.targetValues[key]) {
+        var deepEquality = this.targets[key] ? this.targets[key].deepEquality : false;
+        return deepEquality ? _TUtil.TUtil.areEqual(this.getTargetValue(key), this.val(key), deepEquality) : this.getTargetValue(key) === this.val(key);
+      }
+      return false;
+    }
+  }, {
+    key: "getTargetValue",
+    value: function getTargetValue(key) {
+      return this.targetValues[key] ? typeof this.targetValues[key].value === 'function' ? this.targetValues[key].value.call(this) : this.targetValues[key].value : undefined;
+    }
+  }, {
+    key: "getTargetSteps",
+    value: function getTargetSteps(key) {
+      return this.targetValues[key] ? this.targetValues[key].steps || 0 : 0;
+    }
+  }, {
+    key: "getTargetStep",
+    value: function getTargetStep(key) {
+      return this.targetValues[key] ? this.targetValues[key].step : 0;
+    }
+  }, {
+    key: "getScheduleTimeStamp",
+    value: function getScheduleTimeStamp(key) {
+      return this.targetValues[key] ? this.targetValues[key].scheduleTimeStamp : undefined;
+    }
+  }, {
+    key: "getTargetInitialValue",
+    value: function getTargetInitialValue(key) {
+      return this.targetValues[key] ? this.targetValues[key].initialValue : undefined;
+    }
+  }, {
+    key: "getActualValueLastUpdate",
+    value: function getActualValueLastUpdate(key) {
+      return this.targetValues[key] ? this.targetValues[key].actualValueLastUpdate : undefined;
+    }
+  }, {
+    key: "getTargetCreationTime",
+    value: function getTargetCreationTime(key) {
+      return this.targetValues[key] ? this.targetValues[key].creationTime : undefined;
+    }
+  }, {
+    key: "incrementTargetStep",
+    value: function incrementTargetStep(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].step++;
+      }
+      return this.targetValues[key].step;
+    }
+  }, {
+    key: "getTargetCycles",
+    value: function getTargetCycles(key) {
+      return this.targetValues[key] ? this.targetValues[key].cycles || 0 : 0;
+    }
+  }, {
+    key: "getTargetCycle",
+    value: function getTargetCycle(key) {
+      return this.targetValues[key] ? this.targetValues[key].cycle : 0;
+    }
+  }, {
+    key: "incrementTargetCycle",
+    value: function incrementTargetCycle(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].cycle++;
+      }
+      return this.targetValues[key].cycle;
+    }
+  }, {
+    key: "setTargetInterval",
+    value: function setTargetInterval(key, value) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].interval = value;
+      }
+      return this.targetValues[key].interval;
+    }
+  }, {
+    key: "setScheduleTimeStamp",
+    value: function setScheduleTimeStamp(key, value) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].scheduleTimeStamp = value;
+      }
+    }
+  }, {
+    key: "setTargetInitialValue",
+    value: function setTargetInitialValue(key, value) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].initialValue = value;
+      }
+    }
+  }, {
+    key: "setActualValueLastUpdate",
+    value: function setActualValueLastUpdate(key) {
+      if (this.targetValues[key]) {
+        this.targetValues[key].actualValueLastUpdate = _Browser.browser.now();
+      }
+    }
+  }, {
+    key: "getTargetEasing",
+    value: function getTargetEasing(key) {
+      return typeof this.targetValues[key].easing === 'function' ? this.targetValues[key].easing : undefined;
+    }
+  }, {
+    key: "getTargetInterval",
+    value: function getTargetInterval(key) {
+      return this.targetValues[key] ? this.targetValues[key].interval : undefined;
+    }
+  }, {
+    key: "getTargetEventFunctions",
+    value: function getTargetEventFunctions(key) {
+      return this.targetValues[key] ? this.targetValues[key].events : undefined;
+    }
+  }, {
+    key: "setTarget",
+    value: function setTarget(key, value, steps, interval, easing, originalTargetName) {
+      originalTargetName = originalTargetName || this.key;
+      _TargetExecutor.TargetExecutor.executeImperativeTarget(this, key, value, steps, interval, easing, originalTargetName);
+      return this;
+    }
+  }, {
+    key: "val",
+    value: function val(key, value) {
+      if (arguments.length === 2) {
+        this.actualValues[key] = value;
+        return this;
+      }
+      return this.actualValues[key];
+    }
+  }, {
+    key: "addValue",
+    value: function addValue(key, value) {
+      this.actualValues[key] += value;
+      return this;
+    }
+  }, {
+    key: "multiplyValue",
+    value: function multiplyValue(key, value) {
+      this.actualValues[key] *= value;
+      return this;
+    }
+  }, {
+    key: "addChild",
+    value: function addChild(child, index) {
+      var addedChildren = this.actualValues.addedChildren;
+      index = _TUtil.TUtil.isDefined(index) ? index : addedChildren.length;
+      child.parent = this;
+      if (index >= addedChildren.length) {
+        addedChildren.push(child);
+      } else {
+        addedChildren.splice(index, 0, child);
+      }
+      this.setActualValueLastUpdate('children');
+      if (this.targetValues['addedChildren']) {
+        this.setActualValueLastUpdate('addedChildren');
+      } else {
+        this.setTarget('addedChildren', addedChildren);
+      }
+      _App.tApp.manager.scheduleRun(10, 'addChild-' + this.oid + "-" + child.oid);
+      return this;
+    }
+  }, {
+    key: "addToUpdatingChildren",
+    value: function addToUpdatingChildren(child) {
+      if (!this.updatingChildrenMap[child.oid]) {
+        this.updatingChildrenMap[child.oid] = true;
+        this.updatingChildrenList.push(child.oid);
+      }
+    }
+  }, {
+    key: "removeFromUpdatingChildren",
+    value: function removeFromUpdatingChildren(child) {
+      if (this.updatingChildrenMap[child.oid]) {
+        delete this.updatingChildrenMap[child.oid];
+        var index = this.updatingChildrenList.indexOf(child.oid);
+        if (index >= 0) {
+          this.updatingChildrenList.splice(index, 1);
+        }
+      }
+    }
+  }, {
+    key: "hasUpdatingChildren",
+    value: function hasUpdatingChildren() {
+      return this.updatingChildrenList.length > 0;
+    }
+  }, {
+    key: "hasTargetUpdates",
+    value: function hasTargetUpdates(key) {
+      return key ? this.updatingTargetMap[key] === true : this.updatingTargetList.length > 0;
+    }
+  }, {
+    key: "removeTarget",
+    value: function removeTarget(key) {
+      delete this.targets[key];
+      this.removeFromActiveTargets(key);
+      this.removeFromUpdatingTargets(key);
+      delete this.targetValues[key];
+    }
+  }, {
+    key: "addTarget",
+    value: function addTarget(key, target) {
+      this.addTargets(_defineProperty({}, key, target));
+    }
+  }, {
+    key: "addTargets",
+    value: function addTargets(targets) {
+      var _this3 = this;
+      Object.keys(targets).forEach(function (key) {
+        _this3.targets[key] = targets[key];
+        _this3.removeFromUpdatingTargets(key);
+        _this3.processNewTarget(key);
+      });
+      _App.tApp.manager.scheduleRun(10, 'addTargets-' + this.oid);
+    }
+  }, {
+    key: "addToActiveTargets",
+    value: function addToActiveTargets(key) {
+      if (!this.activeTargetMap[key]) {
+        this.activeTargetMap[key] = true;
+        if (key === 'start') {
+          this.activeTargetList.unshift('start');
+        } else if (key === 'width' || key === 'height') {
+          var startIndex = this.activeTargetList.indexOf('start');
+          if (startIndex !== -1) {
+            this.activeTargetList.splice(1, 0, key);
+          } else {
+            this.activeTargetList.unshift(key);
+          }
+        } else {
+          this.activeTargetList.push(key);
+        }
+      }
+    }
+  }, {
+    key: "removeFromActiveTargets",
+    value: function removeFromActiveTargets(key) {
+      if (this.activeTargetMap[key]) {
+        delete this.activeTargetMap[key];
+        var index = this.activeTargetList.indexOf(key);
+        if (index >= 0) {
+          this.activeTargetList.splice(index, 1);
+        }
+      }
+    }
+  }, {
+    key: "addToUpdatingTargets",
+    value: function addToUpdatingTargets(key) {
+      if (!this.updatingTargetMap[key]) {
+        this.updatingTargetMap[key] = true;
+        this.updatingTargetList.push(key);
+        if (this.getParent()) {
+          this.getParent().addToUpdatingChildren(this);
+        }
+      }
+    }
+  }, {
+    key: "removeFromUpdatingTargets",
+    value: function removeFromUpdatingTargets(key) {
+      if (this.updatingTargetMap[key]) {
+        delete this.updatingTargetMap[key];
+        var index = this.updatingTargetList.indexOf(key);
+        if (index >= 0) {
+          this.updatingTargetList.splice(index, 1);
+        }
+        if (this.updatingTargetList.length === 0 && this.getParent()) {
+          this.getParent().removeFromUpdatingChildren(this);
+        }
+      }
+    }
+  }, {
+    key: "deleteTargetValue",
+    value: function deleteTargetValue(key) {
+      delete this.targetValues[key];
+      this.addToActiveTargets(key);
+      this.removeFromUpdatingTargets(key);
+      _App.tApp.manager.scheduleRun(10, 'deleteTargetValue-' + this.oid + "-" + key);
+    }
+  }, {
+    key: "resetImperative",
+    value: function resetImperative(key) {
+      var targetValue = this.targetValues[key];
+      if (targetValue) {
+        targetValue.isImperative = false;
+        targetValue.executionFlag = false;
+        targetValue.scheduleTimeStamp = undefined;
+        targetValue.step = 0;
+        targetValue.cycle = 0;
+        targetValue.steps = 0;
+        targetValue.cycles = 0;
+        targetValue.interval = 0;
+      }
+      return this;
+    }
+  }, {
+    key: "activateTarget",
+    value: function activateTarget(key) {
+      return this.activateTargets([key]);
+    }
+  }, {
+    key: "activateTargets",
+    value: function activateTargets(keys) {
+      var _this4 = this;
+      keys.forEach(function (key) {
+        var targetValue = _this4.targetValues[key];
+        if (targetValue) {
+          targetValue.executionFlag = false;
+          targetValue.scheduleTimeStamp = undefined;
+          targetValue.step = 0;
+          targetValue.cycle = 0;
+          _this4.updateTargetStatus(key);
+        } else {
+          _this4.addToActiveTargets(key);
+        }
+      });
+      _App.tApp.manager.scheduleRun(10, 'activateTargets-' + this.oid);
+      return this;
+    }
+  }, {
+    key: "setTargetMethodName",
+    value: function setTargetMethodName(targetName, methodName) {
+      if (!this.targetMethodMap[targetName]) {
+        this.targetMethodMap[targetName] = [];
+      }
+      if (!this.targetMethodMap[targetName].includes(methodName)) {
+        this.targetMethodMap[targetName].push(methodName);
+      }
+    }
+  }]);
+}();