targetj 1.0.2

package/src/LoadingManager.js

@@ -0,0 +1,348 @@
+function LoadingManager() {
+    
+    this.resultMap = {};
+    this.loadingMap = {};
+    
+    this.singleLoadList = undefined;
+    this.groupLoadList = undefined;
+    this.imgLoadList = undefined;
+    
+    this.stopLoadingAfterAttempts = TUtil.isDefined(tapp.stopLoadingAfterAttempts) ? tapp.stopLoadingAfterAttempts : 10;
+    this.attemptFailedInterval = TUtil.isDefined(tapp.attemptFailedInterval) ? tapp.attemptFailedInterval : 2000;
+    
+    this.statistics = {};
+}
+
+LoadingManager.prototype.initSingleLoad = function (fetchId, query, forceLoad)  {
+    
+    if (this.isLoading(fetchId) || (this.isLoaded(fetchId) && !forceLoad) || this.getLoadingAttempts(fetchId) > this.stopLoadingAfterAttempts) return;
+
+    this.initLoadingMap(fetchId);
+     
+    this.singleLoadList = this.singleLoadList ? this.singleLoadList : {};
+    this.singleLoadList[fetchId] = { fetchId: fetchId, query: query };
+};
+
+LoadingManager.prototype.initGroupLoad = function (fetchId, dataId, query, idKey, separator)  {
+    var groupId = JSON.stringify({ query: query, idKey: idKey, separator: separator });
+               
+    if (this.isLoading(fetchId) || this.isLoaded(fetchId) || this.getLoadingAttempts(fetchId) > this.stopLoadingAfterAttempts) return;
+    
+    this.initLoadingMap(fetchId);
+        
+    this.groupLoadList = this.groupLoadList ? this.groupLoadList : {};
+    if (!this.groupLoadList[groupId]) {
+        this.groupLoadList[groupId] = [];
+    }
+       
+    this.groupLoadList[groupId].push({ fetchId: fetchId, dataId: dataId });
+};
+
+LoadingManager.prototype.initImgLoad = function (fetchId, src) {
+    
+    if (this.isLoading(fetchId) || this.isLoaded(fetchId) || this.getLoadingAttempts(fetchId) > this.stopLoadingAfterAttempts) return;
+    
+    this.initLoadingMap(fetchId, 'image');
+    
+    this.imgLoadList = this.imgLoadList ? this.imgLoadList : {};
+    this.imgLoadList[fetchId] = { fetchId: fetchId, src: src };
+};
+
+LoadingManager.prototype.isLoading = function(fetchId) {
+    return TUtil.isDefined(this.loadingMap[fetchId]) ? this.loadingMap[fetchId].loadingFlag : false;
+};
+
+LoadingManager.prototype.isLoaded = function(fetchId) {
+    return TUtil.isDefined(this.resultMap[fetchId]) && this.resultMap[fetchId].success === true;
+};
+
+LoadingManager.prototype.getLoadingAttempts = function(fetchId) {
+    return TUtil.isDefined(this.loadingMap[fetchId]) ? this.loadingMap[fetchId].attempts : 0;
+};
+
+LoadingManager.prototype.getSuccessLoadingTime = function(fetchId) {
+    return TUtil.isDefined(this.loadingMap[fetchId]) &&  this.loadingMap[fetchId].success === true ? this.loadingMap[fetchId].loadingTime : undefined;
+};
+
+LoadingManager.prototype.getFailedInterval = function(fetchId) {
+    return TUtil.isDefined(this.loadingMap[fetchId]) ? this.loadingMap[fetchId].attempts * this.attemptFailedInterval : 0;
+};
+
+LoadingManager.prototype.fetchResult = function(fetchId) {
+    return this.resultMap[fetchId];
+};
+
+LoadingManager.prototype.hasLoadedSuccessfully = function(fetchId) {
+    return this.resultMap[fetchId] && this.resultMap[fetchId].success === true;
+};
+
+LoadingManager.prototype.hasLoadedUnsuccessfully = function(fetchId) {
+    return this.resultMap[fetchId] && this.resultMap[fetchId].success === false;
+};
+
+LoadingManager.prototype.fetchErrors = function(fetchId) {
+    return this.resultMap[fetchId] && this.resultMap[fetchId].result && this.resultMap[fetchId].result.errors ? this.resultMap[fetchId].result.errors : undefined;
+};
+LoadingManager.prototype.initLoadingMap = function(fetchId, category) {
+    category = category ? category : this.getCategoryFromFetchId(fetchId);
+    
+    if (TUtil.isDefined(this.loadingMap[fetchId])) {
+        this.loadingMap[fetchId].loadingFlag = true;
+        this.loadingMap[fetchId].startTime = browser.now();
+        this.loadingMap[fetchId].loadingTime = undefined;
+        
+    } else {
+        this.loadingMap[fetchId] = { 
+            fetchId: fetchId, 
+            category: category, 
+            loadingFlag: true, 
+            attempts: 0, 
+            startTime: browser.now(), 
+            loadingTime: undefined, 
+            success: false 
+        };
+    }
+};
+
+LoadingManager.prototype.groupLoad = function () {
+    if (!this.groupLoadList) return;
+    
+    var groupIds = Object.keys(this.groupLoadList);
+    
+    for (var i = 0; i < groupIds.length; i++) {
+        var groupId = groupIds[i];        
+        var fetchList = this.groupLoadList[groupId];
+                                        
+        var dataIds = [], dataIdFetchIdMap = {};
+        
+        for (var j = 0; j < fetchList.length; j++) {
+            var dataId = fetchList[j].dataId;
+            dataIds.push(dataId);
+            dataIdFetchIdMap[dataId] = fetchList[j].fetchId;
+        }
+                
+        if (dataIds.length > 0)  {
+            var groupObj = JSON.parse(groupId);
+            var groupQuery = this.updateQueryValue(groupObj.query, dataIds.join(groupObj.separator));
+            this.groupAjax(groupQuery, dataIdFetchIdMap, groupObj.idKey);
+        }
+        
+        delete this.groupLoadList[groupId];
+    }
+    
+    this.groupLoadList = undefined;
+    
+};
+
+LoadingManager.prototype.singleLoad = function () {
+    if (!this.singleLoadList) return;
+    
+    var keys = Object.keys(this.singleLoadList);
+        
+    for (var i = 0; i < keys.length; i++) {        
+        var load = this.singleLoadList[keys[i]];
+               
+        this.singleAjax(load.query, load.fetchId);
+    }
+    
+    this.singleLoadList = undefined;
+};
+
+LoadingManager.prototype.imgLoad = function () {  
+    if (!this.imgLoadList) return;
+
+    var keys = Object.keys(this.imgLoadList);
+        
+    for (var i = 0; i < keys.length; i++) {   
+        var load = this.imgLoadList[keys[i]];
+               
+        this.imgAjax(load.src, load.fetchId);
+    }
+    
+    this.imgLoadList = undefined;
+};
+
+LoadingManager.prototype.updateQueryValue = function(query, value) {
+    for (var prop in query) {
+        if (query[prop] === '%s') {
+            query[prop] = value;
+        } else if (query[prop] === '%d') {
+            query[prop] = typeof value === 'number' ? value : parseFloat(value);
+        } else if (typeof query[prop] === 'object') {
+            this.updateQueryValue(query[prop], value);
+        }   
+    }
+    return query;
+};
+
+LoadingManager.prototype.singleAjax = function (query, fetchId) {
+    var self = this;
+            
+    var defaultQuery = { 
+        dataType: "json", 
+        type: "GET",
+        success: function (dataList) {
+            self.loadingMap[fetchId].loadingFlag = false;
+            self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+            self.loadingMap[fetchId].success = true;            
+            self.loadingMap[fetchId].attempts++;
+             
+            self.resultMap[fetchId] = Object.assign({ result: dataList }, self.loadingMap[fetchId] );
+            delete self.loadingMap[fetchId];
+            
+            self.updateStatistics(fetchId);
+                        
+            tapp.manager.scheduleRun(0, "singleAjax_success_" +  fetchId);
+        }, 
+        error: function (textStatus) {             
+            self.resultMap[fetchId] = { error: textStatus, success: false };
+            
+            self.loadingMap[fetchId].loadingFlag = false;
+            self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+            self.loadingMap[fetchId].attempts++;
+            
+            tapp.manager.scheduleRun(0, "singleAjax_error_" +  fetchId);
+        }
+    };
+
+    $Dom.ajax(Object.assign(defaultQuery, query)); 
+};
+
+LoadingManager.prototype.groupAjax = function (query, dataIdFetchIdMap, idKey) {
+    
+    var self = this;
+        
+    var defaultQuery = {
+         dataType: "json", 
+         type: "GET",
+         success: function (dataList) {
+            for (var i = 0; i < dataList.length; i++) {
+                
+                var dataId = dataList[i][idKey];
+                if (dataIdFetchIdMap[dataId]) {
+                    var fetchId = dataIdFetchIdMap[dataId];        
+                    self.loadingMap[fetchId].loadingFlag = false;
+                    self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+                    self.loadingMap[fetchId].success = true;                                
+                    self.loadingMap[fetchId].attempts++;
+                    
+                    self.resultMap[fetchId] = Object.assign({ result: dataList[i] }, self.loadingMap[fetchId] );
+                    
+                    self.updateStatistics(fetchId);
+                    
+                    delete self.loadingMap[fetchId];
+                    delete dataIdFetchIdMap[dataId];
+                }
+            }
+            
+            Object.keys(dataIdFetchIdMap).forEach(function(dataId) {
+                
+                var fetchId = dataIdFetchIdMap[dataId];
+                
+                if (!self.loadingMap[fetchId].success) {
+                    self.loadingMap[fetchId].loadingFlag = false;
+                    self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+                    self.loadingMap[fetchId].attempts++;
+                }
+            }); 
+                        
+            tapp.manager.scheduleRun(0, "groupAjax_success_" +  query);
+        }, 
+        error: function (textStatus) {
+            Object.keys(dataIdFetchIdMap).forEach(function(dataId) {
+                var fetchId =dataIdFetchIdMap[dataId];
+                                
+                self.resultMap[fetchId] = { error: textStatus, success: false };
+                self.loadingMap[fetchId].loadingFlag = false;
+                self.loadingMap[fetchId].attempts++;                 
+            });
+                        
+            tapp.manager.scheduleRun(0, "groupAjax_error_" +  query);
+        }
+    };
+
+    $Dom.ajax(Object.assign(defaultQuery, query)); 
+};
+
+LoadingManager.prototype.imgAjax = function (src, fetchId) {
+    var self = this;
+                
+    var image = new Image();
+    image.src = src;
+       
+    image.onload = function() {
+            self.loadingMap[fetchId].loadingFlag = false;
+            self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+            self.loadingMap[fetchId].success = true;            
+            self.loadingMap[fetchId].attempts++;
+                         
+            self.resultMap[fetchId] = Object.assign({ width: this.width, height: this.height, $image: new $Dom(image) }, self.loadingMap[fetchId]);
+            
+            self.updateStatistics(fetchId, 'image');
+            delete self.loadingMap[fetchId];
+                        
+            tapp.manager.scheduleRun(0, "imgAjax_success_" +  fetchId);
+    };
+            
+    image.onerror = image.onabort =  function () {
+        self.resultMap[fetchId] = { result: "no image", success: false };
+            
+        self.loadingMap[fetchId].loadingFlag = false;
+        self.loadingMap[fetchId].loadingTime = browser.now() - self.loadingMap[fetchId].startTime;
+        self.loadingMap[fetchId].attempts++;
+
+
+        tapp.manager.scheduleRun(0, "imgAjax_error_" +  fetchId); 
+    };
+       
+};
+
+LoadingManager.prototype.getCategoryFromFetchId = function(fetchId) {
+    return fetchId.replace(/[^a-zA-Z]/g, '');
+};
+
+LoadingManager.prototype.updateStatistics = function(fetchId, category) {
+    category = category ? category : this.getCategoryFromFetchId(fetchId);
+
+    if (this.statistics[category]) {
+        this.statistics[category].count++;
+        this.statistics[category].totalTime += this.resultMap[fetchId].loadingTime;
+        this.statistics[category].lastUpdate = browser.now();
+        delete this.statistics[category].averageTime;
+    } else {
+       this.statistics[category] = {
+           count: 1,
+           totalTime: this.resultMap[fetchId].loadingTime,
+           lastUpdate: browser.now()
+       };
+    }
+};
+
+LoadingManager.prototype.getAverageLoadingTime = function(category) {
+    var now = browser.now();
+    
+    if (this.statistics[category] && this.statistics[category].averageTime && (now - this.statistics[category].lastUpdate) < 500) {
+        return this.statistics[category].averageTime;
+    }
+
+    var totalTime = this.statistics[category] ? this.statistics[category].totalTime : 0;
+    var count = this.statistics[category] ? this.statistics[category].count : 0;
+    
+    
+    Object.values(this.loadingMap).filter(function(loadItem) { return loadItem.category === category; }).forEach(function(loadItem) {
+        totalTime += now - loadItem.startTime;
+        count++;
+    });
+    
+    if (this.statistics[category]) {
+
+        this.statistics[category].averageTime = count > 0 ? totalTime / count : 0;
+        this.statistics[category].lastUpdate = browser.now();
+
+        return this.statistics[category].averageTime;
+    } else {
+        return 0;
+    }
+};
+
+

