dbm 1.0.0

package/react/login/LoginForm.js

@@ -0,0 +1,113 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class LoginForm extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("username", "");
+        this.item.setValue("password", "");
+
+    }
+
+    _login() {
+        console.log("_login");
+
+        let loader = new Dbm.loading.JsonLoader();
+        loader.setupJsonPost("/api/user/login", {"username": this.item.username, "password": this.item.password});
+
+        Dbm.flow.addUpdateCommand(loader.item.properties.status, Dbm.commands.callFunction(this._loaderStatusChanged.bind(this), [loader]));
+
+        loader.load();
+    }
+
+    _loaderStatusChanged(aLoader) {
+        console.log("_loaderStatusChanged");
+        console.log(aLoader, aLoader.item.status);
+
+        if(aLoader.item.status === Dbm.loading.LoadingStatus.LOADED) {
+            if(aLoader.item.data.success) {
+                
+                let item = Dbm.getInstance().repository.getItem("graphApi").controller.signIn(aLoader.item.data.data.wsToken);
+                Dbm.flow.addUpdateCommand(item.properties.status, Dbm.commands.callFunction(this._graphApiRequestStatusChanges.bind(this), [item, aLoader]));
+            }
+            else {
+                alert("Unable to log in: " + aLoader.item.data.message);
+            }
+        }
+    }
+
+    _graphApiRequestStatusChanges(aRequest, aLoader) {
+        console.log("_graphApiRequestStatusChanges");
+        console.log(aRequest, aRequest.status);
+
+        if(aRequest.status === Dbm.loading.LoadingStatus.LOADED) {
+            let completedCommands = this.getProp("completedCommands");
+            if(completedCommands) {
+                let currentArray = completedCommands;
+                let currentArrayLength = currentArray.length;
+                for(let i = 0; i < currentArrayLength; i++) {
+                    let currentCommand = currentArray[i];
+                    currentCommand.perform(this, aLoader.item.data.data);
+                }
+                return;
+            }
+
+            let site = Dbm.getInstance().repository.getItem("site");
+            let queryString = new URLSearchParams(window.location.search);
+            let skipRedirect = this.getProp("skipRedirect");
+
+            if(!skipRedirect) {
+                let redirectUrl = queryString.get('redirect');
+                if(redirectUrl) {
+                    Dbm.getInstance().repository.getItem("siteNavigation").controller.navigate(redirectUrl);
+                    return;
+                }
+            }
+            
+            let action = queryString.get('action');
+            if(action) {
+                let actionCommand = Dbm.objectPath(site, "loginActions." + action);
+                if(actionCommand) {
+                    actionCommand.perform(this, aLoader.item.data.data);
+                    return;
+                }
+                console.warn("Unknown action " + action);
+            }
+
+            let actionCommand = Dbm.objectPath(site, "loginActions.default");
+            if(actionCommand) {
+                actionCommand.perform(this, aLoader.item.data.data);
+                return;
+            }  
+
+            Dbm.getInstance().repository.getItem("siteNavigation").controller.navigate(site.loggedInUrl);
+        }
+    }
+
+    _renderMainElement() {
+
+        return this._createMainElement("div", {}, 
+            React.createElement("div", {className: "body-text"},
+                React.createElement("div", {"className": ""},
+                    React.createElement("label", {className: ""},
+                        "Email"
+                    )
+                ),
+                React.createElement(Dbm.react.form.FormField, {value: this.item.properties.username}),
+                React.createElement("div", {"className": "spacing standard"}),
+                React.createElement("div", {"className": ""},
+                    React.createElement("label", {className: ""},
+                        "Password"
+                    )
+                ),
+                React.createElement(Dbm.react.form.FormField, {type: "password", value: this.item.properties.password})
+            ),
+            React.createElement("div", {"className": "spacing standard"}),
+            React.createElement("div", {"className": "flex-row justify-center"}, 
+                React.createElement("div", {"className": "standard-button standard-button-padding", onClick: () => this._login()}, "Login")
+            )
+        );
+    }
+}
+

package/react/login/index.js

@@ -0,0 +1 @@
+export {default as LoginForm} from "./LoginForm.js";

package/react/modules/ModuleCreator.js

@@ -0,0 +1,30 @@
+import Dbm from "../../index.js";
+import {createRoot} from 'react-dom/client';
+import {createElement} from "react";
+
+export default class ModuleCreator extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+
+        this._mainElement = null;
+    }
+
+    setMainElement(aElement) {
+        this._mainElement = aElement;
+
+        return this;
+    }
+
+    createModule(aHolderNode, aData) {
+        //console.log("createModule");
+        //console.log(this, aData);
+
+        let root = createRoot(aHolderNode);
+
+        let elementWithInjections = createElement(Dbm.react.context.Context.Provider, {value: {moduleCreator: this, moduleData: aData, moduleRoot: root}}, this._mainElement);
+
+        root.render(elementWithInjections);
+
+        return root;
+    }
+}

