dbm 1.0.0

package/commands/CallFunction.js

@@ -0,0 +1,21 @@
+import Dbm from "../index.js";
+import CommandBaseObject from "./CommandBaseObject.js"
+
+export default class CallFunction extends CommandBaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("scopeObject", null);
+        this.item.setValue("callFunction", null);
+        this.item.setValue("callArguments", []);
+    }
+
+    perform(aFromObject, aData) {
+
+        //METODO: resolve input
+        let callFunction = this.item.callFunction;
+
+        //METODO: try catch
+        callFunction.apply(this.item.scopeObject, this.item.callArguments);
+    }
+}

package/commands/CommandBaseObject.js

@@ -0,0 +1,11 @@
+import Dbm from "../index.js";
+
+export default class CommandBaseObject extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    perform(aFromObject, aData) {
+        //MENOTE: should be overridden
+    }
+}

package/commands/ResolvePromise.js

@@ -0,0 +1,20 @@
+import Dbm from "../index.js";
+import CommandBaseObject from "./CommandBaseObject.js"
+
+export default class ResolvePromise extends CommandBaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.setValue("promise", new Promise((aResolve, aReject) => {
+            this.item.setValue("resolve", aResolve);
+            this.item.setValue("reject", aReject);
+        }));
+
+        this.item.setValue("value", null);
+    }
+
+    perform(aFromObject, aData) {
+
+        this.item.resolve(this.item.value);
+    }
+}

package/commands/index.js

@@ -0,0 +1,36 @@
+import Dbm from "../index.js";
+
+export {default as CommandBaseObject} from "./CommandBaseObject.js";
+export {default as CallFunction} from "./CallFunction.js";
+export {default as ResolvePromise} from "./ResolvePromise.js";
+
+
+let callScopedFunction = function(aScopeObject, aFunction, aArguments = []) {
+    let newCommand = new Dbm.commands.CallFunction();
+    newCommand.item.setValue("scopeObject", aScopeObject);
+    newCommand.item.setValue("callFunction", aFunction);
+    newCommand.item.setValue("callArguments", aArguments);
+
+    return newCommand;
+}
+
+export {callScopedFunction};
+
+let callFunction = function(aFunction, aArguments = []) {
+    let newCommand = new Dbm.commands.CallFunction();
+    newCommand.item.setValue("callFunction", aFunction);
+    newCommand.item.setValue("callArguments", aArguments);
+
+    return newCommand;
+}
+
+export {callFunction};
+
+let resolvePromise = function(aValue = null) {
+    let newCommand = new Dbm.commands.ResolvePromise();
+    newCommand.item.setValue("value", aValue);
+
+    return newCommand;
+}
+
+export {resolvePromise};

package/core/BaseObject.js

@@ -0,0 +1,23 @@
+import Dbm from "../index.js";
+
+export default class BaseObject extends Dbm.core.LifeCycleObject {
+
+    _constructProperties() {
+        super._constructProperties();
+        this._item = null;
+    }
+
+    get item() {
+        if(!this._item) {
+            this._item = new Dbm.repository.Item();
+            this._item.setValue("controller", this);
+        }
+        return this._item;
+    }
+
+    setItem(aItem) {
+        this._item = aItem;
+
+        return this;
+    }
+}

package/core/GlobalObject.js

@@ -0,0 +1,18 @@
+import Dbm from "../index.js";
+
+export default class GlobalObject extends Dbm.core.BaseObject {
+    constructor() {
+        super();
+
+        this._repository = new Dbm.repository.Repository();
+        this._nextId = 0;
+    }
+
+    get repository() {
+        return this._repository;
+    }
+
+    getNextId() {
+        return this._nextId++;
+    }
+}

package/core/LifeCycleObject.js

@@ -0,0 +1,25 @@
+import Dbm from "../index.js";
+
+export default class LifeCycleObject {
+    constructor() {
+
+        if(process.env.NODE_ENV === "development") {
+            this._debugId = Math.round(Math.random()*1000000000000);
+        }
+
+        this._constructProperties();
+        this._construct();
+    }
+
+    _constructProperties() {
+
+    }
+
+    _construct() {
+
+    }
+
+    destroy() {
+        //METODO
+    }
+}

package/core/index.js

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

package/dbm.js

