dbm 1.0.4 → 1.0.6

package/commands/CallFunction.js

@@ -11,11 +11,27 @@ export default class CallFunction extends CommandBaseObject {
     }
 
     perform(aFromObject, aData) {
-
-        //METODO: resolve input
+		
         let callFunction = this.item.callFunction;
+		
+		let currentArray = this.item.callArguments;
+		let currentArrayLength = currentArray.length;
+		let resolvedArguments = new Array(currentArrayLength);
+		
+        for(let i = 0; i < currentArrayLength; i++){
+            let currentArgument = currentArray[i];
+			
+            if(currentArgument && currentArgument.isFlowProperty) {
+                currentArgument = currentArgument.value;
+            }
+            else if(currentArgument && currentArgument.isSource) {
+                currentArgument = currentArgument.getSource(aFromObject, aData);
+            }
+            
+            resolvedArguments[i] = currentArgument;
+        }
 
         //METODO: try catch
-        callFunction.apply(this.item.scopeObject, this.item.callArguments);
+        return callFunction.apply(this.item.scopeObject, resolvedArguments);
     }
 }

package/core/index.js

@@ -1,3 +1,5 @@
 export {default as LifeCycleObject} from "./LifeCycleObject.js";
 export {default as BaseObject} from "./BaseObject.js";
-export {default as GlobalObject} from "./GlobalObject.js";
+export {default as GlobalObject} from "./GlobalObject.js";
+
+export * as source from "./source/index.js";

package/core/source/EventSource.js

@@ -0,0 +1,8 @@
+import Dbm from "../../index.js";
+
+export default class EventSource extends Dbm.core.source.SourceBaseObject {
+	
+	getBaseObject(aFromObject, aEventData) {
+		return aEventData;
+	}
+}

package/core/source/SourceBaseObject.js

@@ -0,0 +1,29 @@
+import Dbm from "../../index.js";
+
+export default class SourceBaseObject extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("path", null);
+    }
+
+    get isSource() {
+        return true;
+    }
+	
+	getBaseObject(aFromObject, aEventData) {
+		return null;
+	}
+
+    getSource(aFromObject, aEventData = null) {
+        //console.log("getSource");
+		
+		let path = this.item.path;
+		let baseObject = this.getBaseObject(aFromObject, aEventData);
+		if(!path) {
+			return baseObject;
+		}
+        
+        return Dbm.objectPath(baseObject, path);
+    }
+}

package/core/source/StaticSource.js

@@ -0,0 +1,14 @@
+import Dbm from "../../index.js";
+
+export default class StaticSoruce extends Dbm.core.source.SourceBaseObject {
+	
+    _construct() {
+        super._construct();
+
+        this.item.setValue("object", null);
+    }
+	
+	getBaseObject(aFromObject, aEventData) {
+		return this.item.object;
+	}
+}

package/core/source/index.js

@@ -0,0 +1,22 @@
+import Dbm from "../../index.js";
+
+export {default as SourceBaseObject} from "./SourceBaseObject.js";
+export {default as EventSource} from "./EventSource.js";
+export {default as StaticSource} from "./StaticSource.js";
+
+export const event = function(aPath = null) {
+	let newSource = new Dbm.core.source.EventSource();
+	
+	newSource.item.properties.path.setOrConnect(aPath);
+	
+	return newSource;
+}
+
+export const staticObject = function(aObject, aPath = null) {
+	let newSource = new Dbm.core.source.StaticSource();
+	
+	newSource.item.object = aObject;
+	newSource.item.properties.path.setOrConnect(aPath);
+	
+	return newSource;
+}

package/flow/FlowProperty.js