package/src/LocationManager.js

@@ -0,0 +1,156 @@
+function LocationManager() {
+    this.hasLocationList = [];
+    this.hasLocationMap = {};
+
+    this.bracketThreshold = 4;
+    this.locationCount = [];
+}
+
+LocationManager.prototype.calculateAll = function() {
+    this.hasLocationList.length = 0;
+    this.hasLocationMap = {};
+    this.locationCount.length = 0;
+    tapp.targetManager.doneTargets.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");            
+    }
+};
+
+LocationManager.prototype.calculate = function() {                   
+    this.addToLocationList(tapp.ui);
+    this.calculateContainer(tapp.ui);
+};
+
+LocationManager.prototype.getChildren = function(container) {
+    var brackets;
+    
+    if (this.isProlificContainer(container)) {
+        brackets = Bracket.generate(container);
+    } 
+
+    return brackets ? brackets.list : container.getChildren(); 
+};
+
+LocationManager.prototype.isProlificContainer = function(container)   {
+    return container.canBeBracketed() && container.getChildren().length > this.bracketThreshold;
+};
+
+LocationManager.prototype.calculateContainer = function(container) {
+    var allChildren = this.getChildren(container);
+        
+    var viewport = container.createViewport();  
+    container.resetVisibleList();
+                   
+    var i = 0;
+        
+    while (i < allChildren.length && tapp.isRunning()) {
+        
+        var child = allChildren[i++];
+                        
+        var outerXEast = undefined, innerXEast = undefined;
+                
+        
+        this.calculateTargets(child);
+        
+        if (child.getActualValueLastUpdate('canBeBracketed') > child.getParent().getActualValueLastUpdate("allChildren")) {
+            delete child.getParent().targetValues['allChildren'];
+        }
+         
+        viewport.setCurrentChild(child);  
+        child.setLocation(viewport);
+
+        innerXEast = TUtil.isDefined(container.getValue('innerXEast')) ? container.getValue('innerXEast') : container.absX + container.getInnerWidth();
+        outerXEast = TUtil.isDefined(child.getValue('outerXEast')) ? child.getValue('outerXEast') : child.absX + child.getInnerWidth();
+        
+        if (viewport.isOverflow(outerXEast, innerXEast)) {   
+            viewport.overflow();                       
+            child.setLocation(viewport);
+        } else {            
+            child.setLocation(viewport);
+        }
+                 
+        if (child.canBeVisible() && !this.hasLocationMap[child.oid]) {    
+            this.addToLocationList(child);          
+        }
+
+        if (!child.targetUpdatingMap.x) {
+            if (TUtil.isDefined(child.targets.x)) {
+                tapp.targetManager.setTargetValue(child, 'x');
+            } else if (!TUtil.isDefined(child.targetValues.x)) {
+                child.setValue('x', child.x);                
+            }
+        }
+
+        if (!child.targetUpdatingMap.y) {
+            if (TUtil.isDefined(child.targets.y)) {
+                tapp.targetManager.setTargetValue(child, 'y');
+            } else if (!TUtil.isDefined(child.targetValues.y)) {
+                child.setValue('y', child.y);
+            }            
+        }
+
+        viewport.isVisible(child);
+                               
+        child.addToParentVisibleList();
+       
+        if (child.shouldCalculateChildrenLocations()) {
+            this.calculateContainer(child);  
+        } else  {
+            child.manuallyCalculateChildrenLocations();          
+        }
+        
+        if (child.isVisible() &&  child.canBeVisible() && (child.targetUpdatingList.length > 0 || child.updatingChildren.length > 0)) {
+            container.addUpdatingChild(child);
+        } 
+          
+        if (child.isInFlow()) {
+            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.getHeight() !== childLastHeight && tapp.events.isScrollTopHandler(child.getParent())
+                        && tapp.events.currentTouch.dir === 'up') {
+                this.calculateContainer(child); 
+            } 
+            
+            if (TUtil.isNumber(child.getValue('appendNewLine'))) {
+                viewport.appendNewLine();
+            } else {
+                viewport.nextLocation();
+            }
+        }
+        
+        this.locationCount.push(child.oid + "-" + child.targetUpdatingList.length + "-" + (browser.now() - this.startTime));
+
+    }
+
+    viewport.calcContentWidthHeight();
+};
+
+LocationManager.prototype.calculateTargets = function(tmodel) {           
+    tapp.targetManager.setTargetValues(tmodel);        
+    tapp.targetManager.setActualValues(tmodel);
+
+    if (!TUtil.isDefined(tmodel.targetValues.width) && tmodel.hasDom()) TargetUtil.setWidthFromDom(tmodel);
+    if (!TUtil.isDefined(tmodel.targetValues.height) && tmodel.hasDom()) TargetUtil.setHeightFromDom(tmodel);
+};
+
+LocationManager.prototype.addToLocationList = function(child)   {
+    this.hasLocationList.push(child);
+    this.hasLocationMap[child.oid] = child;
+};

