dbm 1.0.0

package/flow/updatefunctions/basic/CombineString.js

@@ -0,0 +1,45 @@
+import Dbm from "../../../index.js";
+
+export default class CombineString extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("parts", []);
+        this.input.register("delimiter", "");
+
+        this.output.register("value", "");
+    }
+
+    addPart(aValue) {
+        let part = this.input.register("part_" + this.input.parts.length, null).setOrConnect(aValue);
+
+        this.input.parts.push(part);
+
+        return this;
+    }
+
+    addParts(...aParts) {
+        let currentArray = aParts;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            this.addPart(currentArray[i]);
+        }
+
+        return this;
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let currentArray = this.input.parts;
+        let currentArrayLength = currentArray.length;
+
+        let returnArray = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            returnArray[i] = currentArray[i].value;
+        }
+
+        this.output.value = returnArray.join(this.input.delimiter);
+    }
+}

package/flow/updatefunctions/basic/RunCommand.js

@@ -0,0 +1,34 @@
+import Dbm from "../../../index.js";
+
+export default class RunCommand extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("baseObject", this);
+        this.input.register("command", null);
+        this.input.register("value", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let command = this.input.command;
+        command.perform(this.input.baseObject, value);
+        
+
+        this.output.value = value;
+    }
+
+    noFirstTriggger() {
+        this.input.updateValues();
+        this.output.markAsClean();
+        this.isDirty = false;
+
+        return this;
+    }
+}

package/flow/updatefunctions/basic/index.js

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

package/flow/updatefunctions/debug/Log.js

@@ -0,0 +1,30 @@
+import Dbm from "../../../index.js";
+
+export default class Log extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("annotation", null);
+        this.input.register("value", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let annotation = this.input.annotation;
+        if(annotation) {
+            console.log(annotation, value);
+        }
+        else {
+            console.log(value);
+        }
+        
+
+        this.output.value = value;
+    }
+}

package/flow/updatefunctions/debug/index.js

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

package/flow/updatefunctions/dom/ElementSize.js

@@ -0,0 +1,47 @@
+import Dbm from "../../../index.js";
+
+export default class ElementSize extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("element", null);
+
+        this.output.register("width", 0);
+        this.output.register("height", 0);
+
+        this._callback_sizeChangedBound = this._callback_sizeChanged.bind(this);
+    }
+
+    start() {
+        window.addEventListener("resize", this._callback_sizeChangedBound, false);
+
+        return this;
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let element = this.input.element;
+
+        if(element) {
+            this.output.width = element.clientWidth;
+            this.output.height = element.clientHeight;
+        }
+        else {
+            this.output.width = 0;
+            this.output.height = 0;
+        }
+    }
+
+    _callback_sizeChanged(aEvent) {
+        //console.log("_callback_sizeChanged");
+
+        let element = this.input.element;
+
+        if(element) {
+            this.output.properties.width._internal_setValueInFlowOutsideOfUpdate(element.clientWidth);
+            this.output.properties.height._internal_setValueInFlowOutsideOfUpdate(element.clientHeight);
+        }
+    }
+}

package/flow/updatefunctions/dom/StyleObject.js

@@ -0,0 +1,43 @@
+import Dbm from "../../../index.js";
+
+export default class StyleObject extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("values", {});
+        this.input.register("units", {});
+
+        this.output.register("style", {});
+    }
+
+    addProperty(aName, aValue, aUnit = null) {
+        let property = this.input.register("property_" + aName, null).setOrConnect(aValue);
+        let unit = this.input.register("units_" + aName, null).setOrConnect(aUnit);
+
+        this.input.values[aName] = property;
+        this.input.units[aName] = unit;
+
+        return this;
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let properties = this.input.values;
+
+        let styleObject = {};
+
+        for(let objectName in properties) {
+            let value = properties[objectName].value;
+            let unit = this.input.units[objectName].value;
+
+            if(unit) {
+                value += " " + unit;
+            }
+            styleObject[objectName] = value;
+        }
+
+        this.output.style = styleObject;
+    }
+}