package/react/modules/index.js

@@ -0,0 +1 @@
+export {default as ModuleCreator} from "./ModuleCreator.js";

package/react/source/ContextVariableSource.js

@@ -0,0 +1,19 @@
+import Dbm from "../../index.js";
+
+export default class ContextVariableSource extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("path", null);
+    }
+
+    get isSource() {
+        return true;
+    }
+
+    getSource(aFromObject) {
+        //console.log("getSource");
+        
+        return Dbm.objectPath(aFromObject.context, this.item.path);
+    }
+}

package/react/source/index.js

@@ -0,0 +1 @@
+export {default as ContextVariableSource} from "./ContextVariableSource.js";

package/react/text/HtmlText.js

@@ -0,0 +1,14 @@
+import Dbm from "../../index.js";
+
+export default class HtmlText extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    _renderMainElement() {
+        
+        let text = "" + this.getPropValue("text");
+
+        return this._createMainElement("span", {"dangerouslySetInnerHTML": {__html: text}});;
+    }
+}

package/react/text/Text.js

@@ -0,0 +1,13 @@
+import Dbm from "../../index.js";
+
+export default class Text extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    render() {
+        let text = "" + this.getPropValue("text");
+
+        return text;
+    }
+}

package/react/text/index.js

@@ -0,0 +1,19 @@
+import Dbm from "../../index.js";
+import {createElement} from "react";
+
+export {default as Text} from "./Text.js";
+export {default as HtmlText} from "./HtmlText.js";
+
+export let text = function(aText) {
+    if(typeof(aText) === "string") {
+        return aText;
+    }
+    return createElement(Dbm.react.text.Text, {text: aText});
+}
+
+export let htmlText = function(aText, aElementType = "span") {
+    if(typeof(aText) === "string") {
+        //return createElement(aElementType, {"dangerouslySetInnerHTML": {__html: aText}});
+    }
+    return createElement(Dbm.react.text.HtmlText, {text: aText, elementType: aElementType});
+}

package/repository/Item.js

@@ -0,0 +1,70 @@
+import Dbm from "../index.js";
+
+export default class Item extends Dbm.core.LifeCycleObject {
+    _constructProperties() {
+        super._constructProperties();
+
+        this._id = null;
+
+        this.properties = {};
+    }
+
+    get id() {
+        return this._id;
+    }
+
+    register(aId) {
+        this.setId(aId);
+        Dbm.getInstance().repository.addItem(this);
+
+        return this;
+    }
+
+    setId(aId) {
+        this._id = aId;
+
+        return this;
+    }
+
+    setValue(aName, aValue) {
+        this.getProperty(aName).value = aValue;
+        
+        return this;
+    }
+
+    propertyInput(aName, aFlowProperty) {
+        this.getProperty(aName).connectInput(aFlowProperty);
+
+        return this;
+    }
+
+    propertyOutput(aName, aFlowProperty) {
+        aFlowProperty.connectInput(this.getProperty(aName));
+
+        return this;
+    }
+
+    getProperty(aName) {
+        if(!this.properties.hasOwnProperty(aName)) {
+            let property = new Dbm.flow.FlowProperty();
+            Object.defineProperty(this, aName, {
+                get() {
+                    return property.value;
+                },
+                set(aValue) {
+                    property.value = aValue;
+                }
+            });
+            this.properties[aName] = property;
+        }
+
+        return this.properties[aName];
+    }
+
+    requireProperty(aName, aDefaultValue = null) {
+        if(!this.properties.hasOwnProperty(aName)) {
+            this.setValue(aName, aDefaultValue);
+        }
+        return this.properties[aName];
+    }
+}

package/repository/Repository.js

@@ -0,0 +1,60 @@
+import Dbm from "../index.js";
+
+export default class Repository extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._items = {};
+
+        this._item = this.getItem("repository");
+        this.item.setValue("controller", this);
+    }
+
+    addItem(aItem) {
+        this._items[aItem.id] = aItem;
+
+        return this;
+    }
+
+    addAlias(aAlias, aItem) {
+        this._items[aAlias] = aItem;
+
+        return this;
+    }
+
+    getItem(aName) {
+        let item = this._items[aName];
+        if(!item) {
+            item = new Dbm.repository.Item();
+            item.setId(aName);
+            this._items[aName] = item;
+        }
+
+        return item;
+    }
+
+    getItems(aNames) {
+        let currentArray = aNames;
+        let currentArrayLength = currentArray.length;
+        let returnArray = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            returnArray[i] = this.getItem(currentArray[i]);
+        }
+
+        return returnArray;
+    }
+
+    getItemIfExists(aName) {
+        let item = this._items[aName];
+        if(item) {
+            return item;
+        }
+
+        return null;
+    }
+
+    createInternalItem() {
+        let name = "_internal" + Dbm.getInstance().getNextId();
+        return this.getItem(name);
+    }
+}

