dbm 1.4.10 → 1.4.13

package/commands/index.js

@@ -61,6 +61,12 @@ export const performCommands = function(aCommands, aFromObject = null, aEventDat
     let currentArrayLength = currentArray.length;
     for(let i = 0; i < currentArrayLength; i++) {
         let currentCommand = currentArray[i];
+
+        if(currentCommand && currentCommand.isSource) {
+            currentCommand = currentCommand.getSource(aFromObject);
+        }
+        //METODO: add flow property
+
         try {
             currentCommand.perform(aFromObject, aEventData);
         }

package/css/all.css

@@ -5,4 +5,5 @@
 @import './rows.css';
 @import './icons.css';
 @import './tags.css';
-@import './elements.css';
+@import './elements.css';
+@import './text.css';

package/css/tags.css

@@ -107,8 +107,17 @@
     overflow: hidden;
 }
 
-.standard-tag-list .standard-tag-list-item{
+.standard-tag-list .standard-tag-list-item {
     float: left;
     margin-right: var(--standard-tag-list-horizontal-margin, 10px);
     margin-bottom: var(--standard-tag-list-vertical-margin, 5px);
+}
+
+.option {
+    cursor: pointer;
+}
+
+.option.selected {
+    background-color: var(--standard-tag-option-selected-background-color, #555555);
+    color: var(--standard-tag-option-selected-text-color, #ffffff);
 }

package/css/text.css

@@ -0,0 +1,4 @@
+.small-description {
+    font-size: 12px;
+    color: #828282;
+}

package/flow/FlowProperty.js

@@ -48,18 +48,31 @@ export default class FlowProperty extends Dbm.flow.FlowBaseObject {
         return this;
     }
 
-    addAddionalAnimation(aFromValue, aToValue, aTime = 0.5, aDelay = 0, aEasing = null) {
+    addAdditionalAnimation(aFromValue, aToValue, aTime = 0.5, aDelay = 0, aEasing = null) {
         Dbm.getInstance().repository.getItem("propertyUpdater").controller.addPropertyAnimation(this, aFromValue, aToValue, aTime, aDelay, aEasing);
 
         return this;
     }
 
+    addAddionalAnimation(aFromValue, aToValue, aTime = 0.5, aDelay = 0, aEasing = null) {
+        //METODO: warning message
+        this.addAdditionalAnimation(aFromValue, aToValue, aTime, aDelay, aEasing);
+
+        return this;
+    }
+
     delayValue(aToValue, aDelay = 0) {
         Dbm.getInstance().repository.getItem("propertyUpdater").controller.delayUpdateProperty(this, aToValue, aDelay);
 
         return this;
     }
 
+    addDelayValue(aToValue, aDelay = 0) {
+        Dbm.getInstance().repository.getItem("propertyUpdater").controller.addDelayUpdateProperty(this, aToValue, aDelay);
+
+        return this;
+    }
+
     getMostUpstreamProperty() {
 
         let debugCounter = 0;

package/flow/index.js

@@ -92,4 +92,32 @@ export const externalObject = function(aObject) {
     returnObject.item.properties.object.setOrConnect(aObject);
 
     return returnObject;
+}
+
+export const dynamicUpdateFunction = function(aFunction, aInputs = {}, aOutputs = {}) {
+
+    let inputs = {...aInputs};
+    let outputs = {...aOutputs};
+
+    let TheClass = class DynamicUpdateFunction extends Dbm.flow.FlowUpdateFunction {
+        _construct() {
+            super._construct();
+
+            for(let objectName in inputs) {
+                this.input.register(objectName, inputs[objectName]);
+            }
+
+            for(let objectName in outputs) {
+                this.output.register(objectName, outputs[objectName]);
+            }
+        }
+
+        _update() {
+            //MENOTE: dynamically replaced
+        }
+    }
+
+    TheClass.prototype._update = aFunction;
+
+    return new TheClass();
 }

package/flow/updatefunctions/basic/GetItemBy.js

@@ -0,0 +1,20 @@
+import Dbm from "../../../index.js";
+
+export default class GetItemBy extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("value", null);
+        this.input.register("items", []);
+        this.input.register("path", "id");
+
+        this.output.register("value", null);
+    }
+
+    _update() {
+        //console.log("GetItemBy::_update");
+        
+        this.output.value = Dbm.utils.ArrayFunctions.getItemBy(this.input.items, this.input.path, this.input.value);
+    }
+}

package/flow/updatefunctions/basic/index.js

@@ -8,6 +8,7 @@ export {default as PropertyOfWithDefault} from "./PropertyOfWithDefault.js";
 export {default as MappedList} from "./MappedList.js";
 export {default as Translation} from "./Translation.js";
 export {default as SetProperty} from "./SetProperty.js";
+export {default as GetItemBy} from "./GetItemBy.js";
 
 export const runCommand = function(aValue, aCommand) {
 	let updateFunction = new Dbm.flow.updatefunctions.basic.RunCommand();
@@ -134,5 +135,16 @@ export const setProperty = function(aObject, aPropertyName, aValue = null) {
 	properties.object.setOrConnect(aObject);
 	properties.propertyName.setOrConnect(aPropertyName);
 
+	return updateFunction;
+}
+
+export const getItemBy = function(aItems, aValue, aPath = "id") {
+	let updateFunction = new Dbm.flow.updatefunctions.basic.GetItemBy();
+
+	let properties = updateFunction.input.properties;
+	properties.value.setOrConnect(aValue);
+	properties.items.setOrConnect(aItems);
+	properties.path.setOrConnect(aPath);
+
 	return updateFunction;
 }

package/flow/updatefunctions/dom/WindowSize.js

@@ -0,0 +1,33 @@
+import Dbm from "../../../index.js";
+
+export default class WindowSize extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+
+        this.output.register("width", window.innerWidth);
+        this.output.register("height", window.innerHeight);
+
+        this._callback_sizeChangedBound = this._callback_sizeChanged.bind(this);
+    }
+
+    start() {
+        window.addEventListener("resize", this._callback_sizeChangedBound, false);
+
+        return this;
+    }
+
+    _update() {
+        //console.log("_update");
+
+        this.output.width = window.innerWidth;
+        this.output.height = window.innerHeight;
+    }
+
+    _callback_sizeChanged(aEvent) {
+        //console.log("_callback_sizeChanged");
+
+        this.output.properties.width._internal_setValueInFlowOutsideOfUpdate(window.innerWidth);
+        this.output.properties.height._internal_setValueInFlowOutsideOfUpdate(window.innerHeight);
+    }
+}

package/flow/updatefunctions/dom/index.js

@@ -2,4 +2,5 @@ export {default as ElementSize} from "./ElementSize.js";
 export {default as StyleObject} from "./StyleObject.js";
 export {default as HorizontalFlip} from "./HorizontalFlip.js";
 export {default as ElementPosition} from "./ElementPosition.js";
-export {default as TransformStyle} from "./TransformStyle.js";
+export {default as TransformStyle} from "./TransformStyle.js";
+export {default as WindowSize} from "./WindowSize.js";

package/flow/updatefunctions/logic/Condition.js

@@ -17,13 +17,13 @@ export default class Condition extends Dbm.flow.FlowUpdateFunction {
 
         let operation = this.input.operation;
         if(typeof(operation) === "string") {
-            if(operation === "!==") {
-                operation = function(aA, aB) {return aA !== aB;}
-            }
-            else {
-                //METODO: add more operations
-                operation = function(aA, aB) {return aA === aB;}
+            let compareFunction = Dbm.getInstance().repository.getItem("compareFunctions/" + operation).compare;
+            if(!compareFunction) {
+                console.warn("No copmare function registered for: " + operation + ". Using ==", this);
+                compareFunction = Dbm.utils.CompareFunctions.equals;
             }
+
+            operation = compareFunction
         }
 
         this.output.result = operation.call(this, this.input.input1, this.input.input2);

package/graphapi/webclient/index.js

@@ -65,4 +65,16 @@ export const performAction = function(aType, aData, aCallback = null) {
     }
     
     return request.properties.data;
+}
+
+export const loadRange = function(aSelects, aEncodings, aCommand) {
+    let graphApi = Dbm.getRepositoryItem("cachedGraphApi").controller;
+        
+    let request = graphApi.requestRange(aSelects, aEncodings);
+    
+    if(aCommand) {
+        Dbm.flow.runWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, aCommand);
+    }
+
+    return request.properties.items;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.4.10",
+  "version": "1.4.13",
   "main": "index.js",
   "type": "module",
   "exports": {

package/react/admin/objects/EditObject.js

@@ -19,7 +19,7 @@ export default class EditObject extends Dbm.react.BaseObject {
                     {"type": "includeDraft"},
                     {"type": "idSelection", "ids": [id]},
                 ],
-                ["objectTypes"]
+                ["objectTypes", "name", "identifier"]
             );
             allLoaded.addCheck(request.properties.status);
         }
@@ -38,11 +38,23 @@ export default class EditObject extends Dbm.react.BaseObject {
             
             React.createElement(Dbm.react.area.HasData, {check: this.item.properties.loaded},
                 React.createElement(Dbm.react.context.AddContextVariables, {"values": {"item": item}},
-                    React.createElement(Dbm.react.admin.editorsgroup.EditItem, {}, 
-                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.contextVariable("item.objectTypes"), "as": "objectType", "keyField": "(root)"},
-                            Dbm.react.text.text(Dbm.react.source.contextVariable("objectType"))
+                    React.createElement(Dbm.react.admin.editorsgroup.EditItem, {},
+                        React.createElement("h2", {"className": "no-margins"},
+                            Dbm.react.text.text(Dbm.react.source.item("id")),
+                            " - ",
+                            Dbm.react.text.text(Dbm.react.source.item("name")),
                         ),
-                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.contextVariable("item.objectTypes"), "as": "objectType", "keyField": "(root)"},
+                        React.createElement("div", {"className": "small-description"},
+                            Dbm.react.text.text(Dbm.react.source.item("identifier"))
+                        ),
+                        React.createElement("div", {"className": "spacing small"}),
+                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.item("objectTypes"), className: "inline-list standard-tag-list standard-tag-list-expand", "as": "objectType", "keyField": "(root)"},
+                            React.createElement("div", {"className": "standard-tag standard-tag-padding standard-tag-list-item inline-list-item display-inline-block"},
+                                Dbm.react.text.text(Dbm.react.source.contextVariable("objectType"))
+                            )
+                        ),
+                        React.createElement("div", {"className": "spacing small"}),
+                        React.createElement(Dbm.react.area.List, {items: Dbm.react.source.item("objectTypes"), "as": "objectType", "keyField": "(root)"},
                             React.createElement(Dbm.react.admin.objects.InjectObjectTypeEditor, {type: Dbm.react.source.contextVariable("objectType")})
                         )
                     )

package/react/form/CustomSelection.js

@@ -0,0 +1,69 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class CustomSelection extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let valueProperty = this.getDynamicPropWithoutState("value", null);
+        let itemsProperty = this.getDynamicPropWithoutState("items", []);
+
+        let openProperty = this.item.requireProperty("open", false);
+        this.item.requireProperty("rows", []);
+
+        this.item.requireProperty("selectedItem", null);
+
+        let mappedList = Dbm.flow.updatefunctions.basic.mappedList(itemsProperty, [this._getScopedCallFunctionCommand(this._newRow, [Dbm.core.source.event("mappedItem")])]);
+        this.item.setValue("mappedList", mappedList);
+        this.item.properties.rows.connectInput(mappedList.output.properties.items);
+
+        let singleSelection = new Dbm.flow.controllers.select.SingleSelection();
+        this.item.setValue("singleSelection", singleSelection.item);
+        singleSelection.item.properties.value.connectInput(valueProperty);
+
+        let closeCommand = Dbm.commands.setProperty(openProperty, false);
+        this.item.setValue("closeCommand", closeCommand);
+
+        let path = this.getPropValueWithDefault("path", "id");
+        let getItemBy = Dbm.flow.updatefunctions.basic.getItemBy(itemsProperty, valueProperty, path);
+        this.item.setValue("getItemBy", getItemBy);
+
+        this.item.properties.selectedItem.connectInput(getItemBy.output.properties.value);
+    }
+
+    _newRow(aRow) {
+        //console.log("_newRow");
+        //console.log(aRow);
+
+        let path = this.getPropValueWithDefault("path", "id");
+
+        let value = Dbm.objectPath(aRow, "forItem." + path);
+
+        let selectedProperty = this.item.singleSelection.controller.addSelectionValue(value);
+
+        aRow.setValue("value", value);
+        aRow.requireProperty("selected", false).connectInput(selectedProperty);
+    }
+
+    _renderMainElement() {
+
+        let children = Dbm.utils.ArrayFunctions.singleOrArray(this.getPropValue("children"));
+        
+        let slots = Dbm.react.ChildFunctions.splitIntoSlots(children);
+                
+        let buttonElement = slots["button"];
+        let mainChildren = slots.main;
+
+        let contextValues = {"value": this.item.properties["props/value"], "selectedItem": this.item.properties.selectedItem, "rows": this.item.properties.rows, "closeCommand": this.item.closeCommand};
+
+        return this._createMainElement(Dbm.react.form.Dropdown, {"open": this.item.properties.open},
+            React.createElement(Dbm.react.context.AddContextVariables, {"data-slot": "button", "values": contextValues}, 
+                React.createElement(Dbm.react.area.InsertElement, {"element": buttonElement})
+            ),
+            React.createElement(Dbm.react.context.AddContextVariables, {"values": contextValues}, 
+                React.createElement(Dbm.react.area.InsertElement, {"element": mainChildren})
+            )
+        );
+    }
+}
+

package/react/form/GraphApiObjectCustomSelection.js

@@ -0,0 +1,105 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class GraphApiObjectSelection extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.getDynamicProp("value", "");
+        this.item.requireProperty("items", []);
+        this.item.requireProperty("sortedItems", []);
+
+        let objectType = this.getPropValue("objectType");
+        let encodings = Dbm.utils.ArrayFunctions.arrayOrSeparatedString(this.getPropValueWithDefault("encoding", "name"), ",", true);
+
+        {
+            let selects = [
+                    {"type": "byObjectType", "objectType": objectType},
+                    {"type": "includeDraft"},
+                    {"type": "includePrivate"}
+                ];
+            if(this.getPropValue("anyStatus")) {
+                selects = [
+                    {"type": "byObjectType", "objectType": objectType},
+                    {"type": "includeAnyStatus"}
+                ];
+            }
+
+            let request = Dbm.getCachedGraphApi().requestRange(
+                selects,
+                encodings
+            );
+
+            this.item.properties.items.connectInput(request.properties.items);
+
+            Dbm.flow.runWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._itemsLoaded.bind(this), [request]));
+        }
+    }
+
+    _itemsLoaded(aRequest) {
+
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+
+        let currentArray = [].concat(aRequest.items);
+        Dbm.utils.ArrayFunctions.naturalSortOnField(currentArray, nameField);
+
+        this.item.sortedItems = currentArray;
+    }
+
+    _renderMainElement() {
+
+        let value = this.getDynamicProp("value");
+        let nameField = this.getPropValueWithDefault("nameField", "name");
+
+        return this._createMainElement(Dbm.react.form.CustomSelection, {"value": value, "items": this.item.properties.sortedItems, "path": nameField},
+
+    React.createElement("div", {
+    "data-slot": "button",
+    children: [React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("value"),
+      children: React.createElement(Dbm.react.context.AddItemToContext, {
+        item: Dbm.react.source.contextVariable("selectedItem"),
+        children: [React.createElement(Dbm.react.area.HasData, {
+          check: Dbm.react.source.item(),
+          children: React.createElement("div", {
+            children: Dbm.react.text.text(Dbm.react.source.item("name"))
+          })
+        }), React.createElement(Dbm.react.area.HasData, {
+          check: Dbm.react.source.item(),
+          checkType: "invert/default",
+          children: React.createElement("div", {
+            children: Dbm.react.text.text(Dbm.react.source.contextVariable("value"))
+          })
+        })]
+      })
+    }), React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("value"),
+      checkType: "invert/default",
+      children: React.createElement("div", {
+        children: Dbm.react.text.translatedText("Select")
+      })
+    })]
+  }), React.createElement("div", {
+    children: React.createElement(Dbm.react.area.HasData, {
+      check: Dbm.react.source.contextVariable("isVisible"),
+      children: React.createElement(Dbm.react.area.List, {
+        items: Dbm.react.source.contextVariable("rows"),
+        as: "row",
+        children: React.createElement(Dbm.react.context.AddItemToContext, {
+          item: Dbm.react.source.contextVariable("row.forItem"),
+          children: React.createElement(Dbm.react.interaction.CommandButton, {
+            commands: [Dbm.commands.setProperty(Dbm.react.source.contextVariable("row.properties.selected"), true), Dbm.react.source.contextVariable("closeCommand")],
+            children: React.createElement("div", {
+              children: Dbm.react.text.text(Dbm.react.source.item("name"))
+            })
+          })
+        })
+      })
+    })
+  })
+
+
+        );
+    }
+}
+