package/flow/updatefunctions/dom/index.js

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

package/flow/updatefunctions/index.js

@@ -0,0 +1,5 @@
+export * as logic from "./logic/index.js";
+export * as debug from "./debug/index.js";
+export * as react from "./react/index.js";
+export * as basic from "./basic/index.js";
+export * as dom from "./dom/index.js";

package/flow/updatefunctions/logic/Addition.js

@@ -0,0 +1,19 @@
+import Dbm from "../../../index.js";
+
+export default class Addition extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("input1", 0);
+        this.input.register("input2", 0);
+
+        this.output.register("result", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        this.output.result = this.input.input1 + this.input.input2;
+    }
+}

package/flow/updatefunctions/logic/Multiplication.js

@@ -0,0 +1,19 @@
+import Dbm from "../../../index.js";
+
+export default class Multiplication extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("input1", 0);
+        this.input.register("input2", 0);
+
+        this.output.register("result", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        this.output.result = this.input.input1 * this.input.input2;
+    }
+}

package/flow/updatefunctions/logic/RangeSwitch.js

@@ -0,0 +1,46 @@
+import Dbm from "../../../index.js";
+
+export default class RangeSwitch extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", 0);
+        this.input.register("defaultValue", null);
+        this.input.register("ranges", []);
+
+        this.output.register("value", null);
+    }
+
+    addValueForRange(aOutputValue, aMinInputValue = null, aMaxInputValue = null) {
+
+        let rangeData = {value: aOutputValue, min: aMinInputValue, max: aMaxInputValue};
+
+        let newRanges = [].concat(this.input.ranges);
+
+        newRanges.push(rangeData);
+
+        this.input.ranges = newRanges;
+
+        return this;
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let currentArray = this.input.ranges;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentRange = currentArray[i];
+
+            if((value >= currentRange["min"] || currentRange["min"] === null) && (value < currentRange["max"] || currentRange["max"] === null)) {
+                this.output.value = currentRange["value"];
+                return;
+            }
+        }
+
+        this.output.value = this.input.defaultValue;
+    }
+}

package/flow/updatefunctions/logic/Subtraction.js

@@ -0,0 +1,19 @@
+import Dbm from "../../../index.js";
+
+export default class Subtraction extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("input1", 0);
+        this.input.register("input2", 0);
+
+        this.output.register("result", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        this.output.result = this.input.input1 - this.input.input2;
+    }
+}

package/flow/updatefunctions/logic/index.js

@@ -0,0 +1,38 @@
+import Dbm from "../../../index.js";
+
+export {default as Addition} from "./Addition.js";
+export {default as Multiplication} from "./Multiplication.js";
+export {default as RangeSwitch} from "./RangeSwitch.js";
+export {default as Subtraction} from "./Subtraction.js";
+
+export let subtract = function(aInput1 = 0, aInput2 = 0) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
+    updateFunction.input.properties.input1.setOrConnect(aInput1);
+    updateFunction.input.properties.input2.setOrConnect(aInput2);
+
+    return updateFunction;
+}
+
+export let invertP = function(aP = 0) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
+    updateFunction.input.properties.input1.setValue(1);
+    updateFunction.input.properties.input2.setOrConnect(aP);
+
+    return updateFunction;
+}
+
+export let add = function(aInput1 = 0, aInput2 = 0) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Addition();
+    updateFunction.input.properties.input1.setOrConnect(aInput1);
+    updateFunction.input.properties.input2.setOrConnect(aInput2);
+
+    return updateFunction;
+}
+
+export let multiply = function(aInput1 = 1, aInput2 = 1) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.Multiplication();
+    updateFunction.input.properties.input1.setOrConnect(aInput1);
+    updateFunction.input.properties.input2.setOrConnect(aInput2);
+
+    return updateFunction;
+}

package/flow/updatefunctions/react/UpdateState.js

