dbm 1.0.0

package/startup/Controller.js

@@ -0,0 +1,43 @@
+import Dbm from "../index.js";
+import Runner from "./Runner.js";
+
+export default class Controller extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+        this._runners = [];
+        this._nextId = 0;
+    }
+
+    get isSetup() {
+        return true;
+    }
+
+    _getNextId() {
+        let nextId = this._nextId;
+
+        this._nextId++;
+
+        return nextId;
+    }
+
+    create(aElement, aModuleName, aData) {
+        console.log("Controller::create");
+        console.log(aElement, aData);
+
+        let newRunner = new Runner();
+        newRunner.setup(aElement, aModuleName, aData, this._getNextId());
+        this.add(newRunner);
+        newRunner.start();
+
+        return newRunner;
+    }
+
+    add(aWidget) {
+        this._runners.push(aWidget);
+        return this;
+    }
+
+    remove(aId) {
+        //METODO
+    }
+}

package/startup/Runner.js

@@ -0,0 +1,40 @@
+import Dbm from "../index.js";
+
+export default class Runner extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+
+        this._element = null;
+        this._moduleName = null;
+        this._data = null;
+        this._id = -1;
+        this._reactRoot = null;
+    }
+
+    setup(aElement, aModuleName, aData, aId) {
+        this._element = aElement;
+        this._moduleName = aModuleName;
+        this._data = aData;
+        this._id = aId;
+
+        return this;
+    }
+
+    start() {
+        //console.log("Runner::start");
+        //console.log(this);
+
+        let root = document.createElement("div");
+        this._element.appendChild(root);
+
+        let module = Dbm.getInstance().repository.getItem("moduleCreators/" + this._moduleName).controller;
+
+        this._reactRoot = module.createModule(root, this._data);
+    }
+
+    stop() {
+        //console.log("Runner::stop");
+        
+        this._reactRoot.unmount();
+    }
+}

package/startup/index.js

@@ -0,0 +1,28 @@
+import Dbm from "../index.js";
+
+export {default as Runner} from "./Runner.js";
+export {default as Controller} from "./Controller.js";
+
+export let runStartup = function() {
+    if(!window.dbmstartup.modules.isSetup) {
+        let controller = new Dbm.startup.Controller();
+
+        let currentArray = globalThis.dbmstartup.modules._;
+
+        globalThis.dbmstartup.modules = controller;
+
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentData = currentArray[i];
+            if(currentData) {
+                let newRunner = new Dbm.startup.Runner();
+                newRunner.setup(currentData["element"], currentData["moduleName"], currentData["data"], i);
+                newRunner.start();
+            }
+        }
+
+        controller._nextId = currentArrayLength+1;
+
+        currentArray.splice(0, currentArrayLength);
+    }
+}

package/tracking/Controller.js