package/repository/index.js

@@ -0,0 +1,2 @@
+export {default as Item} from "./Item.js";
+export {default as Repository} from "./Repository.js";

package/site/SiteDataLoader.js

@@ -0,0 +1,62 @@
+import Dbm from "../index.js";
+
+export default class SiteDataLoader extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+		this.item.setValue("status", 0);
+        this.item.setValue("url", null);
+		this.item.setValue("currentPage", null);
+        
+		let urlUpdate = new Dbm.flow.updatefunctions.basic.RunCommand();
+		urlUpdate.input.properties.value.connectInput(this.item.properties.url);
+		urlUpdate.input.command = Dbm.commands.callFunction(this._loadUrl.bind(this), []);
+
+		urlUpdate.output.properties.value.startUpdating();
+    }
+
+	_loadUrl() {
+		console.log("_loadUrl");
+
+		let url = this.item.url;
+		if(url != null) {
+			let parsedUrl = new URL(url);
+			let pathName = parsedUrl.pathname;
+
+			let pageData = Dbm.getInstance().repository.getItem(pathName);
+			pageData.setValue("url", url);
+
+			let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+			let request = graphApi.requestUrl(pathName);
+
+			let urlUpdate = new Dbm.flow.updatefunctions.basic.RunCommand();
+			urlUpdate.input.properties.value.connectInput(request.properties.status);
+			urlUpdate.input.command = Dbm.commands.callFunction(this._pageDataLoaded.bind(this), [pageData, request]);
+
+			this.item.setValue("status", 2);
+			urlUpdate.output.properties.value.startUpdating();
+		}
+		else {
+			this.item.currentPage = null;
+			this.item.setValue("status", 0);
+		}
+	}
+
+	_pageDataLoaded(aPageData, aRequest) {
+		//console.log("_pageDataLoaded");
+		//console.log(aPageData, aRequest, aRequest.status);
+
+		if(aRequest.status === 1) {
+			aPageData.setValue("page", aRequest.item);
+			aPageData.setValue("canRender", true);
+
+			if(this.item.url === aPageData.url) {
+				this.item.currentPage = aPageData;
+				this.item.setValue("status", 1);
+			}
+
+			//METODO: remove updaters
+		}
+		
+	}
+}

package/site/SiteNavigation.js

