targetj 1.0.51 → 1.0.53

package/Exports.js

@@ -1,5 +1,6 @@
 export * from "./src/App.js"
 export * from "./src/TModel.js"
 export * from "./src/SearchUtil.js"
+export * from "./src/TargetUtil.js"
 export * from "./src/TUtil.js"
 export * from "./src/Browser.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "targetj",
-  "version": "1.0.51",
+  "version": "1.0.53",
   "keywords": [
     "targetj"
   ],

package/src/Bracket.js

@@ -5,15 +5,14 @@ import { browser } from "./Browser.js";
 
 function Bracket(parent) {
 
-    var tm = new TModel("BI");
-    tm.parent = parent;
-    tm.newFlag = true;
-    
-    tm.targets = {
+    var tm = new TModel("BI", {
         canHaveDom: false,
-        outerXEast: 0
-    };
+        outerXEast: 0        
+    });
     
+    tm.parent = parent;
+    tm.newFlag = true;
+
     tm.getWidth = function()    {
         return this.getContentWidth();
     };

package/src/LocationManager.js

@@ -18,18 +18,7 @@ LocationManager.prototype.calculateAll = function() {
     this.locationCount.length = 0;
     this.startTime = browser.now();
 
-    this.calculate(); 
-        
-    if (tapp.targetManager.doneTargets.length > 0) {
-        tapp.targetManager.doneTargets.forEach(function(target) {
-            //imperative call is possible till this gets executed so we need to make sure that it is still done
-            if (target.tmodel.isTargetDone(target.key)) {
-                target.tmodel.setTargetComplete(target.key);
-            }
-        });
-        
-        tapp.manager.scheduleRun(10, "done to complete");            
-    }
+    this.calculate();
 };
 
 LocationManager.prototype.calculate = function() {                   
@@ -90,7 +79,7 @@ LocationManager.prototype.calculateContainer = function(container) {
 
         if (!child.targetUpdatingMap.x) {
             if (TUtil.isDefined(child.targets.x)) {
-                tapp.targetManager.setTargetValue(child, 'x');
+                //tapp.targetManager.setTargetValue(child, 'x');
             } else if (!TUtil.isDefined(child.targetValues.x)) {
                 child.setValue('x', child.x);                
             }
@@ -98,7 +87,7 @@ LocationManager.prototype.calculateContainer = function(container) {
 
         if (!child.targetUpdatingMap.y) {
             if (TUtil.isDefined(child.targets.y)) {
-                tapp.targetManager.setTargetValue(child, 'y');
+                //tapp.targetManager.setTargetValue(child, 'y');
             } else if (!TUtil.isDefined(child.targetValues.y)) {
                 child.setValue('y', child.y);
             }            
@@ -120,9 +109,14 @@ LocationManager.prototype.calculateContainer = function(container) {
             var childLastHeight = child.getHeight();
            
             if (child.hasChildren()) {
-                tapp.targetManager.setTargetValuesWithKeys(child, ['width', 'height'], true);
-                tapp.targetManager.setJustActualValue(child, 'width');
-                tapp.targetManager.setJustActualValue(child, 'height');
+                if (child.isTargetEnabled('width')) {
+                    TargetUtil.assignValueArray(child, 'width');
+                    tapp.targetManager.setJustActualValue(child, 'width');
+                }
+                if (child.isTargetEnabled('height')) {
+                    TargetUtil.assignValueArray(child, 'height');
+                    tapp.targetManager.setJustActualValue(child, 'height');
+                }
             }
 
             if (child.getHeight() !== childLastHeight && tapp.events.isScrollTopHandler(child.getParent())
@@ -143,8 +137,8 @@ LocationManager.prototype.calculateContainer = function(container) {
     viewport.calcContentWidthHeight();
 };
 
-LocationManager.prototype.calculateTargets = function(tmodel) {           
-    tapp.targetManager.setTargetValues(tmodel);        
+LocationManager.prototype.calculateTargets = function(tmodel) { 
+    tapp.targetManager.setTargetValues(tmodel, Object.keys(tmodel.activeTargetKeyMap));        
     tapp.targetManager.setActualValues(tmodel);
 
     if (!TUtil.isDefined(tmodel.targetValues.width) && tmodel.hasDom()) TargetUtil.setWidthFromDom(tmodel);

package/src/TModel.js

@@ -11,9 +11,15 @@ function TModel(type, targets) {
         targets = type;
         type = "";     
     }
-    
+
+    var self = this;
     this.type = type ? type : 'blank';
-    this.targets = Object.assign({}, targets);  
+    this.targets = Object.assign({}, targets);
+    this.activeTargetKeyMap = {};
+    Object.keys(this.targets).forEach(function(key) {
+        self.activeTargetKeyMap[key] = true;
+    });    
+    
     var uniqueId = App.getOid(this.type);
     this.oid = uniqueId.oid;
     this.oidNum = uniqueId.num;
@@ -54,9 +60,7 @@ function TModel(type, targets) {
         calculateChildren: undefined,
         isVisible: undefined
     };
-    
-    this.activeTargetKeyMap = {};
-    
+        
     this.targetUpdatingMap = {};
     this.targetUpdatingList = [];
     
@@ -489,9 +493,9 @@ TModel.prototype.resetTargetCycle = function(key)   {
     }
 };
 
-TModel.prototype.resetActualTimeStamp = function(key)   {
+TModel.prototype.resetScheduleTimeStamp = function(key)   {
     if (this.targetValues[key]) {
-        this.targetValues[key].actualTimeStamp = undefined;
+        this.targetValues[key].scheduleTimeStamp = undefined;
     }
 };
 
@@ -523,17 +527,25 @@ TModel.prototype.updateTargetStatus = function(key) {
     
     this.targetValues[key].status = '';
    
-    if ((steps > 0 || cycles > 0) && (step < steps || cycle < cycles || !this.doesTargetEqualActual(key))) {
+    if (step < steps || cycle < cycles || !this.doesTargetEqualActual(key)) {
         this.targetValues[key].status = 'updating';
-    } else if (this.doesTargetEqualActual(key) || !this.isTargetInLoop(key)) {   
+    } else if (!this.hasTargetGotExecuted(key) || this.isTargetInLoop(key)) {
+        this.targetValues[key].status = 'active';        
+    } else {   
         this.targetValues[key].status = 'done';
     }
+    
+    return this.targetValues[key].status;
 };
 
-TModel.prototype.getTargetStatus = function(key) {
+TModel.prototype.getTargetStatus = function(key) {   
     return this.targetValues[key] ? this.targetValues[key].status : 0;
 };
 
+TModel.prototype.isTargetActive = function(key) {
+    return this.targetValues[key] && this.targetValues[key].status === 'active';
+};
+
 TModel.prototype.isTargetUpdating = function(key) {
     return this.targetValues[key] && this.targetValues[key].status === 'updating';
 };
@@ -547,7 +559,15 @@ TModel.prototype.isTargetComplete = function(key) {
 };
 
 TModel.prototype.hasTargetGotExecuted = function(key) {
-    return this.targets[key] ? this.targetValues[key] && this.targetValues[key].executionCounter > 0 : true;
+    return this.targets[key] ? this.targetValues[key] && this.targetValues[key].executionCount > 0 : true;
+};
+
+TModel.prototype.isTargetImperative = function(key) {
+    return this.targetValues[key] ? this.targetValues[key] && this.targetValues[key].callingTargetKey !== key : false;    
+};
+
+TModel.prototype.getTargetExecutionCount = function(key) {
+    return this.targetValues[key] ? this.targetValues[key].executionCount : 0;    
 };
 
 TModel.prototype.setTargetComplete = function(key) {
@@ -559,11 +579,9 @@ TModel.prototype.setTargetComplete = function(key) {
 TModel.prototype.isTargetEnabled = function(key) {
     var target = this.targets[key];
     
-    if (!TUtil.isDefined(target) || target.enabledOn === false) return false;
+    if (!TUtil.isDefined(target)) return false;
       
-    var targetEnabled = typeof target.enabledOn === 'function' ? target.enabledOn.call(this, key) : true;
-    
-    return !!targetEnabled;
+    return typeof target.enabledOn === 'function' ? target.enabledOn.call(this, key) : target.enabledOn === false ? false : true;
 };
 
 TModel.prototype.isTargetInLoop = function(key) {            
@@ -571,11 +589,16 @@ TModel.prototype.isTargetInLoop = function(key) {
 };
 
 TModel.prototype.doesTargetEqualActual = function(key) {
-    return this.targetValues[key] && this.getTargetValue(key) === this.getValue(key);
+    if (this.targetValues[key]) {
+        var deepEquality =  this.targets[key] ? this.targets[key].deepEquality : false;
+        return deepEquality ? TUtil.areEqual(this.getTargetValue(key), this.getValue(key), deepEquality) : this.getTargetValue(key) === this.getValue(key);
+    } 
+    
+    return false;
 };
 
 TModel.prototype.getTargetValue = function(key)  {
-    return this.targetValues[key] ? (typeof this.targetValues[key].value  === 'function' ? this.targetValues[key].value.call(this) :  this.targetValues[key].value) : undefined;
+    return this.targetValues[key] ? (typeof this.targetValues[key].value  === 'function' ? this.targetValues[key].value.call(this) : this.targetValues[key].value) : undefined;
 };
 
 TModel.prototype.getTargetSteps = function(key)  {
@@ -586,8 +609,8 @@ TModel.prototype.getTargetStep = function(key)  {
     return this.targetValues[key] ? this.targetValues[key].step : 0;
 };
 
-TModel.prototype.getActualTimeStamp = function(key)  {
-    return this.targetValues[key] ? this.targetValues[key].actualTimeStamp : undefined;
+TModel.prototype.getScheduleTimeStamp = function(key)  {
+    return this.targetValues[key] ? this.targetValues[key].scheduleTimeStamp : undefined;
 };
 
 TModel.prototype.getLastActualValue = function(key)  {
@@ -619,9 +642,9 @@ TModel.prototype.setTargetCycle = function(key, value)   {
     }
 };
 
-TModel.prototype.setActualTimeStamp = function(key, value)   {
+TModel.prototype.setScheduleTimeStamp = function(key, value)   {
     if (this.targetValues[key]) {
-        this.targetValues[key].actualTimeStamp = value;
+        this.targetValues[key].scheduleTimeStamp = value;
     }
 };
 
@@ -660,53 +683,45 @@ TModel.prototype.resetCallingTargetKey = function(key)   {
 };
 
 TModel.prototype.setTargetValue = function(key, value, steps, stepInterval, cycles, callingTargetKey) {
-    if (!TUtil.isDefined(this.targetValues[key]) || value !== this.targetValues[key].value || value !== this.actualValues[key] || steps || cycles || stepInterval || typeof this.targets[key] === 'object')   {
                     
-        steps = steps || 0;
-        cycles = cycles || 0;
-        stepInterval = stepInterval || 0;
-        
-        if (this.targetValues[key]) {    
-            if (key !== callingTargetKey && (this.targetValues[key].callingTargetKey !== callingTargetKey || value !== this.targetValues[key].value)) {
-                this.targetValues[key].step = 0;
-            }            
-            this.targetValues[key].value = value;
-            this.targetValues[key].steps = steps;
-            this.targetValues[key].cycles = cycles;
-            this.targetValues[key].stepInterval = stepInterval;
-            this.targetValues[key].callingTargetKey = callingTargetKey;
-        } else { 
-            this.targetValues[key] = Object.assign(TargetUtil.emptyValue(), {
-                value: value,  
-                steps: steps, 
-                cycles: cycles, 
-                stepInterval: stepInterval, 
-                callingTargetKey: callingTargetKey
-            });
-            TargetUtil.extractInvisibles(this, this.targets[key], key);            
-        }
-        
-        //take a shortcut and update the actualValues immediately without the need for TargetManager
-        if (steps === 0 && cycles === 0) {
-            var oldValue = this.actualValues[key];
-            this.actualValues[key] = typeof value === 'function' ? value.call(this) : value;            
-            this.setActualValueLastUpdate(key);
-            TargetUtil.handleValueChange(this, key, this.actualValues[key], oldValue, 0, 0);             
-        }
-        
-        this.updateTargetStatus(key);
-        
-        if (this.isTargetUpdating(key) && key !== callingTargetKey) {              
-            this.activeTargetKeyMap[key] = true;
-            if (!this.targetUpdatingMap[key]) {
-                this.targetUpdatingList.push(key);
-                this.targetUpdatingMap[key] = key;
-            }
+    steps = steps || 0;
+    cycles = cycles || 0;
+    stepInterval = stepInterval || 0;
+
+    if (this.targetValues[key]) {    
+        if (key !== callingTargetKey && (this.targetValues[key].callingTargetKey !== callingTargetKey || value !== this.targetValues[key].value)) {
+            this.resetTargetStep(key);
             this.resetLastActualValue(key);
-        }
-          
-        tapp.manager.scheduleRun(10, 'setTargetValue-' + (this.getParent() ? this.getParent().oid : "") + "-" + this.oid + "-" + key);
+        }  
+        
+        this.targetValues[key].value = value;
+        this.targetValues[key].steps = steps;
+        this.targetValues[key].cycles = cycles;
+        this.targetValues[key].stepInterval = stepInterval;
+        this.targetValues[key].callingTargetKey = callingTargetKey;
+    } else { 
+        this.targetValues[key] = Object.assign(TargetUtil.emptyValue(), {
+            value: value,  
+            steps: steps, 
+            cycles: cycles, 
+            stepInterval: stepInterval, 
+            callingTargetKey: callingTargetKey
+        });
+        TargetUtil.extractInvisibles(this, this.targets[key], key);            
+    }
+
+    //take a shortcut and update the actualValues immediately without the need for TargetManager
+    if (steps === 0 && cycles === 0) {
+        var oldValue = this.actualValues[key];
+        this.actualValues[key] = typeof value === 'function' ? value.call(this) : value;            
+        this.setActualValueLastUpdate(key);
+        TargetUtil.handleValueChange(this, key, this.actualValues[key], oldValue, 0, 0); 
     }
+    
+    this.activeTargetKeyMap[key] = true;
+    this.targetValues[key].executionCount++; 
+
+    this.updateTargetStatus(key);
 };
 
 TModel.prototype.setValue = function(key, value) {

package/src/TModelManager.js

@@ -321,6 +321,15 @@ TModelManager.prototype.run = function(oid, delay) {
                     tapp.locationManager.calculateTargets(tapp.ui);
 
                     tapp.locationManager.calculateAll();
+                    
+                    if (tapp.targetManager.doneTargets.length > 0) {
+                        tapp.targetManager.doneTargets.forEach(function(target) {
+                            //imperative call is possible till this gets executed so we need to make sure that it is still done
+                            if (target.tmodel.isTargetDone(target.key)) {
+                                target.tmodel.setTargetComplete(target.key);
+                            }
+                        });
+                    }                    
 
                     tapp.events.resetEvents();
 

package/src/TUtil.js

@@ -57,11 +57,9 @@ TUtil.areEqual = function(a, b, deepEquality) {
 
     if (deepEquality) {        
         return JSON.stringify(a) === JSON.stringify(b);     
-    } else if (TUtil.isDefined(a) && TUtil.isDefined(b)) {
-        return a === b;
     } else {
-        return false;
-    }
+        return a === b;
+    } 
 };
 
 TUtil.momentum = function (past, current, time) {
@@ -103,7 +101,7 @@ TUtil.getOptionValue = function(option, defaultValue, tmodel)    {
     return !TUtil.isDefined(option) ? defaultValue : typeof option === 'function' ? option.call(tmodel) : option;
 };
 
-TUtil.executeFunctionByName = function (functionName, context /*, args */) {
+TUtil.executeFunctionByName = function (functionName, context) {
     if (!functionName)
         return null;
 

package/src/TargetManager.js

@@ -7,54 +7,42 @@ function TargetManager() {
     this.doneTargets = [];
 }
 
-TargetManager.prototype.setTargetValuesWithKeys = function(tmodel, keys, force) {
-    for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        if (tmodel.targetValues[key] && tmodel.getCallingTargetKey(key) === key) {
-            this.setTargetValue(tmodel, key, force);
-        }
-    }
-};
+TargetManager.prototype.setTargetValues = function(tmodel, activeKeys) {
+        tmodel.targetUpdatingMap = {};
+        tmodel.targetUpdatingList = [];
+        tmodel.targetMethodMap = {};
 
-TargetManager.prototype.setTargetValues = function(tmodel) {
-         
-    var activeKeys = Object.keys(tmodel.activeTargetKeyMap);
-    
-    if (tmodel.targets !== tmodel.actualValues.targets) {
-        tmodel.actualValues.targets =  tmodel.targets;
-        Object.keys(tmodel.targets).forEach(function(key) {
-            if (activeKeys.indexOf(key) === -1) {
-                activeKeys.push(key);
-            }
-        });
-    }
-                    
-    tmodel.targetUpdatingMap = {};
-    tmodel.targetUpdatingList = [];
-    tmodel.targetMethodMap = {};
-                    
     for (var i = 0; i < activeKeys.length; i++) {
-       
         var key = activeKeys[i];
-                                
+                                  
         if (tmodel.targetUpdatingMap[key]) {            
             continue;
-        }   
+        } 
         
-        if (tmodel.isTargetUpdating(key) && tmodel.getCallingTargetKey(key) !== key) {  
-            tmodel.targetUpdatingMap[key] = true;
-            tmodel.targetUpdatingList.push(key); 
-            continue;
+        if (tmodel.isTargetImperative(key)) {
+            tmodel.setTargetMethodName(key, 'value');
+            
+            if (tmodel.isTargetUpdating(key)) {
+                tmodel.targetUpdatingMap[key] = true;
+                tmodel.targetUpdatingList.push(key);
+                continue;
+            }
         }
         
-        var result = this.setTargetValue(tmodel, key);
-        
-        if (result) {
-            tmodel.targetUpdatingMap[key] = true;
-            tmodel.targetUpdatingList.push(key);  
-        } else if (tmodel.isTargetDone(key)) {
+        if (tmodel.isTargetDone(key)) {
             this.doneTargets.push({ tmodel: tmodel, key: key });
+        } else if (tmodel.isTargetComplete(key)) {
+            delete tmodel.activeTargetKeyMap[key];
+        } else {
+            this.setTargetValue(tmodel, key);
+            tmodel.updateTargetStatus(key);
+
+            if (tmodel.isTargetUpdating(key)) {
+                tmodel.targetUpdatingMap[key] = true;
+                tmodel.targetUpdatingList.push(key);
+            }
         }
+       
     }
 
     if (tmodel.getParent() && tmodel.targetUpdatingList.length === 0) {
@@ -62,7 +50,7 @@ TargetManager.prototype.setTargetValues = function(tmodel) {
     }
 };
 
-TargetManager.prototype.setTargetValue = function(tmodel, key, force) {
+TargetManager.prototype.setTargetValue = function(tmodel, key) {
     var target = tmodel.targets[key];
     
     if (!TUtil.isDefined(target)) {
@@ -70,76 +58,38 @@ TargetManager.prototype.setTargetValue = function(tmodel, key, force) {
         return;
     }
 
-    if (tmodel.isTargetUpdating(key) || !tmodel.targetValues[key] || tmodel.isTargetInLoop(key) || !tmodel.hasTargetGotExecuted(key) || force) {
-
-        if (tmodel.isTargetEnabled(key)) {
-
-            var valueOnly = target ? !!target.valueOnly : false;
-
-            if (!TUtil.isDefined(tmodel.getActualTimeStamp(key))) {
-                var cycle = tmodel.getTargetCycle(key);
-                var valueArray = TargetUtil.getValueStepsCycles(tmodel, target, cycle, valueOnly, key);               
-                TargetUtil.assignValueArray(tmodel, key, valueArray);
-                 
-                if (!force) {
-                    tmodel.setTargetMethodName(key, 'value');
-                }
-            }
-            
-            if (tmodel.isTargetInLoop(key) 
-                    || (!tmodel.isTargetDone(key) && !tmodel.isTargetComplete(key))
-                    || TUtil.isDefined(tmodel.getActualTimeStamp(key))
-                    || !tmodel.hasTargetGotExecuted(key)) {
-                tmodel.activeTargetKeyMap[key] = true;
-            } else if (tmodel.activeTargetKeyMap[key]) { 
-                delete tmodel.activeTargetKeyMap[key];
-            }
-            
-            if (TUtil.isDefined(tmodel.getActualTimeStamp(key))) {
-                var schedulePeriod = TargetUtil.getActualSchedulePeriod(tmodel, key, tmodel.getTargetStepInterval(key)); 
-                if (schedulePeriod > 0) {
-                    tapp.manager.scheduleRun(schedulePeriod, "actualInterval__" + tmodel.oid + "__" + key); 
-                }
-            }
-            
-            return (!tmodel.isTargetDone(key) && !tmodel.isTargetComplete(key)) || !tmodel.doesTargetEqualActual(key);
-        } else {
-            tmodel.setTargetMethodName(key, 'enabledOn');
-            tmodel.activeTargetKeyMap[key] = true;
+    if (tmodel.isTargetEnabled(key)) {
+        if (tmodel.getScheduleTimeStamp(key) && tmodel.isTargetActive(key) && tmodel.getTargetStepInterval(key) > 0
+                && tmodel.getScheduleTimeStamp(key) + tmodel.getTargetStepInterval(key) <= TargetJ.browser.now()) {
+            tmodel.resetScheduleTimeStamp(key);
         }
-    } else if (tmodel.activeTargetKeyMap[key]) {
-        delete tmodel.activeTargetKeyMap[key];
-    }
-    
-};
-
-TargetManager.prototype.setActualValues = function(tmodel)  { 
-    var i;
-    var target;
-    var key, keys = [];
-                                
-    for (i = 0; i < tmodel.targetUpdatingList.length; i++) {
-        key = tmodel.targetUpdatingList[i];
-
-        target = tmodel.targets[key];
-        var status = tmodel.getTargetStatus(key);
-               
-        if (tmodel.isTargetUpdating(key)) {
-            keys.push(key);
+        
+        if (!TUtil.isDefined(tmodel.getScheduleTimeStamp(key))) {
+            TargetUtil.assignValueArray(tmodel, key); 
+            tmodel.setTargetMethodName(key, 'value');
         }
         
-        if (status !== tmodel.getTargetStatus(key)) {
-            tapp.manager.scheduleRun(1, tmodel.oid + "-" + key + '-statusChange');            
+        var schedulePeriod = TargetUtil.scheduleExecution(tmodel, key);
+        if (schedulePeriod > 0) {
+            tapp.manager.scheduleRun(schedulePeriod, "actualInterval__" + tmodel.oid + "__" + key); 
         }
+    } else {
+        tmodel.setTargetMethodName(key, 'enabledOn');
     }
-             
-    for (i = 0; i < keys.length; i++) {
-        key = keys[i];
+};
+
+TargetManager.prototype.setActualValues = function(tmodel, keyList)  { 
+    var i, key; 
+    keyList = !keyList ? tmodel.targetUpdatingList : keyList;
+    var length = keyList.length;
+    
+    for (i = 0; i < length; i++) {
+        key = keyList[i];
          
-        var schedulePeriod = TargetUtil.getActualSchedulePeriod(tmodel, key, tmodel.getTargetStepInterval(key));
-        if (schedulePeriod === 0 || !TUtil.isDefined(schedulePeriod)) {
+        var schedulePeriod = TargetUtil.scheduleExecution(tmodel, key);
+        if (schedulePeriod === 0) {
             this.setActualValue(tmodel, key);            
-        } else {            
+        } else { 
             tapp.manager.scheduleRun(schedulePeriod, "actualInterval__" + tmodel.oid + "__" + key);  
         }
     }
@@ -148,9 +98,7 @@ TargetManager.prototype.setActualValues = function(tmodel)  {
 
 TargetManager.prototype.setJustActualValue = function(tmodel, key)  {
     
-     var target = tmodel.targets[key];
-
-    if (!tmodel.targetValues[key] || (target && typeof target.enabledOn === 'function' && !target.enabledOn.call(tmodel, key))) {
+    if (!tmodel.targetUpdatingList[key]) {
         return false;
     }
     
@@ -181,30 +129,18 @@ TargetManager.prototype.setActualValue = function(tmodel, key) {
     var easing = TUtil.isDefined(tmodel.getTargetEasing(key)) ? tmodel.getTargetEasing(key) : EasingEffects.linear;
     var cycle = tmodel.getTargetCycle(key);
     var easingStep = easing(tmodel.getTargetStepPercent(key, step)); 
-    var cycleUpdate = false;
-    var stepInterval = tmodel.getTargetStepInterval(key);  
-    var lastUpdate = tmodel.getActualValueLastUpdate(key);
+    var stepInterval = tmodel.getTargetStepInterval(key) || 0;  
     var oldValue = tmodel.actualValues[key], oldStep = step, oldCycle = cycle;
-    var now = browser.now();
-   
-    tmodel.setTargetMethodName(key, 'value');
-       
+          
     if (step < steps) { 
         if (!TUtil.isDefined(tmodel.getLastActualValue(key))) {
             tmodel.setLastActualValue(key, tmodel.actualValues[key]);
         }
         tmodel.actualValues[key] = typeof targetValue  === 'number' ? targetValue * easingStep + tmodel.getLastActualValue(key) * (1 - easingStep) : targetValue;
        
-        tmodel.setActualValueLastUpdate(key);
         tmodel.setActualValueLastUpdate(key);
         
-        var stepIncrease = 1;
-        if (!TUtil.isDefined(stepInterval) && false) {
-            var expectedStepInterval = 10;
-            stepIncrease = step > 0 && lastUpdate && tapp.throttle === 0 && expectedStepInterval > 0 ? Math.max(1, Math.floor((now - lastUpdate) / expectedStepInterval)) : 1;
-        }
-                 
-        step = tmodel.setTargetStep(key, step + stepIncrease);         
+        step = tmodel.setTargetStep(key, step + 1);         
     } 
 
     if (step >= steps) {        
@@ -216,27 +152,20 @@ TargetManager.prototype.setActualValue = function(tmodel, key) {
             tmodel.setTargetMethodName(key, 'onStepsEnd');
         }
         
-        tmodel.updateTargetStatus(key);        
-
         if (tmodel.getTargetCycle(key) < tmodel.getTargetCycles(key)) {
             tmodel.setTargetCycle(key, tmodel.getTargetCycle(key) + 1);
 
-            cycleUpdate = true;
             tmodel.resetTargetStep(key);
             tmodel.resetLastActualValue(key);
-        }
-                
+        }        
     }
     
     TargetUtil.handleValueChange(tmodel, key, tmodel.actualValues[key], oldValue, oldStep, oldCycle);
 
-    if (TUtil.isDefined(tmodel.getActualTimeStamp(key)))  {
-        tmodel.resetActualTimeStamp(key); 
-    }
-       
-    if (step < steps || cycleUpdate) {
-        tapp.manager.scheduleRun(step < steps ? stepInterval : 0, tmodel.oid + "---" + key + "-" + step + "/" + steps + "-" + cycle + "-" + stepInterval);
-    }            
+    tmodel.resetScheduleTimeStamp(key);
+    tmodel.updateTargetStatus(key);
+
+    tapp.manager.scheduleRun(stepInterval, tmodel.oid + "---" + key + "-" + step + "/" + steps + "-" + cycle + "-" + stepInterval);      
 };
 
 export { TargetManager };

package/src/TargetUtil.js

@@ -26,23 +26,28 @@ TargetUtil.emptyValue = function() {
         cycles: 0, 
         stepInterval: 0, 
         lastActualValue: undefined,
-        actualTimeStamp: undefined,
+        scheduleTimeStamp: undefined,
         actualValueLastUpdate: 0,
         status: '',
-        executionCounter: 0,
+        executionCount: 0,
         callingTargetKey: undefined
     };
 };
 
-TargetUtil.getValueStepsCycles = function(tmodel, _target, cycle, valueOnly, key) {
+TargetUtil.getValueStepsCycles = function(tmodel, key) {
+    var _target = tmodel.targets[key];
+    var valueOnly = _target && _target.valueOnly ? true : false;
+    var cycle = tmodel.getTargetCycle(key);
     var value = 0, steps = 0, stepInterval = 0, cycles = 0;
     var lastValue = tmodel.getValue(key);
     
     function getValue(target) {             
         if (Array.isArray(target)) {                      
-            if (!target.valueOnly) {
-                if (typeof target[0] === 'function')    {
-                  value = target[0].call(tmodel, key, cycle, lastValue);
+            if (valueOnly) {
+                return [target, steps, stepInterval, cycles];
+            } else {
+                if (typeof target[0] === 'function') {
+                    value = target[0].call(tmodel, key, cycle, lastValue);
                 } else {
                     value = target[0];
                 }
@@ -51,17 +56,15 @@ TargetUtil.getValueStepsCycles = function(tmodel, _target, cycle, valueOnly, key
                 cycles = target.length >= 4 ? target[3] : cycles;
 
                 return [value, steps, stepInterval, cycles];
-            } else {
-                return [target, steps, stepInterval, cycles];
             }
                 
-        } else if (typeof target === 'object' && target && !(target instanceof TModel)) {
+        } else if (typeof target === 'object' && target) {
             value = typeof target.value === 'function' ? target.value.call(tmodel, key, cycle, lastValue) : TUtil.isDefined(target.value) ? target.value : target;
             steps = typeof target.steps === 'function' ? target.steps.call(tmodel, key, cycle) : TUtil.isDefined(target.steps) ? target.steps : 0;
             stepInterval = typeof target.stepInterval === 'function' ? target.stepInterval.call(tmodel, key, cycle, tmodel.getTargetStepInterval(key)) : TUtil.isDefined(target.stepInterval) ? target.stepInterval : 0;            
             cycles = typeof target.cycles === 'function' ? target.cycles.call(tmodel, key, cycle, tmodel.getTargetCycles(key)) : TUtil.isDefined(target.cycles) ? target.cycles : 0;
 
-            if (Array.isArray(value) && valueOnly === false && !value.valueOnly) {
+            if (Array.isArray(value) && valueOnly === false) {
                 return getValue(value);
             } else {
                 return [value, steps, stepInterval, cycles];
@@ -88,8 +91,9 @@ TargetUtil.getValueStepsCycles = function(tmodel, _target, cycle, valueOnly, key
     return valueArray;
 };
 
-TargetUtil.assignValueArray = function(tmodel, key, valueArray) {
-    
+TargetUtil.assignValueArray = function(tmodel, key) {
+    var valueArray = TargetUtil.getValueStepsCycles(tmodel, key);               
+
     if (Array.isArray(valueArray)) {
         var newValue = valueArray[0];
         var newSteps = valueArray[1];
@@ -97,23 +101,22 @@ TargetUtil.assignValueArray = function(tmodel, key, valueArray) {
         var newCycles = valueArray[3];
         var target = tmodel.targets[key];
                
-        var cycle = tmodel.getTargetCycle(key);
         var targetValue = tmodel.targetValues[key];        
         var theValue = targetValue ? targetValue.value : undefined;
-        var newValueFlag = !TUtil.areEqual(theValue, newValue, target.deepEquality) 
+        var newValueFlag = !TUtil.areEqual(theValue, newValue, tmodel.targets[key] ? !!tmodel.targets[key].deepEquality : false) 
                 || !TUtil.isDefined(targetValue)
                 || (!tmodel.isTargetUpdating(key) && !tmodel.doesTargetEqualActual(key));
                 
         if (newValueFlag || targetValue.steps !== newSteps || targetValue.cycles !== newCycles || targetValue.stepInterval !== newStepInterval) {
                      
             tmodel.setTargetValue(key, newValue, newSteps, newStepInterval, newCycles, key);
-            tmodel.targetValues[key].executionCounter++;
-            
+   
             if (newValueFlag) {
                 tmodel.resetTargetStep(key);
-               
                 tmodel.resetLastActualValue(key);
             }
+        } else {
+            tmodel.targetValues[key].executionCount++; 
         }
     }
 };
@@ -124,31 +127,27 @@ TargetUtil.getIntervalValue = function(tmodel, key, interval) {
     return TUtil.isNumber(intervalValue) ? intervalValue : 0;
 };
 
-TargetUtil.getActualSchedulePeriod = function(tmodel, key, intervalValue) {   
+TargetUtil.scheduleExecution = function(tmodel, key) {   
     
-    var now = browser.now();
-    var pastPeriod;
     var schedulePeriod = 0;
+    var intervalValue = tmodel.getTargetStepInterval(key);
+    var now = browser.now();
     
     if (intervalValue > 0) {
-        if (TUtil.isDefined(tmodel.getActualTimeStamp(key))) {
-            pastPeriod = now - tmodel.getActualTimeStamp(key);
-            if (pastPeriod < intervalValue) {
-                schedulePeriod = intervalValue - pastPeriod;
+        if (TUtil.isDefined(tmodel.getScheduleTimeStamp(key))) {
+            var period = now - tmodel.getScheduleTimeStamp(key);
+            if (period < intervalValue) {
+                schedulePeriod = intervalValue - period;
             } else {
                 schedulePeriod = 0;
             }
         } else {
-            tmodel.setActualTimeStamp(key, now);
             schedulePeriod = intervalValue;
         }
-    } else if (TUtil.isDefined(tmodel.getActualTimeStamp(key))) {
-        pastPeriod = now - tmodel.getActualTimeStamp(key);
-        if (pastPeriod < 0) {
-            schedulePeriod = -pastPeriod;
-        } else {
-            schedulePeriod = 0;
-        }
+    }
+    
+    if (schedulePeriod > 0 && !TUtil.isDefined(tmodel.getScheduleTimeStamp(key))) {
+        tmodel.setScheduleTimeStamp(key, now);       
     }
 
     return schedulePeriod;
@@ -187,6 +186,7 @@ TargetUtil.getTargetSchedulePeriod = function(tmodel, key, intervalValue) {
 
 TargetUtil.handleValueChange = function(tmodel, key, newValue, lastValue, step, cycle) {
     if (typeof tmodel.targets[key] === 'object' && typeof tmodel.targets[key].onValueChange === 'function') {
+        
         var valueChanged = !TUtil.areEqual(newValue, lastValue, tmodel.targets[key].deepEquality);
         if (valueChanged) {
             tmodel.targets[key].onValueChange.call(tmodel, key, newValue, lastValue, cycle);