@@ -17,7 +17,7 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
 
     setValue(aValue) {
         if(this._upstreamConnection) {
-            //METODO: add warning
+			console.warn("Property has upstream connection, can't set value", this, aValue);
             //METODO: check if upstream can be changed
         }
         else {

package/flow/FlowPropertyWithExternalInput.js

@@ -0,0 +1,18 @@
+import Dbm from "../index.js";
+
+export default class FlowPropertyWithExternalInput extends Dbm.flow.FlowProperty {
+
+    setValue(aValue) {
+        if(aValue !== this._value) {
+            this._value = aValue;
+            this.isDirty = false;
+            this.setDownstreamAsDirty();
+        }
+
+        return this;
+    }
+
+    _internal_setValueInFlow(aValue) {
+        //MENOTE: do nothing
+    }
+}

package/flow/index.js

@@ -6,6 +6,7 @@ export {default as FlowUpdateFunction} from "./FlowUpdateFunction.js";
 export {default as UpdateFunctionInputs} from "./UpdateFunctionInputs.js";
 export {default as UpdateFunctionOutputs} from "./UpdateFunctionOutputs.js";
 export {default as DirtyCommands} from "./DirtyCommands.js";
+export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExternalInput.js";
 
 export * as updatefunctions from "./updatefunctions/index.js";
 
@@ -15,7 +16,7 @@ export let addUpdateCommand = function(aProperty, aCommand) {
     updateFunction.input.command = aCommand;
     updateFunction.noFirstTriggger();
     
-    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.getInstance().repository.getItem("propertyUpdater").controller.addSinglePropertyUpdateBound, [updateFunction.output.properties.value]);
+    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.getInstance().repository.getItem("propertyUpdater").controller.addSinglePropertyUpdateBound, [Dbm.core.source.staticObject(updateFunction.output.properties.value)]);
 
     let dirtyCommands = new Dbm.flow.DirtyCommands();
     updateFunction.output.properties.value.connectOutput(dirtyCommands);
@@ -37,4 +38,40 @@ export let addDirectUpdateCommand = function(aProperty, aCommand) {
     dirtyCommands.commands.push(updatePropertyCommand);
     
     return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
+}
+
+export let addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
+	let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
+	
+	let updateData = Dbm.flow.addUpdateCommand(whenMatched.output.properties.value, aCommand);
+	
+	updateData["whenMatched"] = whenMatched;
+	
+	return whenMatched;
+}
+
+export const animateValue = function(aValue, aTime = 0.5, aEasing = null) {
+	
+	let returnObject = new Dbm.repository.Item();
+	
+	returnObject.setValue("time", aTime);
+	returnObject.setValue("easing", aEasing);
+	
+	let inputProperty = returnObject.requireProperty("input");
+	inputProperty.setOrConnect(aValue);
+	
+	let outputProperty = new Dbm.flow.FlowPropertyWithExternalInput();
+	outputProperty.value = inputProperty.value;
+	
+	returnObject._internal_addProperty("output", outputProperty);
+	
+	let updateCommand = Dbm.flow.addUpdateCommand(inputProperty, Dbm.commands.callFunction(function(aItem) {
+		console.log("animate value");
+		
+		aItem.properties.output.animateValue(aItem.input, aItem.time, aItem.easing);
+	}, [returnObject]));
+	
+	returnObject.setValue("updateCommand", updateCommand);
+	
+	return returnObject;
 }

package/flow/updatefunctions/basic/RunCommand.js

@@ -18,10 +18,9 @@ export default class RunCommand extends Dbm.flow.FlowUpdateFunction {
         let value = this.input.value;
 
         let command = this.input.command;
-        command.perform(this.input.baseObject, value);
-        
+        let outputValue = command.perform(this.input.baseObject, value);
 
-        this.output.value = value;
+        this.output.value = outputValue;
     }
 
     noFirstTriggger() {

package/flow/updatefunctions/basic/index.js

@@ -1,2 +1,18 @@
+import Dbm from "../../../index.js";
+
 export {default as RunCommand} from "./RunCommand.js";
-export {default as CombineString} from "./CombineString.js";
+export {default as CombineString} from "./CombineString.js";
+
+export const runCommand = function(aValue, aCommand) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
+	updateFunction.input.properties.value.setOrConnect(aValue);
+	updateFunction.input.properties.command.setOrConnect(aCommand);
+	
+	return updateFunction;
+}
+
+export const transformValue = function(aValue, aFunction) {
+	let command = Dbm.commands.callFunction(aFunction, [Dbm.core.source.event()]);
+	
+	return Dbm.flow.updatefunctions.basic.runCommand(aValue, command);
+}

package/flow/updatefunctions/dom/ElementPosition.js

@@ -37,10 +37,14 @@ export default class ElementPosition extends Dbm.flow.FlowUpdateFunction {
 			console.log(element);
             //this.output.width = element.clientWidth;
             //this.output.height = element.clientHeight;
+			
+			//METODO
         }
         else {
             //this.output.width = 0;
             //this.output.height = 0;
+			
+			//METODO
         }
     }
 

package/flow/updatefunctions/logic/Switch.js