@@ -0,0 +1,157 @@
+import Dbm from "../index.js";
+import Cookies from "js-cookie";
+
+export default class Controller extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("trackers", []);
+
+        Dbm.flow.addDirectUpdateCommand(this.item.requireProperty("active", false), Dbm.commands.callFunction(this._updateActiveStatus.bind(this)));
+
+        Dbm.flow.addDirectUpdateCommand(this.item.requireProperty("allowStatistics", false), Dbm.commands.callFunction(this._updateStatisticsTracking.bind(this)));
+        Dbm.flow.addDirectUpdateCommand(this.item.requireProperty("allowMarketing", false), Dbm.commands.callFunction(this._updateMarketingTracking.bind(this)));
+    }
+
+    addTracker(aItem) {
+        //aItem.propertyInput("allowMarketing", this.item.getProperty("allowMarketing"));
+        //aItem.propertyInput("allowStatistics", this.item.getProperty("allowStatistics"));
+
+        let trackers = [].concat(this.item.trackers);
+
+        trackers.push(aItem);
+
+        this.item.trackers = trackers;
+
+        if(this.item.active) {
+            aItem.controller.startTracking();
+            if(this.item.allowStatistics) {
+                aItem.controller.startStatisticsTracking();
+            }
+            if(this.item.allowMarketing) {
+                aItem.controller.startMarketingTracking();
+            }
+        }
+
+        return this;
+    }
+
+    setupPermissionsFromCookies() {
+		this.item.allowStatistics = Cookies.get("cookie/allowStatistics") === "1";
+		this.item.allowMarketing = Cookies.get("cookie/allowMarketing") === "1";
+		
+		return this;
+	}
+
+    start() {
+        console.log("start");
+        this.item.active = true;
+
+        return this;
+    }
+
+    stop() {
+        this.item.active = false;
+
+        return this;
+    }
+
+    _updateActiveStatus() {
+        //console.log("_updateActiveStatus");
+        //console.log(this.item.active);
+
+        let allowStatistics = this.item.allowStatistics;
+        let allowMarketing = this.item.allowMarketing;
+
+        let currentArray = this.item.trackers;
+        let currentArrayLength = currentArray.length;
+        if(this.item.active) {
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTracker = currentArray[i];
+                currentTracker.controller.startTracking();
+                if(allowStatistics) {
+                    currentTracker.controller.startStatisticsTracking();
+                    currentTracker.controller.trackCurrentPage();
+                }
+                if(allowMarketing) {
+                    currentTracker.controller.startMarketingTracking();
+                }
+            }
+        }
+        else {
+            for(let i = 0; i < currentArrayLength; i++) {
+                currentArray[i].controller.stopTracking();
+            }
+        }
+    }
+
+    _updateStatisticsTracking() {
+        //console.log("_updateStatisticsTracking");
+        //console.log(this.item.allowStatistics);
+
+        if(this.item.active && this.item.allowStatistics) {
+            let currentArray = this.item.trackers;
+            let currentArrayLength = currentArray.length;
+            
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTracker = currentArray[i];
+                currentTracker.controller.startStatisticsTracking();
+                currentTracker.controller.trackCurrentPage();
+            }
+        }
+    }
+
+    _updateMarketingTracking() {
+        //console.log("_updateMarketingTracking");
+        //console.log(this.item.allowMarketing);
+
+        if(this.item.active && this.item.allowMarketing) {
+            let currentArray = this.item.trackers;
+            let currentArrayLength = currentArray.length;
+            
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTracker = currentArray[i];
+                currentTracker.controller.startMarketingTracking();
+            }
+        }
+    }
+
+    trackEvent(aEventName, aData) {
+        console.log("trackEvent");
+        console.log(aEventName, aData);
+
+        if(this.item.active) {
+            let currentArray = this.item.trackers;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                currentArray[i].controller.trackEvent(aEventName, aData);
+            }
+        }
+
+        return this;
+    }
+
+    trackPage(aUrl) {
+        if(this.item.active && this.item.allowStatistics) {
+            let currentArray = this.item.trackers;
+            let currentArrayLength = currentArray.length;
+            
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTracker = currentArray[i];
+                currentTracker.controller.trackPage(aUrl);
+            }
+        }
+    }
+
+    trackCurrentPage() {
+        if(this.item.active && this.item.allowStatistics) {
+            let currentArray = this.item.trackers;
+            let currentArrayLength = currentArray.length;
+            
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTracker = currentArray[i];
+                currentTracker.controller.trackCurrentPage();
+            }
+        }
+    }
+}

package/tracking/DataLayerTracker.js

