dbm 1.2.0 → 1.2.2

package/core/source/FirstSource.js

@@ -0,0 +1,36 @@
+import Dbm from "../../index.js";
+
+export default class FirstSource extends Dbm.core.source.SourceBaseObject {
+	
+    _construct() {
+        super._construct();
+
+        this.item.setValue("defaultValue", null);
+        this.item.setValue("sources", []);
+    }
+	
+	getSource(aFromObject, aEventData = null) {
+        //console.log("getSource");
+        
+        let currentArray = this.item.sources;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentSource = currentArray[i];
+
+            let value = currentSource.getSource(aFromObject, aEventData);
+            if(this._log) {
+                console.log("Source first>>>>>", i, currentSource, value);
+            }
+
+            if(value) {
+                return value;
+            }
+        }
+
+        if(this._log) {
+            console.log("Source first>>>>> default", this.item.defaultValue);
+        }
+        
+        return this.item.defaultValue;
+    }
+}

package/core/source/index.js

@@ -4,6 +4,7 @@ export {default as SourceBaseObject} from "./SourceBaseObject.js";
 export {default as EventSource} from "./EventSource.js";
 export {default as FromObject} from "./FromObject.js";
 export {default as StaticSource} from "./StaticSource.js";
+export {default as FirstSource} from "./FirstSource.js";
 
 export const event = function(aPath = null) {
 	let newSource = new Dbm.core.source.EventSource();
@@ -29,3 +30,23 @@ export const staticObject = function(aObject, aPath = null) {
 	
 	return newSource;
 }
+
+export const first = function(...aSources) {
+	let newSource = new Dbm.core.source.FirstSource();
+	
+	newSource.item.sources = [].concat(aSources);
+	
+	return newSource;
+}
+
+export const firstWithDefault = function(...aSourcesAndDefault) {
+	let newSource = new Dbm.core.source.FirstSource();
+
+	let sources = [].concat(aSourcesAndDefault);
+	let defaultValue = sources.pop();
+	
+	newSource.item.sources = sources;
+	newSource.item.properties.defaultValue.setOrConnect(defaultValue);
+	
+	return newSource;
+}

package/dbm.js

@@ -85,6 +85,14 @@ export const setAtObjectPath = function(aObject, aPath, aValue) {
     }
 }
 
+export const getRepositoryItem = function(aName) {
+    return getInstance().repository.getItem(aName);
+}
+
+export const getGraphApi = function() {
+    return getRepositoryItem("graphApi").controller;
+}
+
 export * as utils from "./utils/index.js";
 export * as core from "./core/index.js";
 export * as loading from "./loading/index.js";

package/flow/controllers/index.js

@@ -1,4 +1,5 @@
 export * as select from "./select/index.js";
 export * as edit from "./edit/index.js";
 export * as transform from "./transform/index.js";
-export * as interaction from "./interaction/index.js";
+export * as interaction from "./interaction/index.js";
+export * as timing from "./timing/index.js";

package/flow/controllers/select/InArray.js

@@ -0,0 +1,67 @@
+import Dbm from "../../../index.js";
+
+export default class InArray extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        let valuesUpdatedCommand = Dbm.commands.callFunction(this._valuesUpdated.bind(this));
+
+        this._selectionChangedBound = this._selectionChanged.bind(this);
+
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("values", null), valuesUpdatedCommand);
+        this.item.requireProperty("selections", []);
+
+    }
+
+    getSelectionForValue(aValue) {
+        let selections = this.item.selections;
+        let currentSelection = Dbm.utils.ArrayFunctions.getItemBy(selections, "value", aValue);
+
+        if(!currentSelection) {
+            let selections = [].concat(this.item.selections);
+            let property = new Dbm.flow.FlowProperty();
+            property.setValue(false);
+            Dbm.flow.addUpdateCommand(property, Dbm.commands.callFunction(this._selectionChangedBound, [property, aValue]));
+
+            currentSelection = {"value": aValue, "property": property};
+            selections.push(currentSelection);
+            this.item.selections = selections;
+        }
+
+        return currentSelection.property;
+    }
+
+    _selectionChanged(aSelected, aValue) {
+        console.log("_selectionChanged");
+
+        let newValues = [].concat(this.item.values);
+        if(aSelected) {
+            newValues.push(aValue);
+        }
+        else {
+            let index = newValues.indexOf(aValue);
+            if(index >= 0) {
+                newValues.splice(index, 1);
+            }
+        }
+
+        this.item.properties.values.getMostUpstreamProperty().setValue(newValues);
+    }
+
+    _valuesUpdated() {
+        //console.log("_valuesUpdated");
+        let values = this.item.values;
+
+        let currentArray = this.item.selections;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentSelection = currentArray[i];
+            if(values.indexOf(currentSelection.value) !== -1) {
+                currentSelection.property.getMostUpstreamProperty().setValue(true);
+            }
+            else {
+                currentSelection.property.getMostUpstreamProperty().setValue(false);
+            }
+        }
+    }
+}

