dbm 1.2.1 → 1.2.2

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/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/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/thirdparty/google/maps/PlaceDetails.js

@@ -0,0 +1,80 @@
+import Dbm from "../../../../../index.js";
+
+export default class PlaceDetails extends Dbm.flow.FlowUpdateFunction {
+
+    _construct() {
+        super._construct();
+        
+        this.input.register("id", null);
+        this.input.register("fields", ["addressComponents", "location"]);
+
+        //reviews
+
+        this._loadedScript = false;
+        this._currentId = "";
+
+        this.output.register("updated", true);
+        this.output.register("data", null);
+    }
+
+    loadScript() {
+        console.log("loadScript");
+        let key = Dbm.getRepositoryItem("googleMapsApi").apiKey;
+        let scriptLoader = Dbm.loading.loadScript("https://maps.googleapis.com/maps/api/js?key=" + key + "&libraries=places");
+
+        console.log(scriptLoader.item.properties.status, scriptLoader);
+        if(scriptLoader.item.status === 1) {
+            this._scriptLoaded();
+        }
+        else {
+            Dbm.flow.addUpdateCommandWhenMatched(scriptLoader.item.properties.status, 1, Dbm.commands.callFunction(this._scriptLoaded.bind(this)));
+        }
+
+        return this;
+    }
+
+    _scriptLoaded() {
+        console.log("_scriptLoaded");
+        if(!this._loadedScript) {
+            this._loadedScript = true;
+            this._update();
+        }
+    }
+
+    _update() {
+        console.log("_update");
+
+        
+        let id = this.input.id;
+        this._currentId = id;
+        this.output.updated = false;
+
+        if(id) {
+            this.output.properties.data.isDirty = false;
+            this.output.properties.updated.isDirty = false;
+
+            if(this._loadedScript) {
+
+                let place = new google.maps.places.Place({"id": this.input.id});
+                console.log(place);
+
+                let loadPromise = place.fetchFields({"fields": this.input.fields});
+
+                loadPromise.then((aResult) => {
+                    console.log(id, place, aResult);
+                    this.output.properties.data._internal_setValueInFlowOutsideOfUpdate(place);
+                })
+            }
+            else {
+                this.loadScript();
+            }
+        }
+        else {
+            this.output.data = null;
+            this.output.updated = true;
+        }
+    }
+}
+
+
+

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

@@ -1,3 +1,4 @@
 import Dbm from "../../../../../index.js";
 
 export {default as AutoComplete} from "./AutoComplete.js";
+export {default as PlaceDetails} from "./PlaceDetails.js";

package/graphapi/webclient/ApiConnection.js