@@ -0,0 +1,71 @@
+import {GlobalObject} from "./core/index.js";
+
+if(!globalThis.dbm) {
+    globalThis.dbm = new GlobalObject();
+}
+
+export let getInstance = function() {
+    return globalThis.dbm;
+}
+
+//export {getInstance};
+
+export let objectPath = function(aObject, aPath) {
+    //console.log("objectPath");
+    
+    let currentObject = aObject;
+    
+    aPath += "";
+    if(aPath.length === 0) {
+        return currentObject;
+    }
+    
+    let currentArray = aPath.split(".");
+    let currentArrayLength = currentArray.length;
+    for(let i = 0; i < currentArrayLength; i++) {
+        let currentPathPart = currentArray[0];
+        
+        if(currentObject === null || currentObject === undefined) {
+            break;
+        }
+
+        /*
+        else if(currentPathPart === "(every)") {
+            currentArray.shift();
+            let currentItems = Wprr.utils.array.singleOrArray(currentObject);
+            let returnArray = Wprr.utils.array.mapField(currentItems, currentArray.join("."));
+            return returnArray;
+        }
+        */
+        
+        if(currentPathPart === "(self)") {
+            continue;
+        }
+        else {
+            currentArray.shift();
+            
+            let partAsInt = parseInt(currentPathPart, 10);
+            if(partAsInt.toString() === currentPathPart) {
+                currentObject = currentObject[partAsInt];
+            }
+            else {
+                currentObject = currentObject[currentPathPart];
+            }
+        }
+    }
+    
+    return currentObject;
+}
+
+export * as utils from "./utils/index.js";
+export * as core from "./core/index.js";
+export * as loading from "./loading/index.js";
+export * as react from "./react/index.js";
+export * as repository from "./repository/index.js";
+export * as graphapi from "./graphapi/index.js";
+export * as commands from "./commands/index.js";
+export * as flow from "./flow/index.js";
+export * as updater from "./updater/index.js";
+export * as startup from "./startup/index.js";
+export * as site from "./site/index.js";
+export * as tracking from "./tracking/index.js";

package/flow/DirtyCommands.js

@@ -0,0 +1,45 @@
+import Dbm from "../index.js";
+
+export default class DirtyCommands extends Dbm.flow.FlowBaseObject {
+
+    _constructProperties() {
+        super._constructProperties();
+
+        this.commands = [];
+        this._upstreamConnection = null;
+    }
+
+    get isDirty() {
+        return false;
+    }
+
+    set isDirty(aValue) {
+        if(aValue) {
+            let currentArray = this.commands;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentCommand = currentArray[i];
+                currentCommand.perform(this, null);
+            }
+        }
+    }
+
+    _connection_connectUpstream(aFlowObject) {
+        if(this._upstreamConnection) {
+            //METODO: disconnect old input
+
+        }
+
+        this._upstreamConnection = aFlowObject;
+    }
+
+    destroy() {
+        super.destroy();
+
+        this.commands = [];
+        if(this._upstreamConnection) {
+            //METODO: remove as outgoing
+            this._upstreamConnection = null;
+        }
+    }
+}

package/flow/FlowBaseObject.js

@@ -0,0 +1,78 @@
+import Dbm from "../index.js";
+
+export default class FlowBaseObject extends Dbm.core.LifeCycleObject {
+
+    _constructProperties() {
+        super._constructProperties();
+
+        this._downstreamConnections = [];
+        this.isDirty = false;
+    }
+
+    connectInput(aFlowObject) {
+        this._connection_connectUpstream(aFlowObject);
+        aFlowObject._connection_connectDownstream(this);
+
+        return this;
+    }
+
+    _connection_connectUpstream(aFlowObject) {
+        //MENOTE: should be overridden
+    }
+
+    connectOutput(aFlowObject) {
+        aFlowObject._connection_connectUpstream(this);
+        this._connection_connectDownstream(aFlowObject);
+
+        return this;
+    }
+
+    _connection_connectDownstream(aFlowObject) {
+        this._downstreamConnections.push(aFlowObject);
+        aFlowObject.setAsDirty();
+    }
+
+    _internal_updateFlow() {
+        //MENOTE: should be overridden
+    }
+
+    _internal_setValueInFlow(aValue) {
+        
+    }
+
+    setAsDirty() {
+        this.isDirty = true;
+        this.setDownstreamAsDirty();
+
+        return this;
+    }
+
+    setDownstreamAsDirty() {
+        //console.log("setDownstreamAsDirty");
+        //console.log(this);
+
+        let currentArray = [];
+        this.collectAndMarkDownstreamConnectionsAsDirty(currentArray);
+        for(let i = 0; i < currentArray.length; i++) { //MENOTE: length increases in the loop
+            let currentFlowObject = currentArray[i];
+            //console.log(currentFlowObject);
+            currentFlowObject.collectAndMarkDownstreamConnectionsAsDirty(currentArray);
+        }
+
+        return this;
+    }
+
+    collectAndMarkDownstreamConnectionsAsDirty(aReturnArray) {
+        //console.log("collectAndMarkDownstreamConnectionsAsDirty");
+
+        let currentArray = this._downstreamConnections;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentConenction = currentArray[i];
+            if(!currentConenction.isDirty) {
+                currentConenction.isDirty = true;
+                aReturnArray.push(currentConenction);
+            }
+        }
+    }
+}

