dbm 1.1.11 → 1.1.13

package/core/source/SourceBaseObject.js

@@ -24,6 +24,14 @@ export default class SourceBaseObject extends Dbm.core.BaseObject {
 
         if(this._log) {
             console.log("Source>>>>>", baseObject, path);
+            let currentPath = "";
+            let currentArray = path.split(".");
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                currentPath += currentArray[i];
+                console.log(currentPath, Dbm.objectPath(baseObject, currentPath));
+                currentPath += ".";
+            }
         }
 
 		if(!path) {

package/flow/controllers/transform/SingleArrayValues.js

@@ -0,0 +1,125 @@
+import Dbm from "../../../index.js";
+
+export default class SingleArrayValues extends Dbm.core.BaseObject {
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("array", []);
+        this.item.requireProperty("items", []);
+
+        let arrayUpdatedCommand = Dbm.commands.callFunction(this._arrayUpdated.bind(this));
+        Dbm.flow.addUpdateCommand(this.item.properties.array, arrayUpdatedCommand);
+
+        this._valueUpdatedCommand = Dbm.commands.callFunction(this._valueUpdated.bind(this));
+        
+    }
+
+    _createItem(aInitialValue = null) {
+        let newItem = new Dbm.repository.Item();
+        newItem.setId("_dbmInternal/" + Dbm.getInstance().getNextId());
+        Dbm.flow.addUpdateCommand(newItem.requireProperty("value", aInitialValue), this._valueUpdatedCommand);
+
+        return newItem;
+    }
+
+    push(aValue = null) {
+        let item = this._createItem(aValue);
+        
+        let dataArray = [].concat(this.item.array);
+        let itemsArray = [].concat(this.item.items);
+
+        itemsArray.push(item);
+        dataArray.push(aValue);
+        
+        this.item.items = itemsArray;
+        this.item.properties.array.getMostUpstreamProperty().value = dataArray;
+    }
+
+    removeItem(aItem) {
+        //console.log("removeItem");
+        //console.log(aItem);
+
+        let dataArray = [].concat(this.item.array);
+        let itemsArray = [].concat(this.item.items);
+
+        let index = itemsArray.indexOf(aItem);
+        if(index >= 0) {
+            itemsArray.splice(index, 1);
+            dataArray.splice(index, 1);
+            
+            this.item.items = itemsArray;
+            this.item.properties.array.getMostUpstreamProperty().value = dataArray;
+        }
+    }
+
+    _movePosition(aFromIndex, aToIndex) {
+        //METODO
+    }
+
+    moveItem(aItem, aPosition) {
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            this._movePosition(index, aPosition);
+        }
+    }
+
+    moveUpItem(aItem, aPosition) {
+
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            if(index > 0) {
+                this._movePosition(index, index-1);
+            }
+        }
+    }
+
+    moveDownItem(aItem, aPosition) {
+        let index = this.item.items.indexOf(aItem);
+        if(index >= 0) {
+            if(index < this.item.items.length-1) {
+                this._movePosition(index, index+1);
+            }
+        }
+    }
+
+    _arrayUpdated() {
+        console.log("_arrayUpdated");
+
+        let dataArray = this.item.array;
+        let itemsArray = this.item.items;
+
+        let dataLength = dataArray.length;
+        let itemsLength = itemsArray.length;
+        let itemChange = dataLength-itemsLength;
+        if(itemChange !== 0) {
+            itemsArray = [].concat(itemsArray);
+            if(itemChange < 0) {
+                itemsArray.splice(itemsArray.length, Math.abs(itemChange));
+            }
+            else if(itemChange > 0) {
+                for(let i = 0; i < itemChange; i++) {
+                    itemsArray.push(this._createItem(dataArray[itemsLength+i]));
+                }
+            }
+        }
+        
+        let currentArray = dataArray;
+        let currentArrayLength = currentArray.length;
+        for(let i = 0; i < currentArrayLength; i++) {
+            itemsArray[i].value = currentArray[i];
+        }
+
+        if(itemChange !== 0) {
+            this.item.items = itemsArray;
+        }
+        
+    }
+
+    _valueUpdated() {
+        console.log("_valueUpdated");
+
+        let values = Dbm.utils.ArrayFunctions.mapField(this.item.items, "value");
+        console.log(values); 
+        this.item.properties.array.getMostUpstreamProperty().value = values;
+    }
+}

package/flow/controllers/transform/index.js

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

package/graphapi/webclient/CachedRequests.js