package/react/form/index.js

@@ -7,6 +7,7 @@ export {default as LabelledArea} from "./LabelledArea.js";
 export {default as FileDropArea} from "./FileDropArea.js";
 export {default as Selection} from "./Selection.js";
 export {default as GraphApiObjectSelection} from "./GraphApiObjectSelection.js";
+export {default as GraphApiObjectCustomSelection} from "./GraphApiObjectCustomSelection.js";
 export {default as GraphApiSelectOrCreateObject} from "./GraphApiSelectOrCreateObject.js";
 export {default as GraphApiImage} from "./GraphApiImage.js";
 export {default as EditArray} from "./EditArray.js";
@@ -16,6 +17,7 @@ export {default as Form} from "./Form.js";
 export {default as Option} from "./Option.js";
 export {default as Dropdown} from "./Dropdown.js";
 export {default as GraphApiObjectOptions} from "./GraphApiObjectOptions.js";
+export {default as CustomSelection} from "./CustomSelection.js";
 
 export const validationStateClassName = function(aChildren) {
     return React.createElement(Dbm.react.AddProps, {className: Dbm.react.source.contextVariable("field.properties.validationState")},

package/updater/PropertyUpdater.js

@@ -147,6 +147,10 @@ export default class PropertyUpdater extends Dbm.core.BaseObject {
             this._currentTweens.get(aProperty).stop();
         }
         
+        return this.addDelayUpdateProperty(aProperty, aToValue, aDelay);
+    }
+
+    addDelayUpdateProperty(aProperty, aToValue, aDelay = 0) {
         let tweenObject = {"envelope": aProperty.value};
 
         let tween = new Tween(tweenObject).to({"envelope": aToValue}, 0).delay(1000*aDelay).onUpdate(function(aData) {

package/updater/index.js

@@ -1,10 +1,11 @@
+import { Easing } from "@tweenjs/tween.js";
 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() {
+export const webSetup = function() {
     let updater = new Dbm.updater.PropertyUpdater();
     updater.item.register("propertyUpdater");
 
@@ -14,9 +15,14 @@ let webSetup = function() {
     updater.start();
 }
 
-export {webSetup};
+export const setupEasingFunctions = function() {
+    let item = Dbm.getRepositoryItem("easingFunctions");
 
-let nodeSetup = function() {
+    item.setValue("easeOut", Easing.Quadratic.Out);
+    item.setValue("easeIn", Easing.Quadratic.In);
+}
+
+export const nodeSetup = function() {
     let updater = new Dbm.updater.PropertyUpdater();
     updater.item.register("propertyUpdater");
 
@@ -24,6 +30,4 @@ let nodeSetup = function() {
     updater.setTimer(timer.item);
 
     updater.start();
-}
-
-export {nodeSetup};
+}

package/utils/MathFunctions.js

@@ -0,0 +1,15 @@
+export const clamp = function(aValue, aMinValue = 0, aMaxValue = 1) {
+    return Math.max(Math.min(aValue, aMaxValue), aMinValue);
+}
+
+export const parametricValue = function(aValue, aStartValue, aEndValue) {
+    return (aValue-aStartValue)/(aEndValue-aStartValue);
+}
+
+export const clampedParametricValue = function(aValue, aStartValue, aEndValue) {
+    return clamp(parametricValue(aValue, aStartValue, aEndValue), 0, 1);
+}
+
+export const linearInerpolation = function(aParameter, aStartValue, aEndValue) {
+    return (1-aParameter)*aStartValue+aParameter*aEndValue;
+}

package/utils/index.js

@@ -7,6 +7,7 @@ export * as TranslationFunctions from "./TranslationFunctions.js";
 export * as LevenshteinDistance from "./LevenshteinDistance.js";
 export * as ObjectFunctions from "./ObjectFunctions.js";
 export * as LocalCache from "./LocalCache.js";
+export * as MathFunctions from "./MathFunctions.js";
 
 export {default as MultidimensionalArrayHolder} from "./MultidimensionalArrayHolder.js";
 export {default as ArrayOperationResult} from "./ArrayOperationResult.js";