package/flow/controllers/select/index.js

@@ -1 +1,2 @@
-export {default as SingleSelection} from "./SingleSelection.js";
+export {default as SingleSelection} from "./SingleSelection.js";
+export {default as InArray} from "./InArray.js";

package/flow/controllers/timing/IntervalStep.js

@@ -0,0 +1,60 @@
+import Dbm from "../../../index.js";
+
+export default class IntervalStep extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("value", 0);
+        this.item.requireProperty("step", 1);
+        Dbm.flow.addUpdateCommand(this.item.requireProperty("interval", 1), Dbm.commands.callFunction(this.resetInterval.bind(this)));
+
+        this._started = false;
+        this._intervalId = -1;
+        this._callback_nextStepBound = this._callback_nextStep.bind(this);
+    }
+
+    start() {
+        this._started = true;
+        this._startInterval();
+
+        return this;
+    }
+
+    stop() {
+        this._started = false;
+        this._stopInterval();
+
+        return this;
+    }
+
+    setValue(aValue) {
+        this.item.properties.value.getMostUpstreamProperty().value = aValue;
+        this.resetInterval();
+
+        return this;
+    }
+
+    _callback_nextStep() {
+        this.item.properties.value.getMostUpstreamProperty().value += this.item.step;
+    }
+
+    _startInterval() {
+        if(this._intervalId === -1) {
+            this._intervalId = setInterval(this._callback_nextStepBound, this.item.interval*1000);
+        }
+    }
+
+    _stopInterval() {
+        if(this._intervalId !== -1) {
+            clearInterval(this._intervalId);
+            this._intervalId = -1;
+        }
+    }
+
+    resetInterval() {
+        if(this._started) {
+            this._stopInterval();
+            this._startInterval();
+        }
+    }
+}

package/flow/controllers/timing/index.js

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

package/flow/index.js

@@ -11,7 +11,7 @@ export {default as FlowPropertyWithExternalInput} from "./FlowPropertyWithExtern
 export * as updatefunctions from "./updatefunctions/index.js";
 export * as controllers from "./controllers/index.js";
 