package/src/PageManager.js

@@ -0,0 +1,104 @@
+function PageManager() {
+    this.lastLink = document.URL;
+    this.pageCache = {};
+}
+  
+PageManager.prototype.openPage = function(link, isPageFetchNeeded) {
+
+    isPageFetchNeeded = TUtil.isDefined(isPageFetchNeeded) ? isPageFetchNeeded : true;
+    
+    tapp.stop();
+    tapp.reset();
+       
+    var self = this;
+
+    if (typeof tapp.updateAnalytics === 'function') {
+        tapp.updateAnalytics(link);
+    }
+
+    if (!this.pageCache[link] && isPageFetchNeeded) {
+
+        $Dom.ajax({
+            url:link,
+            type: 'GET',
+            data: { tpageOnly: true }, 
+            success: function (data) {
+                tapp.$dom.outerHTML(data);                                
+                tapp.ui = tapp.uiFn();               
+                self.lastLink = link;
+                tapp.start();
+            },
+            error: function () {
+                self.lastLink = undefined;
+                history.back();
+            }
+        });
+
+    } else if (!this.pageCache[link]) {
+        tapp.$dom.innerHTML("");                                
+        tapp.ui = tapp.uiFn();
+        self.lastLink = link;        
+        setTimeout(tapp.start);  
+    } else {
+
+        tapp.$dom.innerHTML(this.pageCache[link].html);
+        tapp.ui = this.pageCache[link].ui;
+        TUtil.initDoms(this.pageCache[link].visibleList);
+        tapp.manager.lists.visible = this.pageCache[link].visibleList.slice(0);
+        self.lastLink = link;
+        setTimeout(tapp.start);  
+    }
+};
+
+PageManager.prototype.openLinkFromHistory = function(state) {    
+    if (state.link) {
+        this.openPage(state.link);
+    } else if (state.browserUrl) {  
+        history.replaceState({ link: state.browserUrl }, "", state.browserUrl);                
+        this.openPage(state.browserUrl);
+    }
+
+    tapp.manager.scheduleRun(0, "pagemanager-openLinkFromHistory");
+};
+
+PageManager.prototype.openLink = function(link, isPageFetchNeeded) {    
+    
+    link = TUtil.getFullLink(link);
+        
+    if (this.lastLink) {
+        this.pageCache[this.lastLink] = { 
+            link: this.lastLink, 
+            html: tapp.$dom.innerHTML(), 
+            visibleList: tapp.manager.lists.visible.slice(0),
+            ui: tapp.ui 
+        };
+    }
+    
+    history.pushState({ link: link }, "", link); 
+    
+    this.openPage(link, isPageFetchNeeded); 
+    
+    tapp.manager.scheduleRun(0, "pagemanager-processOpenLink");
+};
+
+PageManager.prototype.updateBrowserUrl = function(link) {    
+    var currentState = window.history.state;
+    
+    if (!currentState.browserUrl) {
+        this.pageCache[document.URL] = { 
+            link: document.URL, 
+            html: tapp.$dom.innerHTML(), 
+            visibleList: tapp.manager.lists.visible.slice(0),
+            ui: tapp.ui 
+        };
+        history.pushState({ browserUrl: link }, "", link);
+    } else {
+        history.replaceState({ browserUrl: link }, "", link);                
+    }
+    
+    tapp.manager.scheduleRun(0, "pagemanager-processUpdateBrowserUrl");
+};
+
+PageManager.prototype.back = function()    {
+    return history.back();
+};