@@ -77,6 +77,7 @@ export default class ApiConnection extends Dbm.core.BaseObject {
 
     requestData(aFunctionName, aData) {
         let item = this._getRequestItem();
+        item.requireProperty("data", null);
 
         let parametersArray = [];
 

package/graphapi/webclient/WebSocketConnection.js

@@ -94,6 +94,7 @@ export default class WebSocketConnection extends Dbm.core.BaseObject {
     requestData(aFunctionName, aData) {
         //console.log("requestData");
         let item = this._getRequestItem();
+        item.requireProperty("data", null);
         item.setValue("requestData", {"type": "data", "functionName": aFunctionName, "data": aData, "requestId": item.id});
         this._runRequest(item);
         

package/graphapi/webclient/admin/EditorGroup.js

@@ -18,7 +18,7 @@ export default class EditorGroup extends Dbm.core.BaseObject {
         let itemEditor = this.item["editor_" + aId];
         if(!itemEditor) {
             itemEditor = new Dbm.graphapi.webclient.admin.ItemEditor();
-            itemEditor.item.setValue("editedItem", Dbm.getInstance().repository.getItem(aId));
+            itemEditor.item.setValue("editedItem", Dbm.getRepositoryItem(aId));
             this.item.setValue("editor_" + aId, itemEditor); 
             this.item.editors = [].concat(this.item.editors, itemEditor);
             this.item.anyChange.addCheck(itemEditor.item.properties.changed);

package/graphapi/webclient/admin/ItemEditor.js

@@ -42,6 +42,18 @@ export default class ItemEditor extends Dbm.core.BaseObject {
         return this.addEditor(aField, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.setField, aUpdateEncoding);
     }
 
+    addFieldTranslationEditor(aField, aLanguage, aInitialValue, aUpdateEncoding = null) {
+        let name = "translation_" + aField + "_" + aLanguage;
+        let valueEditor = this.item["editor_" + name];
+        if(!valueEditor) {
+            valueEditor = this.addEditor(name, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.setFieldTranslation, aUpdateEncoding);
+            valueEditor.item.setValue("name", aField);
+            valueEditor.item.setValue("language", aLanguage);
+        }
+        
+        return valueEditor;
+    }
+
     _addRelationEditor(aName, aType, aObjectType, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
         let valueEditor = this.item["editor_relation_" + aName];
         if(!valueEditor) {
@@ -104,6 +116,33 @@ export default class ItemEditor extends Dbm.core.BaseObject {
         return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleOutgoingRelations, aUpdateEncoding);
     }
 
+    getAdminMultipleIncomingRelationsEditor(aType, aObjectType) {
+        let name = "in_" + aType + "_" + aObjectType;
+        let valueEditor = this.item["editor_relation_" + name];
+        if(!valueEditor) {
+            let relations = Dbm.utils.ArrayFunctions.filterByField(Dbm.objectPath(this.item.editedItem, "relations/in." + aType + ".objects"), "objectTypes", aObjectType, "arrayContains");
+            let ids = Dbm.utils.ArrayFunctions.mapField(relations, "id");
+
+            valueEditor = this.addMultipleIncomingRelationsEditor(aType, aObjectType, ids, "relations");
+        }
+
+        return valueEditor;
+    }
+
+    getAdminMultipleOutgoingRelationsEditor(aType, aObjectType) {
+        let name = "out_" + aType + "_" + aObjectType;
+        let valueEditor = this.item["editor_relation_" + name];
+        if(!valueEditor) {
+            let relations = Dbm.utils.ArrayFunctions.filterByField(Dbm.objectPath(this.item.editedItem, "relations/in." + aType + ".objects"), "objectTypes", aObjectType, "arrayContains");
+            let ids = Dbm.utils.ArrayFunctions.mapField(relations, "id");
+
+            valueEditor = this.addMultipleOutgoingRelationsEditor(aType, aObjectType, ids, "relations");
+        }
+
+        return valueEditor;
+    }
+    
+
     getVisibilityEditor(aInitialValue) {
         let name = "visibility";
         let valueEditor = this.item["visibility"];

package/graphapi/webclient/admin/ItemSaveData.js

@@ -28,6 +28,12 @@ export default class ItemSaveData extends Dbm.core.BaseObject {
 
         return this;
     }
+
+    setFieldTranslation(aField, aLanguage, aValue) {
+        this.createChange("setFieldTranslation", {"value": aValue, "language": aLanguage, "field": aField});
+
+        return this;
+    }
     
     addUpdateEncoding(aEncoding) {
         this._updateEncodings.push(aEncoding);

package/graphapi/webclient/admin/SaveFunctions.js

@@ -4,6 +4,10 @@ export const setField = function(aEditor, aItemSaveData) {
     aItemSaveData.setField(aEditor.item.name, aEditor.item.editValue.getValue());
 }
 
+export const setFieldTranslation = function(aEditor, aItemSaveData) {
+    aItemSaveData.setFieldTranslation(aEditor.item.name, aEditor.item.language, aEditor.item.editValue.getValue());
+}
+
 export const setUrl = function(aEditor, aItemSaveData) {
     aItemSaveData.createChange("setUrl", {"value": aEditor.item.editValue.getValue()});
 }

package/graphapi/webclient/admin/ValueEditor.js

@@ -14,6 +14,21 @@ export default class ValueEditor extends Dbm.core.BaseObject {
         this.item.requireProperty("changed", false).connectInput(editValue.item.properties.changed);
     }
 
+    get value() {
+        return this.valueProperty.value;
+    }
+
+    set value(aValue) {
+        
+        this.valueProperty.value = aValue;
+
+        return aValue;
+    }
+
+    get valueProperty() {
+        return this.item.editValue.value;
+    }
+
     addSaveCommand(aCommand) {
 
         this.item.saveCommands = [].concat(this.item.saveCommands, aCommand);

package/graphapi/webclient/decode/DecodeBaseObject.js

@@ -49,5 +49,9 @@ export default class DecodeBaseObject extends Dbm.core.BaseObject {
                 }
             }
         }
+
+        if(this.item.setupCommands) {
+            Dbm.commands.performCommands(this.item.setupCommands, this, {"item": aItem});
+        }
     }
 }

package/graphapi/webclient/decode/index.js

@@ -3,13 +3,14 @@ import Dbm from "../../../index.js";
 export {default as DecodeBaseObject} from "./DecodeBaseObject.js";
 export {default as Relations} from "./Relations.js";
 
-export const setupDefaultDecoder = function(aName, aFields = [], aSingleLinks = [], aMultipleLinks = []) {
+export const setupDefaultDecoder = function(aName, aFields = [], aSingleLinks = [], aMultipleLinks = [], aSetupCommands = []) {
     let decodePrefix = "graphApi/decode/";
 
     let decoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
     decoder.item.setValue("copyFields", aFields);
     decoder.item.setValue("copyLink", aSingleLinks);
     decoder.item.setValue("copyLinks", aMultipleLinks);
+    decoder.item.setValue("setupCommands", aSetupCommands);
     decoder.item.setValue("encodingType", aName);
     decoder.item.register(decodePrefix + aName);
 
@@ -73,7 +74,7 @@ export const fullSetup = function() {
         let name = "urlRequest";
         let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
         currentDecoder.item.setValue("copyFields", ["meta/description", "seo/noIndex", "seo/noFollow", "publishDate"]);
-        currentDecoder.item.setValue("copyLink", ["category"]);
+        currentDecoder.item.setValue("copyLink", ["category", "translations"]);
         currentDecoder.item.setValue("copyLinks", ["categories"]);
         currentDecoder.item.setValue("encodingType", name);
         currentDecoder.item.register(decodePrefix + name);
@@ -201,4 +202,18 @@ export const fullSetup = function() {
 
     setupDefaultDecoder("linkPreview", ["title", "description", "link", "linkText"], ["page"]);
     setupDefaultDecoder("publishDate", ["publishDate"], []);
+    setupDefaultDecoder("language", [], ["language"]);
+    setupDefaultDecoder("admin_fieldTranslations", ["fields/translations"], []);
+    setupDefaultDecoder("translationGroup", [], [], ["pages"]);
+
+    let connectTranslations = function(aItem, aTranslationsName, aOutputName, aDefaultFieldName) {
+
+        let updateFunction = Dbm.flow.updatefunctions.basic.propertyOfWithDefault(aItem.getProperty(aTranslationsName), Dbm.getRepositoryItem("site").properties.currentLanguageCode, aItem.getProperty(aDefaultFieldName));
+        aItem.requireProperty(aOutputName, null).connectInput(updateFunction.output.properties.value);
+
+        aItem.requireProperty(aOutputName + "/update", updateFunction);
+    }
+
+    setupDefaultDecoder("name_translations", ["name/translations"], [], [], [Dbm.commands.callFunction(connectTranslations, [Dbm.core.source.event("item"), "name/translations", "name/translated", "name"])]);
+    setupDefaultDecoder("title_translations", ["title/translations"], [], [], [Dbm.commands.callFunction(connectTranslations, [Dbm.core.source.event("item"), "title/translations", "title/translated", "title"])]);
 }