-export let addUpdateCommand = function(aProperty, aCommand) {
+export const addUpdateCommand = function(aProperty, aCommand) {
     let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
     updateFunction.input.properties.value.connectInput(aProperty);
     updateFunction.input.command = aCommand;
@@ -26,7 +26,7 @@ export let addUpdateCommand = function(aProperty, aCommand) {
     return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
 }
 
-export let addDirectUpdateCommand = function(aProperty, aCommand) {
+export const addDirectUpdateCommand = function(aProperty, aCommand) {
     let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
     updateFunction.input.properties.value.connectInput(aProperty);
     updateFunction.input.command = aCommand;
@@ -41,7 +41,7 @@ export let addDirectUpdateCommand = function(aProperty, aCommand) {
     return {"updateFunction": updateFunction, "dirtyCommands": dirtyCommands};
 }
 
-export let addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
+export const addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aCommand) {
 	let whenMatched = Dbm.flow.updatefunctions.logic.whenMatched(aProperty, aMatchValue);
 	
 	let updateData = Dbm.flow.addUpdateCommand(whenMatched.output.properties.value, aCommand);
@@ -51,6 +51,16 @@ export let addUpdateCommandWhenMatched = function(aProperty, aMatchValue, aComma
 	return whenMatched;
 }
 
+export const runWhenMatched = function(aProperty, aMatchValue, aCommand) {
+    if(aProperty.value === aMatchValue) {
+        aCommand.perform(null, null);
+
+        return null;
+    }
+    
+    return addUpdateCommandWhenMatched(aProperty, aMatchValue, aCommand);
+}
+
 export const animateValue = function(aValue, aTime = 0.5, aEasing = null) {
 	
 	let returnObject = new Dbm.repository.Item();

package/flow/updatefunctions/animation/AnimateValue.js

@@ -0,0 +1,39 @@
+import Dbm from "../../../index.js";
+
+export default class AnimateValue extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+
+		this._animationInputValue = new Dbm.flow.FlowProperty();
+		this._animationInputValue.value = 0;
+		Dbm.flow.addUpdateCommand(this._animationInputValue, Dbm.commands.callFunction(this._updateAnimation.bind(this)));
+
+		this._animatedValue = new Dbm.flow.FlowProperty();
+		this._animatedValue.value = 0;
+		Dbm.flow.addUpdateCommand(this._animatedValue, Dbm.commands.callFunction(this._animationUpdated.bind(this)));
+        
+        this.input.register("value", 0);
+		this._animationInputValue.connectInput(this.input.properties.value);
+		this.input.register("time", 0.5);
+		this.input.register("easing", null);
+		this.input.register("delay", 0);
+		this.output.register("value", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        //this._animationInputValue.value = this.input.value;
+    }
+
+	_updateAnimation() {
+		//console.log("_updateAnimation");
+		this._animatedValue.animateValue(this._animationInputValue.value, this.input.time, this.input.delay, this.input.easing);
+	}
+
+	_animationUpdated() {
+		//console.log("_animationUpdated");
+		this.output.properties.value._internal_setValueInFlowOutsideOfUpdate(this._animatedValue.value);
+	}
+}

package/flow/updatefunctions/animation/index.js

@@ -0,0 +1,13 @@
+import Dbm from "../../../index.js";
+
+export {default as AnimateValue} from "./AnimateValue.js";
+
+export let animateValue = function(aValue = 0, aTime = 0.5, aDelay = 0, aEasing = null) {
+    let updateFunction = new Dbm.flow.updatefunctions.animation.AnimateValue();
+    updateFunction.input.properties.value.setOrConnect(aValue);
+    updateFunction.input.properties.time.setOrConnect(aTime);
+    updateFunction.input.properties.delay.setOrConnect(aDelay);
+    updateFunction.input.properties.easing.setOrConnect(aEasing);
+
+    return updateFunction;
+}

package/flow/updatefunctions/basic/MappedList.js

@@ -0,0 +1,49 @@
+import Dbm from "../../../index.js";
+
+export default class MappedList extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("items", []);
+        this.input.register("itemReferenceName", "forItem");
+        this.input.register("newItemCommands", []);
+
+        this.output.register("items", []);
+    }
+
+    _update() {
+        console.log("MappedList::_update");
+
+        let currentArray = this.input.items;
+        let currentArrayLength = currentArray.length;
+
+        let itemReferenceName = this.input.itemReferenceName;
+        let newItemCommands = this.input.newItemCommands;
+
+        let currentMappedList = this.output.properties.items.getValueWithoutFlow();
+
+        let returnArray = new Array(currentArrayLength);
+        for(let i = 0; i < currentArrayLength; i++) {
+            let currentItem = currentArray[i];
+
+            let index = Dbm.utils.ArrayFunctions.getItemIndexByIfExists(currentMappedList, itemReferenceName, currentItem);
+
+            if(index !== -1) {
+                returnArray[i] = currentMappedList[index];
+                currentMappedList.splice(index, 1);
+            }
+            else {
+                let newItem = new Dbm.repository.Item();
+                newItem.setId("mapped_" + Dbm.getInstance().getNextId());
+                newItem.setValue(itemReferenceName, currentItem);
+                Dbm.commands.performCommands(newItemCommands, this, {"mappedItem": newItem, "item": currentItem, "itemReferenceName": itemReferenceName});
+                returnArray[i] = newItem;
+            }
+
+            //METODO: clean up unused items
+        }
+
+        this.output.items = returnArray;
+    }
+}

package/flow/updatefunctions/basic/PropertyOf.js

@@ -1,6 +1,6 @@
 import Dbm from "../../../index.js";
 
-export default class Length extends Dbm.flow.FlowUpdateFunction {
+export default class PropertyOf extends Dbm.flow.FlowUpdateFunction {
 
     _construct() {
         super._construct();

package/flow/updatefunctions/basic/PropertyOfWithDefault.js

@@ -0,0 +1,28 @@
+import Dbm from "../../../index.js";
+
+export default class PropertyOfWithDefault extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", "");
+        this.input.register("propertyName", "");
+        this.input.register("defaultValue", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let value = this.input.value;
+
+        let outputValue = Dbm.objectPath(value, this.input.propertyName);
+
+        if(!outputValue) {
+            outputValue = this.input.defaultValue;
+        }
+        
+        this.output.value = outputValue
+    }
+}

package/flow/updatefunctions/basic/Translation.js

@@ -0,0 +1,71 @@
+import Dbm from "../../../index.js";
+
+export default class Translation extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("translations", {});
+        this.input.register("path", null);
+        this.input.register("additionalPath", null);
+        this.input.register("id", "");
+        this.input.register("defaultValue", null);
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let translations = this.input.translations;
+
+        let path = this.input.path;
+        let additionalPath = this.input.additionalPath;
+        let id = this.input.id;
+
+        while(path) {
+
+            let currentAdditionalPath = additionalPath;
+            while(currentAdditionalPath) {
+
+                let currentValue = translations[path + "/" + currentAdditionalPath + "/" + id];
+                if(currentValue) {
+                    this.output.value = currentValue;
+                    return;
+                }
+
+                let nextIndex = currentAdditionalPath.lastIndexOf("/");
+                if(nextIndex >= 0) {
+                    currentAdditionalPath = currentAdditionalPath.substring(0, nextIndex);
+                }
+                else {
+                    currentAdditionalPath = null;
+                }
+            }
+
+            let currentValue = translations[path + "/" + id];
+            if(currentValue) {
+                this.output.value = currentValue;
+                return;
+            }
+
+            let nextIndex = path.lastIndexOf("/");
+            if(nextIndex >= 0) {
+                path = path.substring(0, nextIndex);
+            }
+            else {
+                path = null;
+            }
+        }
+        
+       let currentValue = translations[id];
+        if(currentValue) {
+            this.output.value = currentValue;
+            return;
+        }
+
+        //METODO: report missing translation
+
+        this.output.value = this.input.defaultValue;
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -4,6 +4,9 @@ export {default as RunCommand} from "./RunCommand.js";
 export {default as CombineString} from "./CombineString.js";
 export {default as Length} from "./Length.js";
 export {default as PropertyOf} from "./PropertyOf.js";
+export {default as PropertyOfWithDefault} from "./PropertyOfWithDefault.js";
+export {default as MappedList} from "./MappedList.js";
+export {default as Translation} from "./Translation.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -34,6 +37,15 @@ export const propertyOf = function(aValue, aPropertyName) {
 	return updateFunction;
 }
 
+export const propertyOfWithDefault = function(aValue, aPropertyName, aDefaultValue) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.PropertyOfWithDefault();
+	updateFunction.input.properties.value.setOrConnect(aValue);
+	updateFunction.input.properties.propertyName.setOrConnect(aPropertyName);
+	updateFunction.input.properties.defaultValue.setOrConnect(aDefaultValue);
+	
+	return updateFunction;
+}
+
 export const combine = function(...aValues) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.CombineString();
 	
@@ -46,4 +58,69 @@ export const combine = function(...aValues) {
 	
 	
 	return updateFunction;
+}
+
+export const mappedList = function(aItems, aNewItemCommands = []) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.MappedList();
+	updateFunction.input.properties.items.setOrConnect(aItems);
+	updateFunction.input.properties.newItemCommands.setOrConnect(aNewItemCommands);
+
+	return updateFunction;
+}
+
+export const mappedListWithFunction = function(aItems, aNewItemFunction) {
+	let command = Dbm.commands.callFunction(aNewItemFunction, [Dbm.core.source.event("mappedItem"), Dbm.core.source.fromObject()]);
+
+	return mappedList(aItems, [command]);
+}
+
+
+
+export const activeMappedList = function(aItems, aActiveFromStart = false) {
+
+	let item = new Dbm.repository.Item();
+
+	item.requireProperty("items", []).setOrConnect(aItems);
+	item.requireProperty("activeItems", []);
+	item.requireProperty("selectionItems", []);
+
+	let activeItems = new Dbm.flow.controllers.select.InArray();
+
+	let createActiveField = function(aItem, aUpdateFunction) {
+		let activeProperty = aItem.requireProperty("active", aUpdateFunction.activeFromStart);
+		let inArrayProperty = activeItems.getSelectionForValue(aItem[aUpdateFunction.input.itemReferenceName]);
+		inArrayProperty.connectInput(activeProperty);
+	}
+
+	let updateFunction = mappedListWithFunction(item.properties.items, createActiveField);
+	updateFunction.activeFromStart = aActiveFromStart;
+	item.setValue("mappedList", updateFunction);
+	item.properties.selectionItems.connectInput(updateFunction.output.properties.items);
+
+	activeItems.item.properties.values.connectInput(item.properties.activeItems);
+	item.setValue("inArray", activeItems);
+
+	return item;
+}
+
+export const translation = function(aId, aDefaultValue = null, aPath = null, aAdditionalPath = null, aTranslations = null) {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.Translation();
+
+	updateFunction.input.properties.id.setOrConnect(aId);
+	updateFunction.input.properties.defaultValue.setOrConnect(aDefaultValue);
+	updateFunction.input.properties.path.setOrConnect(aPath);
+	updateFunction.input.properties.additionalPath.setOrConnect(aAdditionalPath);
+
+	if(!aTranslations) {
+		aTranslations = Dbm.getRepositoryItem("site/translations").requireProperty("data");
+	}
+	updateFunction.input.properties.translations.setOrConnect(aTranslations);
+
+	return updateFunction;
+}
+
+export const translationProperty = function(aId, aDefaultValue = null, aPath = null, aAdditionalPath = null, aTranslations = null) {
+	let updateFunction = translation(aId, aDefaultValue, aPath, aAdditionalPath, aTranslations);
+
+	return updateFunction.output.properties.value;
 }

package/flow/updatefunctions/index.js

@@ -3,4 +3,5 @@ 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";
+export * as animation from "./animation/index.js";
 export * as thirdparty from "./thirdparty/index.js";

package/flow/updatefunctions/logic/FloatMod.js

@@ -0,0 +1,26 @@
+import Dbm from "../../../index.js";
+
+export default class FloatMod extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("input", 0);
+        this.input.register("min", 0);
+        this.input.register("max", 1);
+
+        this.output.register("result", 0);
+    }
+
+    _update() {
+        //console.log("_update");
+
+        let relativeValue = this.input.input-this.input.min;
+        let length = this.input.max-this.input.min;
+
+        let times = Math.floor(relativeValue/length);
+        let clampledValue = relativeValue-(length*times);
+
+        this.output.result = this.input.min+clampledValue;
+    }
+}