@@ -31,13 +31,13 @@ export default class Switch extends Dbm.flow.FlowUpdateFunction {
 
         let value = this.input.value;
 
-        let currentArray = this.input.ranges;
+        let currentArray = this.input.cases;
         let currentArrayLength = currentArray.length;
         for(let i = 0; i < currentArrayLength; i++) {
             let currentCase = currentArray[i];
 
             if(value === currentCase["key"]) {
-                this.output.value = currentRange["value"];
+                this.output.value = currentCase["value"];
                 return;
             }
         }

package/flow/updatefunctions/logic/WhenMatched.js

@@ -0,0 +1,24 @@
+import Dbm from "../../../index.js";
+
+export default class WhenMatched extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", null);
+        this.input.register("matchValue", true);
+
+        this.output.register("value", false);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        if(this.input.value === this.input.matchValue) {
+            this.output.value = true;
+        }
+		else {
+			this.output.properties.value.isDirty = false;
+		}
+    }
+}

package/flow/updatefunctions/logic/index.js

@@ -9,6 +9,7 @@ export {default as Condition} from "./Condition.js";
 export {default as All} from "./All.js";
 export {default as Any} from "./Any.js";
 export {default as AllAtValue} from "./AllAtValue.js";
+export {default as WhenMatched} from "./WhenMatched.js";
 
 export let subtract = function(aInput1 = 0, aInput2 = 0) {
     let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
@@ -87,4 +88,19 @@ export let allAtValue = function(aMatchValue, ...aValues) {
     }
 
     return updateFunction;
+}
+
+export let whenMatched = function(aValue, aMatchValue = true) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.WhenMatched();
+    updateFunction.input.properties.value.setOrConnect(aValue);
+    updateFunction.input.properties.matchValue.setOrConnect(aMatchValue);
+
+    return updateFunction;
+}
+
+export let switchValue = function(aValue = null) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Switch();
+    updateFunction.input.properties.value.setOrConnect(aValue);
+	
+	return updateFunction;
 }

package/loading/index.js

@@ -3,6 +3,8 @@ export {default as ScriptLoader} from "./ScriptLoader.js";
 export {default as JsonLoader} from "./JsonLoader.js";
 export * as LoadingStatus from "./LoadingStatus.js";
 