package/flow/FlowProperty.js

@@ -0,0 +1,146 @@
+import Dbm from "../index.js";
+
+export default class FlowProperty extends Dbm.flow.FlowBaseObject {
+
+    _constructProperties() {
+        super._constructProperties();
+
+        this._value = null;
+        
+        this._upstreamConnection = null;
+        
+    }
+
+    get isFlowProperty() {
+        return true;
+    }
+
+    setValue(aValue) {
+        if(this._upstreamConnection) {
+            //METODO: add warning
+            //METODO: check if upstream can be changed
+        }
+        else {
+            if(aValue !== this._value) {
+                this._value = aValue;
+                this.isDirty = false;
+                this.setDownstreamAsDirty();
+            }
+        }
+
+        return this;
+    }
+
+    setOrConnect(aValueOrProperty) {
+        if(aValueOrProperty && aValueOrProperty.isFlowProperty) {
+            this.connectInput(aValueOrProperty);
+        }
+        else {
+            this.setValue(aValueOrProperty);
+        }
+
+        return this;
+    }
+
+    animateValue(aToValue, aTime = 0.5, aDelay = 0, aEasing = null) {
+        Dbm.getInstance().repository.getItem("propertyUpdater").controller.animateProperty(this, aToValue, aTime, aDelay, aEasing);
+
+        return this;
+    }
+
+    getMostUpstreamProperty() {
+
+        let debugCounter = 0;
+
+        let currentProperty = this;
+        while(currentProperty._upstreamConnection) {
+            if(debugCounter++ > 10000) {
+                console.error("Loop ran for too long");
+                return null;
+            }
+            currentProperty = currentProperty._upstreamConnection;
+        }
+        return currentProperty;
+    }
+
+    _connection_connectUpstream(aFlowObject) {
+        if(this._upstreamConnection) {
+            //METODO: disconnect old input
+
+        }
+
+        this._upstreamConnection = aFlowObject;
+    }
+
+    _internal_setValueInFlow(aValue) {
+        this._value = aValue;
+        this.isDirty = false;
+    }
+
+    _internal_setValueInFlowOutsideOfUpdate(aValue) {
+        if(aValue !== this._value) {
+            this._value = aValue;
+            this.isDirty = false;
+            this.setDownstreamAsDirty();
+        }
+    }
+
+    set value(aValue) {
+        this.setValue(aValue);
+    }
+
+    get value() {
+
+        this.updateFlow();
+        
+        return this._value;
+    }
+
+    updateFlow() {
+        //console.log("updateFlow");
+        if(this.isDirty) {
+            if(this._upstreamConnection) {
+                this._upstreamConnection._internal_updateFlow();
+            }
+            else {
+                this.isDirty = false;
+            }
+        }
+
+        return this;
+    }
+
+    getValueWithoutFlow() {
+        return this._value;
+    }
+
+    _internal_updateFlow() {
+        let newValue = this.value;
+        let currentArray = this._downstreamConnections;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentConnection = currentArray[i];
+            currentConnection._internal_setValueInFlow(newValue);
+        }
+    }
+
+    startUpdating() {
+        Dbm.getInstance().repository.getItem("propertyUpdater").controller.addProperty(this);
+        return this;
+    }
+
+    stopUpdating() {
+        Dbm.getInstance().repository.getItem("propertyUpdater").controller.removeProperty(this);
+        return this;
+    }
+
+    destroy() {
+        super.destroy();
+
+        this._value = null;
+        if(this._upstreamConnection) {
+            //METODO: remove as outgoing
+            this._upstreamConnection = null;
+        }
+    }
+}

package/flow/FlowUpdateFunction.js

@@ -0,0 +1,39 @@
+import Dbm from "../index.js";
+
+export default class FlowUpdateFunction extends Dbm.flow.FlowBaseObject {
+
+    _constructProperties() {
+        super._constructProperties();
+        
+        this._upstreamConnections = [];
+        this.input = (new Dbm.flow.UpdateFunctionInputs()).setOwner(this);
+        this.output = (new Dbm.flow.UpdateFunctionOutputs()).setOwner(this);
+    }
+
+    _connection_connectUpstream(aFlowObject) {
+        this._upstreamConnections.push(aFlowObject);
+    }
+
+    _internal_updateFlow() {
+        //console.log("_internal_updateFlow");
+        
+        let shouldUpdate = this.input.updateValues();
+
+        try {
+            if(shouldUpdate) {
+                this._update();
+            }
+            else {
+                this.output.markAsClean();
+            }
+            this.isDirty = false;
+        }
+        catch(theError) {
+            console.error(theError);
+        }
+    }
+
+    _update() {
+        //MENOTE: should be overridden
+    }
+}