package/flow/updatefunctions/logic/PositionedItems.js

@@ -1,6 +1,6 @@
 import Dbm from "../../../index.js";
 
-export default class PoisitonedItems extends Dbm.flow.FlowUpdateFunction {
+export default class PositionedItems extends Dbm.flow.FlowUpdateFunction {
 
     _construct() {
         super._construct();

package/flow/updatefunctions/logic/index.js

@@ -12,6 +12,7 @@ export {default as AllAtValue} from "./AllAtValue.js";
 export {default as WhenMatched} from "./WhenMatched.js";
 export {default as Invert} from "./Invert.js";
 export {default as PositionedItems} from "./PositionedItems.js";
+export {default as FloatMod} from "./FloatMod.js";
 
 export let subtract = function(aInput1 = 0, aInput2 = 0) {
     let updateFunction = new Dbm.flow.updatefunctions.logic.Subtraction();
@@ -111,5 +112,22 @@ export let switchValue = function(aValue = null) {
     let updateFunction = new Dbm.flow.updatefunctions.logic.Switch();
     updateFunction.input.properties.value.setOrConnect(aValue);
 	
+	return updateFunction;
+}
+
+export let floatMod = function(aValue = null, aMax = 1) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.FloatMod();
+    updateFunction.input.properties.input.setOrConnect(aValue);
+    updateFunction.input.properties.max.setOrConnect(aMax);
+	
+	return updateFunction;
+}
+
+export let floatModRange = function(aValue = null, aMin = 0, aMax = 1) {
+    let updateFunction = new Dbm.flow.updatefunctions.logic.FloatMod();
+    updateFunction.input.properties.input.setOrConnect(aValue);
+    updateFunction.input.properties.min.setOrConnect(aMin);
+    updateFunction.input.properties.max.setOrConnect(aMax);
+	
 	return updateFunction;
 }

package/flow/updatefunctions/thirdparty/google/index.js

@@ -0,0 +1,3 @@
+import Dbm from "../../../../index.js";
+
+export * as maps from "./maps/index.js";