+export * as node from "./node/index.js";
+
 export let loadScript = function(aUrl) {
 
     let loaderName = "loader-" + aUrl;

package/loading/node/TextLoader.js

@@ -0,0 +1,161 @@
+import https from "node:https";
+import http from "node:http";
+
+import Dbm from "../../index.js";
+
+export default class JsonLoader extends Dbm.core.BaseObject {
+
+	_construct() {
+		
+		super._construct();
+		
+		this.item.setValue("url", null);
+		this.item.setValue("method", "GET");
+		this.item.setValue("headers", {});
+		
+		this.item.setValue("status", Dbm.loading.LoadingStatus.NOT_STARTED);
+        this.item.setValue("data", null);
+        this.item.setValue("body", null);
+		this.item.setValue("rawData", "");
+
+		this._callback_requestBound = this._callback_request.bind(this);
+		this._callback_dataBound = this._callback_data.bind(this);
+		this._callback_errorBound = this._callback_error.bind(this);
+		this._callback_endBound = this._callback_end.bind(this);
+	}
+	
+	get completed() {
+		let status = this.item.status;
+		return (status === Dbm.loading.LoadingStatus.LOADED || status === Dbm.loading.LoadingStatus.ERROR);
+	}
+	
+	setMethod(aMethod) {
+		this.item.method = aMethod;
+		
+		return this;
+	}
+	
+	setUrl(aUrl) {
+		this.item.url = aUrl;
+		
+		return this;
+	}
+	
+	setupPost(aUrl, aBody) {
+		this.item.url = aUrl;
+		this.item.method = "POST";
+		this.setBody(aBody);
+		
+		return this;
+	}
+	
+	setupJsonPost(aUrl, aBody) {
+		this.item.url = aUrl;
+		
+		return this.setJsonPostBody(aBody);
+	}
+	
+	setJsonPostBody(aBody) {
+		this.item.method = "POST";
+		this.item.body = JSON.stringify(aBody);
+		
+		this.addHeader("Content-Type", "application/json");
+		
+		return this;
+	}
+	
+	addHeader(aName, aValue) {
+		this.item.headers[aName] = aValue;
+		
+		return this;
+	}
+	
+	setBody(aBody) {
+		this.item.body = (aBody instanceof String) ? aBody : JSON.stringify(aBody);
+		
+		return this;
+	}
+	
+	setData(aData) {
+		//console.log("wprr/utils/loading/JsonLoader::setData");
+		//console.log(aData);
+		
+		this._loadedAt = (new Date()).valueOf();
+		this.item.data = aData;
+	}
+	
+	setStatus(aStatus) {
+		//console.log("wprr/utils/loading/JsonLoader::setStatus");
+		//console.log(aStatus);
+		
+		this.item.status = aStatus;
+		
+		return this;
+	}
+
+	_callback_request(aResponse) {
+		//console.log("_callback_request");
+		aResponse.on("data", this._callback_dataBound);
+		aResponse.on("end", this._callback_endBound);
+	}
+
+	_callback_data(aData) {
+		//console.log("_callback_data");
+		this.item.rawData += aData;
+	}
+
+	_callback_error(aError) {
+		console.log("_callback_error");
+		console.error(aError.message);
+
+		this.item.status = Dbm.loading.LoadingStatus.ERROR;
+	}
+
+	_callback_end() {
+		//console.log("_callback_end");
+		//console.log(this.item.rawData);
+		this._setData(this.item.rawData);
+		this.item.status = Dbm.loading.LoadingStatus.LOADED;
+	}
+
+	_setData(aData) {
+		this.item.data = aData;
+	}
+	
+	load() {
+		//console.log("load");
+		
+		if(this.item.status !== Dbm.loading.LoadingStatus.NOT_STARTED) {
+			return this;
+		}
+
+		let body = this.item.body;
+		
+        this.item.status = Dbm.loading.LoadingStatus.LOADING;
+		let sendParameters =  {
+			"method": this.item.method,
+			"headers": {...this.item.headers}
+		};
+
+		if(body) {
+			sendParameters.headers['Content-Length'] = body.length;
+		}
+
+		let url = this.item.url;
+		
+		let request;
+		if(url.indexOf("https://") === 0) {
+			request = https.request(url, sendParameters, this._callback_requestBound).on("error", this._callback_errorBound);
+		}
+		else {
+			request = http.request(url, sendParameters, this._callback_requestBound).on("error", this._callback_errorBound);
+		}
+
+		if(body) {
+			request.write(body);
+		}
+		request.end();
+		
+		return this;
+	}
+}

package/loading/node/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "index.js",
   "type": "module",
   "scripts": {},

package/react/BaseObject.js

@@ -27,11 +27,14 @@ export default class BaseObject extends Component {
                 let currentDynamicProperty = this.getDynamicProp(objectName);
                 currentDynamicProperty.setValue(currentProp);
             }
-            
-            if(currentProp && currentProp.isFlowProperty) {
+            else if(currentProp && currentProp.isFlowProperty) {
                 let currentDynamicProperty = this.getDynamicProp(objectName);
                 currentDynamicProperty.connectInput(currentProp);
             }
+			else if(this._dynamicProps[objectName]) {
+                let currentDynamicProperty = this.getDynamicProp(objectName);
+                currentDynamicProperty.value = currentProp;
+			}
         }
 
         //METODO: remove unused connections

package/react/area/OpenCloseExpandableArea.js

@@ -0,0 +1,45 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class OpenCloseExpandableArea extends Dbm.react.BaseObject {
+	_construct() {
+		super._construct();
+		
+		let startValue = this.getPropValue("startState") === "open";
+		let openProperty = this.getDynamicProp("open", startValue);
+		
+		let switchValue = Dbm.flow.updatefunctions.logic.switchValue(openProperty).addCase(false, 0).addCase(true, 1);
+		let animateValueObject = Dbm.flow.animateValue(switchValue.output.properties.value);
+		let transformToStyle = Dbm.flow.updatefunctions.basic.transformValue(animateValueObject.properties.output, this._transformToStyle.bind(this));
+		
+		this.item.requireProperty("animationStyle", {}).connectInput(transformToStyle.output.properties.value);
+	}
+	
+	_transformToStyle(aEnvelope) {
+		console.log("_transformToStyle");
+		console.log(aEnvelope, this, this.item.element);
+		
+		if(aEnvelope === 0) {
+			return {"height": "0px", "overflow": "hidden"};
+		}
+		else if(aEnvelope === 1 || !this.item.element) {
+			return {};
+		}
+		
+		return {"height": (this.item.element.clientHeight*aEnvelope) + "px", "overflow": "hidden"};
+	}
+	
+	_renderMainElement() {
+        //console.log("OpenCloseExpandableArea::_renderMainElement");
+        //console.log(this);
+		
+		return this._createMainElement(Dbm.react.BaseObject, {"className": "animation-element", "style": this.item.properties.animationStyle},
+			React.createElement("div", {"ref": this.createRef("element")},
+				this.getPropValue("children")
+			)
+		);
+		
+		return null;
+	}
+}
+

package/react/area/ScrollActivatedArea.js

@@ -6,7 +6,7 @@ export default class ScrollActivatedArea extends Dbm.react.BaseObject {
         super._construct();
 		
 		let elementProperty = this.item.requireProperty("element", null);
-		this.item.requireProperty("activated", false);
+		let activatedProperty = this.item.requireProperty("activated", false);
 		
 		let position = new Dbm.flow.updatefunctions.dom.ElementPosition();
 		this.item.setValue("position", position);
@@ -15,17 +15,11 @@ export default class ScrollActivatedArea extends Dbm.react.BaseObject {
 		let prepareProperty = this.item.requireProperty("prepare", 100);
 		position.input.properties.prepareY.connectInput(prepareProperty);
 		
-		position.start();
+		let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(position.output.properties.prepare, true);
+		activatedProperty.connectInput(whenMatched.output.properties.value);
 		
-		Dbm.flow.addUpdateCommand(position.output.properties.prepare, Dbm.commands.callFunction(this._prepareChanged.bind(this)));
-    }
-	
-	_prepareChanged() {
-		//console.log("_prepareChanged");
+		position.start();
 		
-		if(this.item.position.output.prepare) {
-			this.item.setValue("activated", true);
-		}
 	}
 
     _renderMainElement() {

package/react/area/index.js

@@ -1,3 +1,4 @@
 export {default as InsertElement} from "./InsertElement.js";
 export {default as HasData} from "./HasData.js";
-export {default as ScrollActivatedArea} from "./ScrollActivatedArea.js";
+export {default as ScrollActivatedArea} from "./ScrollActivatedArea.js";
+export {default as OpenCloseExpandableArea} from "./OpenCloseExpandableArea.js";

package/react/cookies/CookieBar.js

@@ -149,13 +149,10 @@ export default class CookieBar extends Dbm.react.BaseObject {
 
     _renderMainElement() {
 
-        let isOpen = this.getDynamicProp("open").value;
-        if(!isOpen) {
-            return null;
-        }
-
-        return this._createMainElement("div", {className: "cookie-bar-position", ref: this.createRef("widthElement")}, 
-            React.createElement(Dbm.react.area.InsertElement, {element: this.item.properties.element})
+        return this._createMainElement("div", {className: "cookie-bar-position", ref: this.createRef("widthElement")},
+			React.createElement(Dbm.react.area.OpenCloseExpandableArea, {open: this.getDynamicProp("open")},
+            	React.createElement(Dbm.react.area.InsertElement, {element: this.item.properties.element})
+			)
         );
     }
 }

package/react/source/ContextVariableSource.js

@@ -1,19 +1,8 @@
 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);
-    }
+export default class SourceBaseObject extends Dbm.core.source.SourceBaseObject {
+	
+	getBaseObject(aFromObject, aEventData) {
+		return aFromObject.context;
+	}
 }

package/repository/Item.js

@@ -43,19 +43,23 @@ export default class Item extends Dbm.core.LifeCycleObject {
 
         return this;
     }
+	
+	_internal_addProperty(aName, aProperty) {
+        Object.defineProperty(this, aName, {
+            get() {
+                return aProperty.value;
+            },
+            set(aValue) {
+                aProperty.value = aValue;
+            }
+        });
+        this.properties[aName] = aProperty;
+	}
 
     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;
+			this._internal_addProperty(aName, property);
         }
 
         return this.properties[aName];

package/updater/IntervalTimer.js

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

package/updater/index.js

@@ -2,6 +2,7 @@ import Dbm from "../index.js";
 
 export {default as PropertyUpdater} from "./PropertyUpdater.js";
 export {default as RequestAnimationFrameTimer} from "./RequestAnimationFrameTimer.js";
+export {default as IntervalTimer} from "./IntervalTimer.js";
 
 let webSetup = function() {
     let updater = new Dbm.updater.PropertyUpdater();
@@ -13,4 +14,16 @@ let webSetup = function() {
     updater.start();
 }
 
-export {webSetup};
+export {webSetup};
+
+let nodeSetup = function() {
+    let updater = new Dbm.updater.PropertyUpdater();
+    updater.item.register("propertyUpdater");
+
+    let timer = new Dbm.updater.IntervalTimer();
+    updater.setTimer(timer.item);
+
+    updater.start();
+}
+
+export {nodeSetup};