package/flow/UpdateFunctionInputs.js

@@ -0,0 +1,58 @@
+import Dbm from "../index.js";
+
+export default class UpdateFunctionInputs extends Dbm.core.LifeCycleObject {
+
+    _constructProperties() {
+        super._constructProperties();
+
+        this.properties = {};
+        this._cachedValues = [];
+        this._owner = null;
+    }
+
+    setOwner(aOwner) {
+
+        this._owner = aOwner;
+
+        return this;
+    }
+
+    register(aName, aInitialValue = null) {
+        if(!this.properties.hasOwnProperty(aName)) {
+            let property = new Dbm.flow.FlowProperty();
+            property.value = aInitialValue;
+            this._owner.connectInput(property);
+
+            Object.defineProperty(this, aName, {
+                get() {
+                    return property.value;
+                },
+                set(aValue) {
+                    property.value = aValue;
+                }
+            });
+
+            let cacheObject = {"value": aInitialValue, "property": property};
+            this.properties[aName] = property;
+            this._cachedValues.push(cacheObject);
+        }
+
+        return this.properties[aName];
+    }
+
+    updateValues() {
+        let needsToUpdate = false;
+        let currentArray = this._cachedValues;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentCache = currentArray[i];
+            let newValue = currentCache.property.value;
+            if(newValue !== currentCache.value) {
+                currentCache.value = newValue;
+                needsToUpdate = true;
+            }
+        }
+
+        return needsToUpdate;
+    }
+}

package/flow/UpdateFunctionOutputs.js

@@ -0,0 +1,51 @@
+import Dbm from "../index.js";
+
+export default class UpdateFunctionOutputs extends Dbm.core.LifeCycleObject {
+
+    _constructProperties() {
+        super._constructProperties();
+
+        this.properties = {};
+        this._propertiesList = [];
+        this._owner = null;
+
+    }
+
+    setOwner(aOwner) {
+
+        this._owner = aOwner;
+
+        return this;
+    }
+
+    register(aName, aInitialValue = null) {
+        if(!this.properties.hasOwnProperty(aName)) {
+            let property = new Dbm.flow.FlowProperty();
+            property.value = aInitialValue;
+            this._owner.connectOutput(property);
+
+            Object.defineProperty(this, aName, {
+                get() {
+                    return property.value;
+                },
+                set(aValue) {
+                    property._internal_setValueInFlow(aValue);
+                }
+            });
+
+            this.properties[aName] = property;
+            this._propertiesList.push(property);
+        }
+
+        return this.properties[aName];
+    }
+
+    markAsClean() {
+        let currentArray = this._propertiesList;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentProperty = currentArray[i];
+            currentProperty.isDirty = false;
+        }
+    }
+}

package/flow/index.js

@@ -0,0 +1,40 @@
+import Dbm from "../index.js";
+
+export {default as FlowBaseObject} from "./FlowBaseObject.js";
+export {default as FlowProperty} from "./FlowProperty.js";
+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 * as updatefunctions from "./updatefunctions/index.js";
+
+export let addUpdateCommand = function(aProperty, aCommand) {
+    let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
+    updateFunction.input.properties.value.connectInput(aProperty);
+    updateFunction.input.command = aCommand;
+    updateFunction.noFirstTriggger();
+    
+    let updatePropertyCommand = Dbm.commands.callFunction(Dbm.getInstance().repository.getItem("propertyUpdater").controller.addSinglePropertyUpdateBound, [updateFunction.output.properties.value]);
+
+    let dirtyCommands = new Dbm.flow.DirtyCommands();
+    updateFunction.output.properties.value.connectOutput(dirtyCommands);
+    dirtyCommands.commands.push(updatePropertyCommand);
+
+    return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
+}
+
+export let addDirectUpdateCommand = function(aProperty, aCommand) {
+    let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
+    updateFunction.input.properties.value.connectInput(aProperty);
+    updateFunction.input.command = aCommand;
+    updateFunction.noFirstTriggger();
+    
+    let updatePropertyCommand = Dbm.commands.callFunction(updateFunction.output.properties.value.updateFlow.bind(updateFunction.output.properties.value), []);
+
+    let dirtyCommands = new Dbm.flow.DirtyCommands();
+    updateFunction.output.properties.value.connectOutput(dirtyCommands);
+    dirtyCommands.commands.push(updatePropertyCommand);
+    
+    return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
+}