@@ -0,0 +1,80 @@
+import Dbm from "../index.js";
+import Cookies from "js-cookie";
+
+export default class Controller extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    addToDataLayer(aData) {
+		
+		window.dataLayer.push(aData);
+		
+		return this;
+	}
+	
+	_gtag() {
+		window.dataLayer.push(arguments);
+		
+		return this;
+	}
+
+    startTracking() {
+		if(!window.dataLayer) {
+			window.dataLayer = [];
+		}
+		
+		this._gtag("consent", "default", {
+			"ad_storage": "denied",
+			"ad_user_data": "denied",
+			"ad_personalization": "denied",
+			"analytics_storage": "denied"
+		});
+		
+		return this;
+	}
+
+    startStatisticsTracking() {
+		
+		this._gtag("consent", "update", {
+			"analytics_storage": "granted"
+		});
+        this.addToDataLayer({"event": "enableStatistics"});
+		this.addToDataLayer({"event": "trackCurrentPage"});
+		
+		return this;
+	}
+	
+	startMarketingTracking() {
+		
+		this._gtag("consent", "update", {
+			"ad_storage": "granted",
+			"ad_user_data": "granted",
+			"ad_personalization": "granted"
+		});
+        this.addToDataLayer({"event": "enableMarketing"});
+		
+		return this;
+	}
+	
+	stopTracking() {
+		this.addToDataLayer({"event": "stopTracking"});
+		
+		return this;
+	}
+
+    trackEvent(aEventName, aData) {
+        console.log("trackEvent");
+        console.log(aEventName, aData);
+
+        this.addToDataLayer({"event": "trackEvent", "value": {"name": aEventName, "data": aData}});
+    }
+
+    trackCurrentPage() {
+        this.trackPage(document.location.href);
+    }
+
+    trackPage(aUrl) {
+        this.addToDataLayer({"event": "trackPage", "value": {"url": aUrl}});
+    }
+}

package/tracking/index.js

@@ -0,0 +1,16 @@
+import Dbm from "../index.js";
+
+export {default as Controller} from "./Controller.js";
+export {default as DataLayerTracker} from "./DataLayerTracker.js";
+
+export let setup = function() {
+    
+    let controller = new Dbm.tracking.Controller();
+    controller.item.register("trackingController");
+
+    controller.setupPermissionsFromCookies();
+    controller.start();
+
+    let dataLayerTracker = new Dbm.tracking.DataLayerTracker();
+    controller.addTracker(dataLayerTracker.item);
+}

package/updater/PropertyUpdater.js

@@ -0,0 +1,127 @@
+import Dbm from "../index.js";
+import {Tween, Easing} from '@tweenjs/tween.js';
+
+export default class PropertyUpdater extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("tweens", []);
+        this.item.setValue("updatedProperties", []);
+        this.item.setValue("singleUpdateProperties", []);
+        this.item.setValue("running", false);
+        this.item.setValue("timer", 0);
+
+        this._updateBound = this._update.bind(this);
+        this.addSinglePropertyUpdateBound = this.addSinglePropertyUpdate.bind(this);
+    }
+
+    setTimer(aTimerItem) {
+        aTimerItem.update = this._updateBound;
+        this.item.timer = aTimerItem;
+
+        return this;
+    }
+
+    _update(aTime) {
+        //console.log("_update");
+        {
+            let currentArray = this.item.tweens;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentTween = currentArray[i];
+                currentTween.update();
+            }
+        }
+        {
+            let currentArray = this.item.updatedProperties;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentProperty = currentArray[i];
+                if(currentProperty.isDirty) {
+                    //console.log(currentProperty);
+                    currentProperty.updateFlow();
+                }
+            }
+        }
+
+        {
+            let currentArray = this.item.singleUpdateProperties;
+            let currentArrayLength = currentArray.length;
+            if(currentArrayLength) {
+                this.item.singleUpdateProperties = [];
+                for(let i = 0; i < currentArrayLength; i++) {
+                    let currentProperty = currentArray[i];
+                    if(currentProperty.isDirty) {
+                        currentProperty.updateFlow();
+                    }
+                }
+            }
+            
+        }
+    }
+
+    start() {
+        this.item.timer.controller.start();
+
+        return this;
+    }
+
+    stop() {
+        this.item.timer.controller.start();
+        
+        return this;
+    }
+
+    addProperty(aProperty) {
+
+        let updatedProperties = [].concat(this.item.updatedProperties);
+        updatedProperties.push(aProperty);
+        this.item.updatedProperties = updatedProperties;
+
+        return this;
+    }
+
+    removeProperty(aProperty) {
+
+        let updatedProperties = [].concat(this.item.updatedProperties);
+        let index = updatedProperties.indexOf(aProperty);
+
+        if(index >= 0) {
+            updatedProperties.splice(index, 1);
+        }
+        
+        this.item.updatedProperties = updatedProperties;
+
+        return this;
+    }
+
+    animateProperty(aProperty, aToValue, aTime, aDelay = 0, aEasing = null) {
+        let tweenObject = {"envelope": aProperty.value};
+        if(!aEasing) {
+            aEasing = Easing.Quadratic.Out;
+        }
+        let tween = new Tween(tweenObject).to({"envelope": aToValue}, 1000*aTime).delay(1000*aDelay).easing(aEasing).onUpdate(function(aData) {aProperty.value = aData.envelope}).onComplete(() => {this.removeTween(tween)}).start();
+
+        let tweens = [].concat(this.item.tweens);
+        tweens.push(tween);
+        this.item.tweens = tweens;
+
+        return this;
+    }
+
+    removeTween(aTween) {
+        //console.log("removeTween");
+        //METODO
+    }
+
+    addSinglePropertyUpdate(aProperty) {
+        //console.log("addSinglePropertyUpdate");
+        //console.log(aProperty);
+
+        let updatedProperties = [].concat(this.item.singleUpdateProperties);
+        updatedProperties.push(aProperty);
+        this.item.singleUpdateProperties = updatedProperties;
+
+        return this;
+    }
+}