@@ -0,0 +1,242 @@
+import Dbm from "../index.js";
+
+export default class SiteNavigation extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("url", null);
+        this.item.setValue("active", false);
+
+        this.item.setValue("travelPaths", []);
+        this.item.setValue("navigationLocks", []);
+
+        this.item.setValue("allowedPaths", [
+            new RegExp(".*")
+        ]);
+		
+		this.item.setValue("ignoredPaths", [
+			new RegExp("/assets/.*$"),
+			new RegExp("/api/.*$")
+		]);
+
+        this._callback_beforeUnloadBound = this._callback_beforeUnload.bind(this);
+        this._callback_clickBound = this._callback_click.bind(this);
+        this._callback_popStateBound = this._callback_popState.bind(this);
+    }
+
+    start() {
+        this._performStart();
+        this.item.active = true;
+
+        return this;
+    }
+
+    _performStart() {
+        window.addEventListener("beforeunload", this._callback_beforeUnloadBound, true);
+        window.addEventListener("click", this._callback_clickBound, false);
+        window.addEventListener("popstate", this._callback_popStateBound, false);
+    }
+
+    stop() {
+        this._performStop();
+        this.item.active = false;
+
+        return this;
+    }
+
+    _performStop() {
+        window.removeEventListener("beforeunload", this._callback_beforeUnloadBound, true);
+        window.removeEventListener("click", this._callback_clickBound, false);
+        window.removeEventListener("popstate", this._callback_popStateBound, false);
+    }
+
+    _callback_beforeUnload(aEvent) {
+        //METODO
+        let isLocked = this.hasNavigationLock();
+		
+		if(isLocked) {
+			aEvent.preventDefault();
+			aEvent.returnValue = "";
+		
+			return true;
+		}
+		
+		return false;
+    }
+
+    _shouldHandle(aLink) {
+		let shouldHandle = false
+		{
+			let currentArray = this.item.allowedPaths;
+			let currentArrayLength = currentArray.length;
+			for(let i = 0; i < currentArrayLength; i++) {
+				let currentIgnoredPattern = currentArray[i];
+				if(currentIgnoredPattern.test(aLink)) {
+					shouldHandle = true;
+					break;
+				}
+			}
+		}
+		
+		if(!shouldHandle) {
+			return false;
+		}
+		
+		{
+			let currentArray = this.item.ignoredPaths;
+			let currentArrayLength = currentArray.length;
+			for(let i = 0; i < currentArrayLength; i++) {
+				let currentIgnoredPattern = currentArray[i];
+				if(currentIgnoredPattern.test(aLink)) {
+					return false;
+				}
+			}
+		}
+		
+		
+		return true;
+	}
+
+    _hasSpecialKey(aEvent) {
+		return aEvent.altKey || aEvent.ctrlKey || aEvent.metaKey || aEvent.shiftKey;
+	}
+
+    _callback_click(aEvent) {
+        if(aEvent.defaultPrevented) {
+			return true;
+		}
+		if(this._hasSpecialKey(aEvent)) {
+			return true;
+		}
+		
+		let link = null;
+		let currentNode = aEvent.target;
+		let debugCounter = 0;
+		while(currentNode) {
+			if(debugCounter++ > 10000) {
+				console.error("Loop has run for too long");
+				break;
+			}
+			if(currentNode.localName === "a") {
+				let hrefAttribute = currentNode.getAttribute("href");
+				if(hrefAttribute) {
+					link = hrefAttribute.toString();
+					let hardNavigation = currentNode.getAttribute("data-not-spa-link");
+					if(hardNavigation) {
+						return true;
+					}
+					break;
+				}
+			}
+			currentNode = currentNode.parentNode;
+		}
+		
+		if(!link) {
+			return true;
+		}
+		
+		let originalUrl = new URL(document.location.href);
+		let finalUrl = new URL(link, document.location.href);
+		
+		if(originalUrl.hostname !== finalUrl.hostname) {
+			return true;
+		}
+		
+		if(!this._shouldHandle(finalUrl.href)) {
+			return false;
+		}
+		
+		//console.log(finalUrl);
+		
+		aEvent.preventDefault();
+		
+		this._internalNavigation(finalUrl.href);
+		window.scrollTo(0, 0);
+		
+		return false;
+    }
+
+    _addUrlToPath(aUrl) {
+		let paths = [].concat(this.item.travelPaths);
+			
+		paths.push(aUrl);
+		
+		this.item.travelPaths = paths;
+	}
+	
+	_trackPage(aUrl) {
+		//console.log("_trackPage");
+		
+		let trackingController = Dbm.getInstance().repository.getItem("trackingController").controller;
+		if(trackingController) {
+			trackingController.trackPage(aUrl);
+		}
+	}
+
+    _internalNavigation(aUrl) {
+		
+		let locks = this.getLockedNavigationLocks();
+		if(locks.length > 0) {
+			if(!confirm("Leave without saving changes?")) {
+				return;
+			}
+		}
+		
+		history.pushState({}, "Page", aUrl);
+		this.item.url = aUrl;
+		
+		this._trackPage(aUrl);
+		
+		this._addUrlToPath(aUrl);
+	}
+
+    _callback_popState(aEvent) {
+		//console.log("_callback_popState");
+		
+		let url = document.location.href;
+		this.item.url = url;
+		
+		this._trackPage(url);
+		
+		let paths = [].concat(this.item.travelPaths);
+		paths.pop();
+		this.item.travelPaths = paths;
+	}
+
+    navigate(aUrl) {
+        let originalUrl = new URL(document.location.href);
+		let finalUrl = new URL(aUrl, document.location.href);
+		
+		if(this.item.active && originalUrl.hostname === finalUrl.hostname && this._shouldHandle(finalUrl.href)) {
+			this._internalNavigation(finalUrl.href);
+			window.scrollTo(0, 0);
+		}
+		else {
+			document.location.href = aUrl;
+		}
+    }
+
+    setUrlFromLocation() {
+		let url = document.location.href;
+		this.item.url = url
+		
+		this._addUrlToPath(url);
+		
+		return this;
+	}
+
+    getLockedNavigationLocks() {
+		let locks = this.item.navigationLocks;
+		
+		let lockedLocks = locks; //METODO: filter by locked locks
+		
+		return lockedLocks;
+	}
+
+	hasNavigationLock() {
+		
+		let locks = this.getLockedNavigationLocks();
+		
+		return (locks.length > 0);
+	}
+}

package/site/index.js

@@ -0,0 +1,2 @@
+export {default as SiteNavigation} from "./SiteNavigation.js";
+export {default as SiteDataLoader} from "./SiteDataLoader.js";