@@ -0,0 +1,22 @@
+import Dbm from "../../../index.js";
+
+export default class UpdateState extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("owner", null);
+
+        this.output.register("dynamicUpdate", 0);
+    }
+
+    _update() {
+        //console.log("UpdateState::_update");
+
+        let dynamicUpdate = this.input.owner.state.dynamicUpdate;
+        dynamicUpdate++;
+        this.input.owner.setState({"dynamicUpdate": dynamicUpdate});
+
+        this.output.dynamicUpdate = dynamicUpdate;
+    }
+}

package/flow/updatefunctions/react/index.js

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

package/graphapi/index.js

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

package/graphapi/webclient/WebSocketConnection.js

@@ -0,0 +1,236 @@
+import Dbm from "../../index.js";
+
+export default class WebSocketConnection extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this._webSocket = null;
+        this._callback_onOpenBound = this._callback_onOpen.bind(this);
+        this._callback_onMessageBound = this._callback_onMessage.bind(this);
+
+        this.item.setValue("requests", []);
+        this.item.setValue("status", 0);
+    }
+
+    setup(aUrl) {
+        this._webSocket = new WebSocket(aUrl);
+        this.item.setValue("status", 2);
+
+        this._webSocket.onopen = this._callback_onOpenBound;
+        this._webSocket.onmessage = this._callback_onMessageBound;
+        return this;
+    }
+
+    _getRequestItem() {
+        let requestId = "graphApi/webSocketRequest" + Dbm.getInstance().getNextId();
+
+        let request = new Dbm.graphapi.webclient.WebSocketRequest();
+        request.item.register(requestId);
+        request.item.setValue("status", Dbm.loading.LoadingStatus.NOT_STARTED);
+        request.item.setValue("connection", this.item); 
+
+        return request.item;
+    }
+
+    _runRequest(aRequestItem) {
+        let newRequests = [].concat(this.item.requests);
+        newRequests.push(aRequestItem);
+        this.item.setValue("requests", newRequests);
+
+        if(this.item.status === 1) {
+            aRequestItem.setValue("status", Dbm.loading.LoadingStatus.LOADING);
+            this._webSocket.send(JSON.stringify(aRequestItem.requestData));
+        }
+    }
+
+    requestRange(aSelect, aEncode) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "range", "select": aSelect, "encode": aEncode, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
+    requestItem(aId, aEncode) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "item", "id": aId, "encode": aEncode, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
+    requestData(aFunctionName, aData) {
+        console.log("requestData");
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "data", "functionName": aFunctionName, "data": aData, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
+    createItem(aTypes, aVisibility = "draft", aChanges = [], aEncode = []) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "admin/createObject", "types": aTypes, "visibility": aVisibility, "changes": aChanges, "encode": aEncode, "requestId": item.id});
+        this._runRequest(item);
+
+        return item;
+    }
+
+    editItem(aId, aChanges, aEncode = []) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "admin/editObject", "id": aId, "changes": aChanges, "encode": aEncode, "requestId": item.id});
+        this._runRequest(item);
+
+        return item;
+    }
+
+    requestUrl(aUrl) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "url", "url": aUrl, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
+    _callback_onOpen(aEvent) {
+        //console.log("_callback_onOpen");
+
+        //MENOTE: do nothing
+    }
+
+    _connectionReady() {
+        this.item.setValue("status", 1);
+        let currentArray = this.item.requests;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentItem = currentArray[i];
+            currentItem.setValue("status", Dbm.loading.LoadingStatus.LOADING);
+            this._webSocket.send(JSON.stringify(currentItem.requestData));
+        }
+    }
+
+    _callback_onMessage(aEvent) {
+        //console.log("_callback_onMessage");
+        //console.log(aEvent.data);
+
+        let data = JSON.parse(aEvent.data);
+        let repository = Dbm.getInstance().repository;
+        switch(data.type) {
+            case "updateEncodedObject":
+                {
+                    let item = repository.getItem(data["id"]);
+                    let decoder = repository.getItemIfExists("graphApi/decode/" + data["encoding"]);
+                    if(decoder) {
+                        decoder.controller.updateItemWithEncoding(item, data["data"]);
+                    }
+                    else {
+                        console.warn("No decoder for " + data["encoding"]);
+                    }
+                }
+                break;
+            case "range/response":
+                {
+                    let item = repository.getItem(data["requestId"]);
+                    item.setValue("items", repository.getItems(data["ids"]));
+                    item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+                }
+                break;
+            case "item/response":
+                {
+                    let item = repository.getItem(data["requestId"]);
+                    item.setValue("item", repository.getItem(data["id"]));
+                    item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+
+                    let currentArray = item.doneCommands;
+                    if(currentArray) {
+                        let currentArrayLength = currentArray.length;
+                        for(let i = 0; i < currentArrayLength; i++) {
+                            let currentCommand = currentArray[i];
+                            currentCommand.perform(item, data["id"]);
+                        }
+                    }
+                }
+                break;
+            case "data/response":
+                {
+                    let item = repository.getItem(data["requestId"]);
+                    item.setValue("data", data["data"]);
+                    item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+
+                    let currentArray = item.doneCommands;
+                    if(currentArray) {
+                        let currentArrayLength = currentArray.length;
+                        for(let i = 0; i < currentArrayLength; i++) {
+                            let currentCommand = currentArray[i];
+                            currentCommand.perform(item, data["data"]);
+                        }
+                    }
+                }
+                break;
+            case "url/response":
+                {
+                    let item = repository.getItem(data["requestId"]);
+                    if(data["id"]) {
+                        item.setValue("item", repository.getItem(data["id"]));
+                    }
+                    else {
+                        item.setValue("item", null);
+                    }
+                    item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+
+                    let currentArray = item.doneCommands;
+                    if(currentArray) {
+                        let currentArrayLength = currentArray.length;
+                        for(let i = 0; i < currentArrayLength; i++) {
+                            let currentCommand = currentArray[i];
+                            currentCommand.perform(item, data["id"]);
+                        }
+                    }
+                }
+                break;
+            case "currentUser/response":
+                {
+                    let item = repository.getItem(data["requestId"]);
+                    if(data["id"]) {
+                        item.setValue("user", repository.getItem(data["id"]));
+                    }
+                    else {
+                        item.setValue("user", null);
+                    }
+                    repository.getItem("site").currentUser = item.user;
+                    item.setValue("status", Dbm.loading.LoadingStatus.LOADED);
+                }
+                break;
+            case "connectionReady": 
+                {
+                    if(data["user"]) {
+                        repository.getItem("site").currentUser = repository.getItem(data["user"]);
+                    }
+                    else {
+                        repository.getItem("site").currentUser = null;
+                    }
+                    this._connectionReady();
+                }
+                break;
+            default:
+                console.warn("Unknown message type " + data.type);
+                break;
+        }
+    }
+
+    signIn(aToken) {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "user/signInWithToken", "token": aToken, "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+
+    signOut() {
+        let item = this._getRequestItem();
+        item.setValue("requestData", {"type": "user/signOut", "requestId": item.id});
+        this._runRequest(item);
+        
+        return item;
+    }
+}

package/graphapi/webclient/WebSocketRequest.js

@@ -0,0 +1,30 @@
+import Dbm from "../../index.js";
+
+export default class WebSocketRequest extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+    }
+
+    get processPromise() {
+        if(this.item.status === Dbm.loading.LoadingStatus.LOADED) {
+            return Promise.resolve(this.item);
+        }
+        if(this.item.status === Dbm.loading.LoadingStatus.LOADING || this.item.status === Dbm.loading.LoadingStatus.NOT_STARTED) {
+            if(!this.item.processPromise) {
+                let resolveCommand = Dbm.commands.resolvePromise(this.item);
+                this.item.setValue("doneCommands", [resolveCommand]);
+                let rejectCommand = Dbm.commands.callFunction(resolveCommand.item.reject, []);
+                this.item.setValue("errorCommands", [rejectCommand]);
+    
+                //METODO: change these to addToArray
+
+                this.item.setValue("processPromise", resolveCommand.item.promise);
+            }
+            
+            return this.item.processPromise;
+        }
+        
+        return Promise.reject();
+    }
+}