package/updater/RequestAnimationFrameTimer.js

@@ -0,0 +1,43 @@
+import Dbm from "../index.js";
+
+export default class RequestAnimationFrameTimer extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("running", false);
+        this._requestId = 0;
+        this.item.setValue("update", function() {});
+
+        this._updateBound = this._update.bind(this);
+    }
+
+    _update(aTime) {
+
+        this.item.update(aTime);
+
+        if(this.item.running) {
+            this.item.requestId = window.requestAnimationFrame(this._updateBound);
+        }
+    }
+
+    start() {
+        if(!this.item.running) {
+            this.item.running = true;
+            this._requestId = window.requestAnimationFrame(this._updateBound);
+        }
+
+        return this;
+    }
+
+    stop() {
+        if(this.item.running) {
+            this.item.running = false;
+            if(this._requestId) {
+                window.cancelAnimationFrame(this._requestId);
+                this._requestId = 0;
+            }
+        }
+        
+        return this;
+    }
+}

package/updater/index.js

@@ -0,0 +1,16 @@
+import Dbm from "../index.js";
+
+export {default as PropertyUpdater} from "./PropertyUpdater.js";
+export {default as RequestAnimationFrameTimer} from "./RequestAnimationFrameTimer.js";
+
+let webSetup = function() {
+    let updater = new Dbm.updater.PropertyUpdater();
+    updater.item.register("propertyUpdater");
+
+    let requestAnimationFrameTimer = new Dbm.updater.RequestAnimationFrameTimer();
+    updater.setTimer(requestAnimationFrameTimer.item);
+
+    updater.start();
+}
+
+export {webSetup};

package/utils/ArrayFunctions.js

@@ -0,0 +1,20 @@
+
+    let range = function(aStartValue, aEndValue, aStep = 1) {
+        let returnArray = [];
+    
+        return returnArray;
+    }
+
+    export {range};
+
+    let removeDuplicates = function(aArray) {
+        return aArray;
+    }
+
+    export {removeDuplicates};
+
+    let removeDuplicates2 = function(aArray) {
+        return aArray;
+    }
+
+    export {removeDuplicates2};

package/utils/index.js

@@ -0,0 +1 @@
+export * as ArrayFunctions from "./ArrayFunctions.js";