@@ -42,10 +42,9 @@ export default class CachedRequests extends Dbm.core.BaseObject {
     }
 	
 	requestRange(aSelect, aEncode) {
-        console.log("requestRange");
+        //console.log("requestRange");
 
         let id = this._getRangeIdentifier(aSelect, aEncode);
-        console.log(id);
 
         if(this._ranges[id]) {
             return this._ranges[id];
@@ -59,10 +58,9 @@ export default class CachedRequests extends Dbm.core.BaseObject {
     }
 
     requestItem(aId, aEncode) {
-        console.log("requestItem");
+        //console.log("requestItem");
 
         let id = aId + "/" + this._getEncodeIdentifier(aEncode);
-        console.log(id);
 
         if(this._items[id]) {
             return this._items[id];

package/graphapi/webclient/GraphApi.js

@@ -21,7 +21,7 @@ export default class GraphApi extends Dbm.core.BaseObject {
 	}
 	
     requestRange(aSelect, aEncode) {
-        console.log("requestRange");
+        //console.log("requestRange");
 
         if(this._websocketConnection && this._websocketConnection.item.status === 1) {
 			return this._websocketConnection.requestRange(aSelect, aEncode);
@@ -31,7 +31,7 @@ export default class GraphApi extends Dbm.core.BaseObject {
     }
 
     requestItem(aId, aEncode) {
-        console.log("requestItem");
+        //console.log("requestItem");
 
         if(this._websocketConnection && this._websocketConnection.item.status === 1) {
             return this._websocketConnection.requestItem(aId, aEncode);

package/graphapi/webclient/admin/ImageUploader.js

@@ -0,0 +1,81 @@
+import Dbm from "../../../index.js";
+
+export default class ImageUploader extends Dbm.core.BaseObject {
+
+    _construct() {
+        super._construct();
+
+        this.item.requireProperty("file", null);
+        this.item.requireProperty("status", 0);
+        this.item.requireProperty("item", null);
+
+        this._fileUploadedBound = this._fileUploaded.bind(this);
+    }
+
+    setFile(aFile) {
+        this.item.file = aFile;
+        return this;
+    }
+
+    uploadImage() {
+        console.log("uploadImage");
+        if(this.item.status !== 0) {
+            console.warn("Image is already uploading", this);
+            return this;
+        }
+
+        let file = this.item.file;
+        if(!file) {
+            console.warn("No file set", this);
+            return this;
+        }
+
+        this.item.status = 2;
+                
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        let preSign = graphApi.requestData("fileUpload", {"fileName": file.name, "mimeType": file.type});
+
+        Dbm.flow.addDirectUpdateCommand(preSign.getProperty("status"), Dbm.commands.callFunction(this._statusChanged.bind(this), [preSign, file]));
+        
+        return this;
+    }
+        
+    _statusChanged(aPreSign, aFile) {
+        console.log("_statusChanged");
+        console.log(aPreSign, aFile);
+
+        let item = Dbm.getInstance().repository.getItem(aPreSign.data.id);
+        item.setValue("name", aPreSign.data.name);
+        item.setValue("url", aPreSign.data.publicUrl);
+        item.setValue("resizeUrl", aPreSign.data.publicResizeUrl);
+        item.setValue("identifier", aPreSign.data.identifier);
+        this.item.item = item;
+
+        if(aPreSign.status === 1) {
+            let url = aPreSign.data.url;
+            console.log(url, aPreSign.data);
+
+            let headers = {
+                'Content-Type': aFile.type,
+                'Cache-Control': 'no-cache',
+            };
+
+            let additionalHeaders = aPreSign.data.additionalHeaders;
+            for(let objectName in additionalHeaders) {
+                headers[objectName] = additionalHeaders[objectName];
+            }
+
+            fetch(url, {method: 'PUT', headers: new Headers(headers), body: aFile}).then(this._fileUploadedBound)
+
+        }
+    }
+
+    _fileUploaded() {
+        console.log("_fileUploaded");
+
+        this.item.status = 1;
+
+        console.log("Uploaded", this.item.item);
+    }
+}

package/graphapi/webclient/admin/ItemEditor.js

@@ -42,6 +42,68 @@ export default class ItemEditor extends Dbm.core.BaseObject {
         return this.addEditor(aField, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.setField, aUpdateEncoding);
     }
 
+    _addRelationEditor(aName, aType, aObjectType, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
+        let valueEditor = this.item["editor_relation_" + aName];
+        if(!valueEditor) {
+            valueEditor = new Dbm.graphapi.webclient.admin.ValueEditor();
+            valueEditor.item.editValue.setInitialValue(aInitialValue);
+
+            valueEditor.item.setValue("itemEditor", this.item);
+            valueEditor.item.setValue("type", aType);
+            valueEditor.item.setValue("objectType", aObjectType);
+            valueEditor.item.setValue("updateEncoding", aUpdateEncoding);
+
+            this.item.anyChange.addCheck(valueEditor.item.properties.changed);
+            this.item.setValue("editor_relation_" + aName, valueEditor); 
+            this.item.editors = [].concat(this.item.editors, valueEditor);
+            
+            valueEditor.addSaveFunction(aSaveFunction);
+        }
+
+        return valueEditor;
+    }
+
+    addIncomingRelationEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "in_" + aType + "_" + aObjectType;
+        return this._addRelationEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.incomingRelation, aUpdateEncoding);
+    }
+
+    addOutgoingRelationEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "out_" + aType + "_" + aObjectType;
+        return this._addRelationEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.outgoingRelation, aUpdateEncoding);
+    }
+
+    _addMultipleRelationsEditor(aName, aType, aObjectType, aInitialValue, aSaveFunction, aUpdateEncoding = null) {
+        let valueEditor = this.item["editor_relation_" + aName];
+        if(!valueEditor) {
+            valueEditor = new Dbm.graphapi.webclient.admin.ValueEditor();
+            valueEditor.item.editValue.setInitialValue(aInitialValue);
+
+            valueEditor.item.setValue("itemEditor", this.item);
+            valueEditor.item.setValue("type", aType);
+            valueEditor.item.setValue("objectType", aObjectType);
+            valueEditor.item.setValue("updateEncoding", aUpdateEncoding);
+
+            this.item.anyChange.addCheck(valueEditor.item.properties.changed);
+            this.item.setValue("editor_multipleRelations_" + aName, valueEditor); 
+            this.item.editors = [].concat(this.item.editors, valueEditor);
+            
+            valueEditor.addSaveFunction(aSaveFunction);
+        }
+
+        return valueEditor;
+    }
+
+    addMultipleIncomingRelationsEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "in_" + aType + "_" + aObjectType;
+        return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleIncomingRelations, aUpdateEncoding);
+    }
+
+    addMultipleOutgoingRelationsEditor(aType, aObjectType, aInitialValue, aUpdateEncoding = null) {
+        let name = "out_" + aType + "_" + aObjectType;
+        return this._addMultipleRelationsEditor(name, aType, aObjectType, aInitialValue, Dbm.graphapi.webclient.admin.SaveFunctions.multipleOutgoingRelations, aUpdateEncoding);
+    }
+
     addCommandsToSaveData(aSaveData) {
 
         let editedItemId = Dbm.objectPath(this.item, "editedItem.id");

package/graphapi/webclient/admin/SaveFunctions.js

@@ -1,7 +1,41 @@
+import Dbm from "../../../index.js";
+
 export const setField = function(aEditor, aItemSaveData) {
     aItemSaveData.setField(aEditor.item.name, aEditor.item.editValue.getValue());
 }
 
 export const setUrl = function(aEditor, aItemSaveData) {
     aItemSaveData.createChange("setUrl", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const setIdentifier = function(aEditor, aItemSaveData) {
+    aItemSaveData.createChange("setIdentifier", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const setVisibility = function(aEditor, aItemSaveData) {
+    aItemSaveData.createChange("setVisibility", {"value": aEditor.item.editValue.getValue()});
+}
+
+export const incomingRelation = function(aEditor, aItemSaveData) {
+    let id = aEditor.item.editValue.getValue();
+
+    aItemSaveData.createChange("replaceIncomingRelation", {"value": id, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const outgoingRelation = function(aEditor, aItemSaveData) {
+    let id = aEditor.item.editValue.getValue();
+
+    aItemSaveData.createChange("replaceOutgoingRelation", {"value": id, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const multipleIncomingRelations = function(aEditor, aItemSaveData) {
+    let ids = Dbm.utils.ArrayFunctions.removeValues(aEditor.item.editValue.getValue(), [0, null, undefined]);
+
+    aItemSaveData.createChange("replaceMultipleIncomingRelations", {"value": ids, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
+}
+
+export const multipleOutgoingRelations = function(aEditor, aItemSaveData) {
+    let ids = Dbm.utils.ArrayFunctions.removeValues(aEditor.item.editValue.getValue(), [0, null, undefined]);
+
+    aItemSaveData.createChange("replaceMultipleOutgoingRelations", {"value": ids, "type": aEditor.item.type, "objectType": aEditor.item.objectType});
 }

package/graphapi/webclient/admin/index.js

@@ -5,4 +5,6 @@ export {default as EditorGroup} from "./EditorGroup.js";
 export {default as ItemEditor} from "./ItemEditor.js";
 export {default as ValueEditor} from "./ValueEditor.js";
 
+export {default as ImageUploader} from "./ImageUploader.js";
+
 export * as SaveFunctions from "./SaveFunctions.js";

package/graphapi/webclient/decode/Relations.js

@@ -0,0 +1,77 @@
+import Dbm from "../../../index.js";
+
+export default class Relations extends Dbm.graphapi.webclient.decode.DecodeBaseObject {
+    _construct() {
+        super._construct();
+    }
+
+    _isRelationValid(aStartTime, aEndTime) {
+        let now = (new Date()).toISOString().split("T").join(" ").substring(0, 19);
+
+        return ((aStartTime === null || aStartTime <= now) && (aEndTime === null || aEndTime > now));
+    }
+
+    updateItem(aItem, aData) {
+        super.updateItem(aItem, aData);
+
+        let relations = aData["relations"];
+        {
+            let currentRelations = relations["in"];
+            let currentRelationsItem = aItem["relations/in"];
+            if(!currentRelationsItem) {
+                currentRelationsItem = new Dbm.repository.Item();
+                aItem.setValue("relations/in", currentRelationsItem);
+            }
+
+            let currentArray = currentRelations;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentRelationData = currentArray[i];
+                let currentType = currentRelationData["type"];
+                let typeItem = currentRelationsItem[currentType];
+                if(!typeItem) {
+                    typeItem = new Dbm.repository.Item();
+                    typeItem.setValue("objects", []);
+                    currentRelationsItem.setValue(currentType, typeItem);
+                }
+
+                if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
+                    let newArray = [].concat(typeItem["objects"]);
+                    newArray.push(Dbm.getInstance().repository.getItem(currentRelationData["id"]));
+                    typeItem["objects"] = newArray;
+                    //METODO: set up relations
+                }
+                
+            }
+        }
+
+        {
+            let currentRelations = relations["out"];
+            let currentRelationsItem = aItem["relations/out"];
+            if(!currentRelationsItem) {
+                currentRelationsItem = new Dbm.repository.Item();
+                aItem.setValue("relations/out", currentRelationsItem);
+            }
+
+            let currentArray = currentRelations;
+            let currentArrayLength = currentArray.length;
+            for(let i = 0; i < currentArrayLength; i++) {
+                let currentRelationData = currentArray[i];
+                let currentType = currentRelationData["type"];
+                let typeItem = currentRelationsItem[currentType];
+                if(!typeItem) {
+                    typeItem = new Dbm.repository.Item();
+                    typeItem.setValue("objects", []);
+                    currentRelationsItem.setValue(currentType, typeItem);
+                }
+
+                if(this._isRelationValid(currentRelationData["startAt"], currentRelationData["endAt"])) {
+                    let newArray = [].concat(typeItem["objects"]);
+                    newArray.push(Dbm.getInstance().repository.getItem(currentRelationData["id"]));
+                    typeItem["objects"] = newArray;
+                    //METODO: set up relations
+                }
+            }
+        }
+    }
+}

package/graphapi/webclient/decode/index.js

@@ -1,6 +1,7 @@
 import Dbm from "../../../index.js";
 
 export {default as DecodeBaseObject} from "./DecodeBaseObject.js";
+export {default as Relations} from "./Relations.js";
 
 export const fullSetup = function() {
     let decodePrefix = "graphApi/decode/";
@@ -135,10 +136,41 @@ export const fullSetup = function() {
     }
 
     {
-            let name = "helpSection";
-            let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
-            currentDecoder.item.setValue("copyFields", ["title", "link"]);
-            currentDecoder.item.setValue("encodingType", name);
-            currentDecoder.item.register(decodePrefix + name);
-        }
+        let name = "helpSection";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyFields", ["title", "link"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "relations";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.Relations();
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "atLocation";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyLink", ["location"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "mainImage";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyLink", ["image"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
+
+    {
+        let name = "location";
+        let currentDecoder = new Dbm.graphapi.webclient.decode.DecodeBaseObject();
+        currentDecoder.item.setValue("copyFields", ["street", "postCode", "city", "country", "coordinates"]);
+        currentDecoder.item.setValue("encodingType", name);
+        currentDecoder.item.register(decodePrefix + name);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbm",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "main": "index.js",
   "type": "module",
   "scripts": {},

package/react/BaseObject.js

@@ -32,7 +32,7 @@ export default class BaseObject extends Component {
                 currentDynamicProperty.connectInput(currentProp);
             }
 			else if(this._dynamicProps[objectName]) {
-                let currentDynamicProperty = this.getDynamicProp(objectName);
+                let currentDynamicProperty = this._dynamicProps[objectName];
                 currentDynamicProperty.value = currentProp;
 			}
         }

package/react/admin/EditPage.js

@@ -114,6 +114,20 @@ export default class EditPage extends Dbm.react.BaseObject {
 
     }
 
+    _generateHelpSectionSuggestions() {
+
+        let page = this.context.page;
+
+        let editorGroup = this.item.editorGroup;
+        let itemEditor = editorGroup.getItemEditor(page.id);
+
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+
+        let request = graphApi.requestData("admin/helpSectionSuggestions", {"value": {"title": itemEditor.getEditor("title").item.editValue.getValue(), "content": itemEditor.getEditor("content").item.editValue.getValue()}});
+        Dbm.flow.addUpdateCommandWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._helpSectionSuggestionsLoaded.bind(this), [request]));
+
+    }
+
     _dataLoaded(aRequest) {
         let summary = Dbm.objectPath(aRequest, "data.seoSummary");
 
@@ -125,6 +139,13 @@ export default class EditPage extends Dbm.react.BaseObject {
         itemEditor.getEditor("meta/description").item.editValue.item.value = summary;
     }
 
+    _helpSectionSuggestionsLoaded(aRequest) {
+        console.log("_helpSectionSuggestionsLoaded");
+        let titles = Dbm.objectPath(aRequest, "data.titles");
+
+        console.log(aRequest, titles);
+    }
+
     _renderMainElement() {
 
         let page = this.context.page;
@@ -200,7 +221,10 @@ export default class EditPage extends Dbm.react.BaseObject {
                     React.createElement(Dbm.react.form.FormField, {value: this.item.properties.importText}),
                     React.createElement("div", {"className": "standard-button standard-button-padding", "onClick": () => {this._import()}},
                         "Import"
-                    )
+                    ),
+                    React.createElement("div", {className: "flex-row-item"},
+                        React.createElement("div", {onClick: () => {this._generateHelpSectionSuggestions()}, className: "action-button action-button-padding"}, "Dev: Help sections"),
+                    ),
                 ),
                 React.createElement("div", {className: "spacing standard"}),
                 React.createElement("div", {className: "save-all-position"},

package/react/admin/SelectedImage.js

@@ -0,0 +1,48 @@
+import React from "react";
+import Dbm from "../../index.js";
+
+export default class SelectedImage extends Dbm.react.BaseObject {
+    _construct() {
+        super._construct();
+
+        let id = this.getPropValue("id");
+        this.item.requireProperty("item", null);
+        this.item.requireProperty("loaded", false);
+
+        let graphApi = Dbm.getInstance().repository.getItem("graphApi").controller;
+        let request = graphApi.requestRange(
+            [
+                {"type": "idSelection", "ids": [id]}
+            ],
+            ["name", "image"]
+        );
+
+        Dbm.flow.addUpdateCommandWhenMatched(request.properties.status, Dbm.loading.LoadingStatus.LOADED, Dbm.commands.callFunction(this._dataLoaded.bind(this), [request]));
+    }
+
+    _dataLoaded(aRequest) {
+        console.log("_dataLoaded");
+        console.log(aRequest);
+
+        this.item.item = aRequest.items[0];
+
+        this.item.loaded = true;
+    }
+
+    _renderMainElement() {
+        return React.createElement("div", {}, 
+            React.createElement(Dbm.react.area.HasData, {check: this.item.properties.item}, 
+                React.createElement(Dbm.react.context.AddItemToContext, {item: this.item.properties.item},
+                    React.createElement("div", {className: "flex-row small-item-spacing"},
+                        React.createElement("div", {className: "flex-row-item flex-no-resize"},
+                            React.createElement(Dbm.react.image.WidthScaledImage, {"image": Dbm.react.source.contextVariable("item"), targetWidth: 120, className: "editor-preview background-contain"}),
+                        ),
+                        React.createElement("div", {className: "flex-row-item flex-resize", style: {wordBreak: "break-word", overflowWrap: "break-word"}},
+                            Dbm.react.text.text(Dbm.react.source.contextVariable("item.url"))
+                        )
+                    )
+                )
+            )
+        );
+    }
+}