jamespot-front-business 1.1.68 → 1.1.70

package/dist/esm.js

@@ -231,7 +231,7 @@ const animationStatsSlice = createSlice({
         builder.addCase(fetchAnimationStats.rejected, (state) => {
             state.loading = 'idle';
         });
-    }
+    },
 });
 
 const fetchAnimationStatsCurrent = createAsyncThunk('animations/fetchAnimationStatsCurrent', (uri, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
@@ -263,7 +263,7 @@ const animationStatsCurrentSlice = createSlice({
         builder.addCase(fetchAnimationStatsCurrent.rejected, (state) => {
             state.loading = 'idle';
         });
-    }
+    },
 });
 
 const selectCurrentAnimation = (state) => state.animations.animationsList.animationConfiguration;
@@ -2073,7 +2073,7 @@ const TinyMCEOptionsSlice = createSlice({
     initialState: initialState$5,
     reducers: {
         initOptions: (_, { payload }) => {
-            return { common: payload };
+            return payload;
         },
     },
 });
@@ -2088,11 +2088,15 @@ const TinyMCESlice = {
 const selectTinyMCECommonOptions = (state) => {
     return state.tinymce.options.common;
 };
+const selectTinyMCEExtendedOptions = (state) => {
+    return state.tinymce.options.extended;
+};
 const TinyMCE = {
     slice: TinyMCESlice,
     actions: Object.assign({}, TinyMCEOptionsSlice.actions),
     selectors: {
         selectTinyMCECommonOptions,
+        selectTinyMCEExtendedOptions,
     },
 };
 
@@ -2442,28 +2446,6 @@ function content(name) {
     }
 }
 
-const getWidgetRTHandlers = function (dispatch, uniqid) {
-    const widgetPresenceResponseHandler = function (message) {
-        if (message.namespace === 'WIDGET' && message.function === 'widget-presence-response') {
-            if (message.data && message.data.uniqid === uniqid) {
-                dispatch(Widget.slice.actions.registerWidgetRTObject({
-                    uniqid: message.data.uniqid,
-                    object: message.data.object,
-                }));
-            }
-        }
-    };
-    return [
-        {
-            namespace: 'WIDGET',
-            function: 'widget-presence-response',
-            handler: widgetPresenceResponseHandler,
-        },
-    ];
-};
-
-const MODE_EDIT = 'edit';
-const MODE_VIEW = 'view';
 const initialState$3 = {
     token: undefined,
     ids: {},
@@ -2633,6 +2615,27 @@ const widgetsSlice = createSlice({
         },
     },
 });
+
+const getWidgetRTHandlers = function (dispatch, uniqid) {
+    const widgetPresenceResponseHandler = function (message) {
+        if (message.namespace === 'WIDGET' && message.function === 'widget-presence-response') {
+            if (message.data && message.data.uniqid === uniqid) {
+                dispatch(widgetsSlice.actions.registerWidgetRTObject({
+                    uniqid: message.data.uniqid,
+                    object: message.data.object,
+                }));
+            }
+        }
+    };
+    return [
+        {
+            namespace: 'WIDGET',
+            function: 'widget-presence-response',
+            handler: widgetPresenceResponseHandler,
+        },
+    ];
+};
+
 const selectToken = (state) => state.widgets.token;
 const selectModal = (state) => state.widgets.modal;
 const selectWidgets = (state) => state.widgets.ids;
@@ -2757,12 +2760,11 @@ const AUDIENCE = {
     ALL: '1',
     CUSTOM: '0',
 };
-var StatusType$1;
-(function (StatusType) {
-    StatusType["draft"] = "draft";
-    StatusType["installed"] = "installed";
-    StatusType["suspended"] = "suspended";
-})(StatusType$1 || (StatusType$1 = {}));
+const StatusType$1 = {
+    draft: 'draft',
+    installed: 'installed',
+    suspended: 'suspended',
+};
 const APP_STATUS_TYPE = {
     DRAFT: StatusType$1.draft,
     INSTALLED: StatusType$1.installed,
@@ -2773,51 +2775,50 @@ const STUDIO_VIEW = {
     NOT_SOLR: '0',
 };
 const viewsList = ['create', 'popup', 'edit', 'filter', 'list', 'view'];
-var AppFormItemTypes;
-(function (AppFormItemTypes) {
-    AppFormItemTypes["IMAGE"] = "IMAGE";
-    AppFormItemTypes["DESCRIPTION"] = "DESCRIPTION";
-    AppFormItemTypes["TEXT"] = "TEXT";
-    AppFormItemTypes["TEXTAREA"] = "TEXTAREA";
-    AppFormItemTypes["TEXTAREAHTML"] = "TEXTAREAHTML";
-    AppFormItemTypes["DATE"] = "DATE";
-    AppFormItemTypes["DATETIME"] = "DATETIME";
-    AppFormItemTypes["NUMBER"] = "NUMBER";
-    AppFormItemTypes["URL"] = "URL";
-    AppFormItemTypes["EMAIL"] = "EMAIL";
-    AppFormItemTypes["SELECT"] = "SELECT";
-    AppFormItemTypes["CHECKBOX"] = "CHECKBOX";
-    AppFormItemTypes["TOGGLE"] = "TOGGLE";
-    AppFormItemTypes["RADIO"] = "RADIO";
-    AppFormItemTypes["TAGS"] = "TAGS";
-    AppFormItemTypes["ADDFILEATTACHMENT"] = "ADDFILEATTACHMENT";
-    AppFormItemTypes["CODEHTML"] = "CODEHTML";
-    AppFormItemTypes["USERLINK"] = "USERLINK";
-    AppFormItemTypes["CONTENTLINK"] = "CONTENTLINK";
-    AppFormItemTypes["RANGE"] = "RANGE";
-})(AppFormItemTypes || (AppFormItemTypes = {}));
-var ExtraAppFieldsItemViews;
-(function (ExtraAppFieldsItemViews) {
-    ExtraAppFieldsItemViews["TITLE"] = "TITLE";
-    ExtraAppFieldsItemViews["USER"] = "USER";
-    ExtraAppFieldsItemViews["PUBLISHTO"] = "PUBLISHTO";
-    ExtraAppFieldsItemViews["SENDALERTTOSUBSCRIBERS"] = "SENDALERTTOSUBSCRIBERS";
-    ExtraAppFieldsItemViews["RECEIVEACOPY"] = "RECEIVEACOPY";
-    ExtraAppFieldsItemViews["CREATIONDATE"] = "CREATIONDATE";
-})(ExtraAppFieldsItemViews || (ExtraAppFieldsItemViews = {}));
-var AppFieldFormPropertyTypes;
-(function (AppFieldFormPropertyTypes) {
-    AppFieldFormPropertyTypes["LABEL"] = "label";
-    AppFieldFormPropertyTypes["DESCRIPTION"] = "description";
-    AppFieldFormPropertyTypes["RICHTEXT"] = "richtext";
-    AppFieldFormPropertyTypes["CHECKBOX"] = "checkbox";
-    AppFieldFormPropertyTypes["OPTIONS_EDITOR"] = "options_editor";
-    AppFieldFormPropertyTypes["TAXONOMY"] = "taxonomy";
-    AppFieldFormPropertyTypes["CONTENTTYPE"] = "contenttype";
-})(AppFieldFormPropertyTypes || (AppFieldFormPropertyTypes = {}));
+const AppFormItemTypes = {
+    IMAGE: 'IMAGE',
+    DESCRIPTION: 'DESCRIPTION',
+    TEXT: 'TEXT',
+    TEXTAREA: 'TEXTAREA',
+    TEXTAREAHTML: 'TEXTAREAHTML',
+    DATE: 'DATE',
+    DATETIME: 'DATETIME',
+    NUMBER: 'NUMBER',
+    URL: 'URL',
+    EMAIL: 'EMAIL',
+    SELECT: 'SELECT',
+    CHECKBOX: 'CHECKBOX',
+    TOGGLE: 'TOGGLE',
+    RADIO: 'RADIO',
+    TAGS: 'TAGS',
+    ADDFILEATTACHMENT: 'ADDFILEATTACHMENT',
+    CODEHTML: 'CODEHTML',
+    USERLINK: 'USERLINK',
+    CONTENTLINK: 'CONTENTLINK',
+    RANGE: 'RANGE',
+};
+const ExtraAppFieldsItemViews = {
+    TITLE: 'TITLE',
+    USER: 'USER',
+    PUBLISHTO: 'PUBLISHTO',
+    SENDALERTTOSUBSCRIBERS: 'SENDALERTTOSUBSCRIBERS',
+    RECEIVEACOPY: 'RECEIVEACOPY',
+    CREATIONDATE: 'CREATIONDATE',
+};
+const AppFieldFormPropertyTypes = {
+    LABEL: 'label',
+    DESCRIPTION: 'description',
+    RICHTEXT: 'richtext',
+    CHECKBOX: 'checkbox',
+    OPTIONS_EDITOR: 'options_editor',
+    TAXONOMY: 'taxonomy',
+    CONTENTTYPE: 'contenttype',
+};
 const AppFormUniqueList = [AppFormItemTypes.DESCRIPTION, AppFormItemTypes.IMAGE];
+const AppFormUniqueListCheck = AppFormUniqueList;
 const AppFormBannedFromViews$1 = new Map();
 AppFormBannedFromViews$1.set(AppFormItemTypes.IMAGE, ['list', 'filter', 'view']);
+AppFormBannedFromViews$1.set(AppFormItemTypes.CODEHTML, ['list', 'filter', 'view']);
 const MapExtraFieldsWithView = {
     create: {
         fixed: [ExtraAppFieldsItemViews.TITLE],
@@ -2855,6 +2856,7 @@ const AppColumnsDefaultTypes = [
     AppFormItemTypes.DESCRIPTION,
 ];
 const AppFormPrimaryList = [AppFormItemTypes.DESCRIPTION];
+const AppFormPrimaryListValues = AppFormPrimaryList;
 const AppFormFixedList$1 = [
     ExtraAppFieldsItemViews.TITLE,
     ExtraAppFieldsItemViews.PUBLISHTO,
@@ -2869,6 +2871,18 @@ const AppFormNoAsFieldList = [
 ];
 const AppFormFieldOnlyInView = [AppFormItemTypes.CODEHTML];
 const AppFormNonPrimaryList = AppFormNoAsFieldList.concat(AppFormFieldOnlyInView).concat(AppFormPrimaryList);
+var Element;
+(function (Element) {
+    Element["Attr"] = "attr";
+    Element["PublishTo"] = "publishTo";
+})(Element || (Element = {}));
+var Description;
+(function (Description) {
+    Description["Empty"] = "";
+    Description["FieldTagDescription"] = "Field_Tag_Description";
+    Description["FieldTitleDescription"] = "Field_Title_Description";
+    Description["WWWDescCOM"] = "www.desc.com";
+})(Description || (Description = {}));
 
 var StatusType;
 (function (StatusType) {
@@ -3132,23 +3146,761 @@ function migrateJson(v1Json) {
     return v2;
 }
 
-function InstalledAppStudioAdapter(serverApp, serverApps) {
+function generateNewFormField(type, viewsDefault = true) {
+    return {
+        id: v4(),
+        type,
+        properties: _setFieldProperties(type),
+        mandatory: false,
+        views: {
+            create: viewsDefault,
+            popup: viewsDefault,
+            edit: viewsDefault,
+            list: viewsDefault,
+            filter: viewsDefault,
+            view: viewsDefault,
+        },
+        isActive: true,
+        isFixed: false,
+        isOptional: false,
+        value: null,
+        isLockedValue: false,
+    };
+}
+const taxonomyDefaultValue = {
+    type: 'taxonomyOpen',
+    id: 1,
+    title: 'Mots-clés',
+};
+const contentTypeDefaultValue = {
+    type: 'mpArticle',
+    label: 'Article',
+};
+function _setFieldProperties(type) {
+    switch (type) {
+        case AppFormItemTypes.TEXT:
+        case AppFormItemTypes.DESCRIPTION:
+        case AppFormItemTypes.TEXTAREAHTML:
+        case AppFormItemTypes.DATE:
+        case AppFormItemTypes.DATETIME:
+        case AppFormItemTypes.URL:
+        case AppFormItemTypes.EMAIL:
+        case AppFormItemTypes.TOGGLE:
+        case AppFormItemTypes.USERLINK:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+            ];
+        case AppFormItemTypes.ADDFILEATTACHMENT:
+            return [{ propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' }];
+        case AppFormItemTypes.CODEHTML:
+            return [{ propertyType: AppFieldFormPropertyTypes.RICHTEXT, value: '' }];
+        case AppFormItemTypes.TEXTAREA:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+            ];
+        case AppFormItemTypes.NUMBER:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+                {
+                    propertyType: AppFieldFormPropertyTypes.CHECKBOX,
+                    value: false,
+                    checkBoxOptions: [{ label: 'APPSTUDIO_FormEditProps_Digits', value: false }],
+                },
+            ];
+        case AppFormItemTypes.SELECT:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+                {
+                    propertyType: AppFieldFormPropertyTypes.OPTIONS_EDITOR,
+                    value: [],
+                    isOptionsEditorEnhanced: true,
+                },
+            ];
+        case AppFormItemTypes.CHECKBOX:
+        case AppFormItemTypes.RADIO:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+                {
+                    propertyType: AppFieldFormPropertyTypes.OPTIONS_EDITOR,
+                    value: [],
+                },
+            ];
+        case AppFormItemTypes.TAGS:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+                {
+                    propertyType: AppFieldFormPropertyTypes.TAXONOMY,
+                    value: Object.assign({}, taxonomyDefaultValue),
+                },
+            ];
+        case AppFormItemTypes.CONTENTLINK:
+            return [
+                { propertyType: AppFieldFormPropertyTypes.LABEL, isRequired: true, value: '' },
+                { propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: '' },
+                {
+                    propertyType: AppFieldFormPropertyTypes.CONTENTTYPE,
+                    value: Object.assign({}, contentTypeDefaultValue),
+                },
+            ];
+        default:
+            return [];
+    }
+}
+
+function _initField(type, installedField) {
+    const field = Object.assign(Object.assign({}, generateNewFormField(type, false)), { id: installedField.name, mandatory: installedField.mandatory });
+    field.properties[0].value = installedField.label;
+    field.properties[1].value = installedField.description;
+    return field;
+}
+function _getOptions(installedOptions) {
+    const options = [];
+    Object.keys(installedOptions).forEach((optionKey) => {
+        options.push({
+            title: installedOptions[optionKey],
+            value: optionKey,
+        });
+    });
+    return options;
+}
+function createAddfileattachmentField(installedField) {
+    const field = Object.assign(Object.assign({}, generateNewFormField(AppFormItemTypes.ADDFILEATTACHMENT, false)), { id: installedField.name, mandatory: installedField.mandatory });
+    field.properties[0].value = installedField.label;
+    return field;
+}
+function createHtmlField(formItem) {
+    const field = Object.assign(Object.assign({}, generateNewFormField(AppFormItemTypes.CODEHTML, false)), { id: formItem.name });
+    field.properties[0].value = formItem.properties.code;
+    return field;
+}
+function createImageField() {
+    const field = generateNewFormField(AppFormItemTypes.IMAGE, false);
+    return field;
+}
+function createNumberField(installedField) {
+    var _a;
+    const field = _initField(AppFormItemTypes.NUMBER, installedField);
+    field.properties[2].value = ((_a = installedField.widget.params) === null || _a === void 0 ? void 0 : _a.step) === '0.01';
+    return field;
+}
+function createTagsField(installedField) {
+    var _a, _b;
+    const field = _initField(AppFormItemTypes.TAGS, installedField);
+    field.properties[2].value.id = +((_b = (_a = installedField.widget.params) === null || _a === void 0 ? void 0 : _a.idTaxonomy) !== null && _b !== void 0 ? _b : 1);
+    return field;
+}
+function createSelectField(installedField) {
+    var _a, _b, _c, _d, _e;
+    const field = _initField(AppFormItemTypes.SELECT, installedField);
+    const defaultValue = ((_a = installedField.widget.params) === null || _a === void 0 ? void 0 : _a.defaultValue)
+        ? {
+            title: installedField.widget.options[(_b = installedField.widget.params) === null || _b === void 0 ? void 0 : _b.defaultValue],
+            value: (_c = installedField.widget.params) === null || _c === void 0 ? void 0 : _c.defaultValue,
+        }
+        : undefined;
+    const optionsEditorValue = {
+        propertyOptions: _getOptions(installedField.widget.options),
+        canSelectMultiple: installedField.widget.multiple === '1',
+        userCanModifiyByComment: ((_d = installedField.widget.params) === null || _d === void 0 ? void 0 : _d.explain) === '1',
+        defaultSelectOption: !!((_e = installedField.widget.params) === null || _e === void 0 ? void 0 : _e.defaultValue),
+        defaultSelectOptionValue: defaultValue,
+    };
+    field.properties[2].value = optionsEditorValue;
+    return field;
+}
+function createRadioField(installedField) {
+    const field = _initField(AppFormItemTypes.RADIO, installedField);
+    const optionsEditorValue = {
+        propertyOptions: _getOptions(installedField.widget.options),
+    };
+    field.properties[2].value = optionsEditorValue;
+    return field;
+}
+function createCheckboxField(installedField) {
+    const field = createRadioField(installedField);
+    field.type = AppFormItemTypes.CHECKBOX;
+    return field;
+}
+function createContentLinkField(installedField, state) {
+    var _a, _b;
+    const field = _initField(AppFormItemTypes.CONTENTLINK, installedField);
+    field.properties[2].value.type = (_a = installedField.widget.params.types) !== null && _a !== void 0 ? _a : 'mpArticle';
+    const modelState = state.entities === undefined ? undefined : { entities: state.entities };
+    const model = modelState ? Model.selectors.selectById(modelState, field.properties[2].value.type) : undefined;
+    field.properties[2].value.label = (_b = model === null || model === void 0 ? void 0 : model.label) !== null && _b !== void 0 ? _b : 'Article';
+    return field;
+}
+function createTextField(installedField) {
+    const field = _initField(AppFormItemTypes.TEXT, installedField);
+    return field;
+}
+function createDescriptionField(installedField) {
+    const field = _initField(AppFormItemTypes.DESCRIPTION, installedField);
+    return field;
+}
+function createTextareaHTMLField(installedField) {
+    const field = _initField(AppFormItemTypes.TEXTAREAHTML, installedField);
+    return field;
+}
+function createDateField(installedField) {
+    const field = _initField(AppFormItemTypes.DATE, installedField);
+    return field;
+}
+function createDatetimeField(installedField) {
+    const field = _initField(AppFormItemTypes.DATETIME, installedField);
+    return field;
+}
+function createUrlField(installedField) {
+    const field = _initField(AppFormItemTypes.URL, installedField);
+    return field;
+}
+function createEmailField(installedField) {
+    const field = _initField(AppFormItemTypes.EMAIL, installedField);
+    return field;
+}
+function createToggleField(installedField) {
+    const field = _initField(AppFormItemTypes.TOGGLE, installedField);
+    return field;
+}
+function createUserLinkField(installedField) {
+    const field = _initField(AppFormItemTypes.USERLINK, installedField);
+    return field;
+}
+function createTextAreaField(installedField) {
+    const field = _initField(AppFormItemTypes.TEXTAREA, installedField);
+    return field;
+}
+
+const installedToV2ViewNames = {
+    'create-popup': 'popup',
+    create: 'create',
+    edit: 'edit',
+    display: 'view',
+};
+const specialAttrName = ['title', 'alertAuthor', 'sendAlert'];
+const ignoredFields = ['edito'];
+function updateViewsFromFields(clonedApp, appFields) {
+    return Object.assign({}, ...viewsList.map((view) => {
+        const viewItems = {};
+        Object.entries(clonedApp.views[view]).forEach(([fieldId, field]) => {
+            if (field.isFixed) {
+                viewItems[fieldId] = field;
+            }
+            if (field.isOptional) {
+                viewItems[fieldId] = field;
+            }
+        });
+        appFields.forEach((field, idx) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const isFieldUsedInView = field.views[view];
+            const isExistingField = Object.keys(clonedApp.views[view]).includes(field.id);
+            const fieldType = field.type;
+            if (AppFormBannedFromViews$1.get(fieldType) && ((_a = AppFormBannedFromViews$1.get(fieldType)) === null || _a === void 0 ? void 0 : _a.includes(view))) {
+                return;
+            }
+            let fieldValue = undefined;
+            if (fieldType === AppFormItemTypes.CODEHTML) {
+                const richTextProperty = (_b = field.properties) === null || _b === void 0 ? void 0 : _b.find((prop) => prop.propertyType === AppFieldFormPropertyTypes.RICHTEXT);
+                if (richTextProperty === null || richTextProperty === void 0 ? void 0 : richTextProperty.value) {
+                    fieldValue = richTextProperty === null || richTextProperty === void 0 ? void 0 : richTextProperty.value;
+                }
+            }
+            if (fieldType === AppFormItemTypes.SELECT) {
+                const selectProperty = (_c = field.properties) === null || _c === void 0 ? void 0 : _c.find((prop) => prop.propertyType === AppFieldFormPropertyTypes.OPTIONS_EDITOR);
+                if (isExistingField) {
+                    const exField = clonedApp.views[view][field.id];
+                    const exSelectProperty = (_d = exField.properties) === null || _d === void 0 ? void 0 : _d.find((prop) => prop.propertyType === AppFieldFormPropertyTypes.OPTIONS_EDITOR);
+                    const isMultivalued = !!((_e = selectProperty === null || selectProperty === void 0 ? void 0 : selectProperty.value) === null || _e === void 0 ? void 0 : _e.canSelectMultiple);
+                    const exIsMultivalued = !!((_f = exSelectProperty === null || exSelectProperty === void 0 ? void 0 : exSelectProperty.value) === null || _f === void 0 ? void 0 : _f.canSelectMultiple);
+                    if (isMultivalued === exIsMultivalued) {
+                        fieldValue = exField.value;
+                    }
+                }
+                else {
+                    const isEnhancedSelect = !!(selectProperty === null || selectProperty === void 0 ? void 0 : selectProperty.isOptionsEditorEnhanced);
+                    const defaultValue = isEnhancedSelect && !!(selectProperty === null || selectProperty === void 0 ? void 0 : selectProperty.value.defaultSelectOption)
+                        ? selectProperty === null || selectProperty === void 0 ? void 0 : selectProperty.value.defaultSelectOptionValue
+                        : '';
+                    if (defaultValue) {
+                        fieldValue = defaultValue;
+                    }
+                }
+            }
+            if (isExistingField) {
+                const exField = clonedApp.views[view][field.id];
+                viewItems[field.id] = Object.assign(Object.assign(Object.assign(Object.assign({}, exField), { properties: field.properties || exField.properties || [] }), (fieldValue !== undefined && { value: fieldValue })), { isUsed: isFieldUsedInView, pos: ((_g = clonedApp.syncViewFieldOrder) === null || _g === void 0 ? void 0 : _g[view]) ? idx : exField.pos, isLockedValue: (fieldValue !== undefined || exField.value !== undefined) && exField.isLockedValue });
+            }
+            else {
+                const existingFieldsLen = Object.values(clonedApp.views[view]).filter((v) => !v.isFixed && !v.isOptional).length;
+                viewItems[field.id] = {
+                    type: field.type,
+                    properties: field.properties || [],
+                    isUsed: isFieldUsedInView,
+                    isOptional: false,
+                    isLockedValue: false,
+                    isFixed: false,
+                    value: fieldValue !== null && fieldValue !== void 0 ? fieldValue : null,
+                    pos: ((_h = clonedApp.syncViewFieldOrder) === null || _h === void 0 ? void 0 : _h[view]) ? idx : existingFieldsLen + idx,
+                };
+            }
+        });
+        return {
+            [view]: viewItems,
+        };
+    }));
+}
+function buildAudience(accessRightObjectList) {
+    return accessRightObjectList.map((accessRightObject) => {
+        return {
+            id: `${accessRightObject.type}/${accessRightObject.id}`,
+            uri: `${accessRightObject.type}/${accessRightObject.id}`,
+            shortUri: `${accessRightObject.type}/${accessRightObject.id}`,
+            title: accessRightObject.title,
+            name: accessRightObject.title,
+            mainType: accessRightObject.type,
+            type: accessRightObject.mainType,
+            label: accessRightObject.type,
+            cssClass: accessRightObject._cssClass,
+            cssColor: accessRightObject._cssColor,
+            class: accessRightObject._cssClass,
+            Pseudo: accessRightObject.title,
+            _url: accessRightObject._url,
+        };
+    });
+}
+function populateFieldsAndViews(app, appS, state) {
+    const tables = app.typeModel.tables;
+    const displays = app.typeModel.displays;
+    if (!displays) {
+        return;
+    }
+    const registeredFields = new Map();
+    Object.entries(displays).forEach((displaysEntry) => {
+        const [displayName, displayValue] = displaysEntry;
+        if (Object.keys(installedToV2ViewNames).includes(displayName)) {
+            buildView(appS, registeredFields, displayName, displayValue, tables, state);
+        }
+    });
+    buildListView(appS, registeredFields, app.columns, tables, state);
+    buildFilterView(appS, registeredFields, app.attrExposed, tables, state);
+}
+function buildView(appS, registeredFields, displayName, displayValue, tables, state) {
+    const newName = installedToV2ViewNames[displayName];
+    appS.views[newName] = {};
+    displayValue.composants.forEach((viewComponent, index) => {
+        let field = undefined;
+        if (viewComponent.name && ignoredFields.includes(viewComponent.name)) {
+            return;
+        }
+        const [fieldIdx, fixedInfo] = createOrGetField(appS, registeredFields, viewComponent, tables, state);
+        if (fieldIdx === -1 && fixedInfo) {
+            switch (fixedInfo.ref) {
+                case 'title':
+                    addTitleToView(newName, appS, fixedInfo);
+                    break;
+                case 'alertAuthor':
+                    addAlertAuthorToView(newName, appS, fixedInfo);
+                    break;
+                case 'sendAlert':
+                    addSendAlertToView(newName, appS, fixedInfo);
+                    break;
+                case 'publishTo':
+                    addPublishToToView(newName, appS, fixedInfo);
+                    break;
+                default:
+                    console.error('fixed field info with unsupported ref ', fixedInfo);
+                    break;
+            }
+        }
+        else if (fieldIdx !== -1) {
+            field = appS.fields[fieldIdx];
+            if (!field || !field.views) {
+                throw new Error(`error converting installed app to V2: created field not found in fields array: ${fieldIdx}, ${fixedInfo}`);
+            }
+            field.views[newName] = true;
+            addFieldToView(newName, field, appS, index, fixedInfo);
+        }
+    });
+}
+function buildListView(appS, registeredFields, columns, tables, state) {
+    if (!columns) {
+        return;
+    }
+    Object.keys(columns).forEach((fieldRef, index) => {
+        addFieldToViewFromRef(appS, registeredFields, tables, 'list', fieldRef, index, state);
+    });
+}
+function buildFilterView(appS, registeredFields, attrExposed, tables, state) {
+    attrExposed.forEach((fieldRef, index) => {
+        addFieldToViewFromRef(appS, registeredFields, tables, 'filter', fieldRef, index, state);
+    });
+}
+function addFieldToViewFromRef(appS, registeredFields, tables, viewName, fieldRef, index, state) {
+    switch (fieldRef) {
+        case 'title':
+            addTitleToView(viewName, appS, { ref: 'title', fixedValue: undefined });
+            break;
+        case 'iduser':
+        case 'idUser':
+            addUserToView(viewName, appS);
+            break;
+        case 'datecreation':
+        case 'dateCreation':
+            addDateCreationToView(viewName, appS);
+            break;
+        default:
+            defaultFieldCreation(appS, registeredFields, tables, viewName, fieldRef, index, state);
+            break;
+    }
+}
+function defaultFieldCreation(appS, registeredFields, tables, viewName, fieldRef, index, state) {
+    const fieldIndex = createOrGetFieldFromRef(appS, registeredFields, tables, fieldRef, state);
+    const field = appS.fields[fieldIndex];
+    if (!field || !field.views) {
+        throw new Error(`error converting installed app to V2: unable to handle ${fieldRef} in list view`);
+    }
+    field.views[viewName] = true;
+    addFieldToView(viewName, field, appS, index, undefined);
+}
+function createOrGetFieldFromRef(appS, registeredFields, tables, fieldRef, state) {
+    const knownIndex = registeredFields.get(fieldRef);
+    if (knownIndex !== undefined) {
+        return knownIndex;
+    }
+    const [ref, indexCreated] = createStudioDefinedField(appS, fieldRef, tables, state);
+    registeredFields.set(ref, indexCreated);
+    return indexCreated;
+}
+function createOrGetField(appS, registeredFields, viewComponent, tables, state) {
+    if (viewComponent.name !== undefined && viewComponent.element === 'attr') {
+        if (specialAttrName.includes(viewComponent.name)) {
+            return [-1, { ref: viewComponent.name, fixedValue: undefined }];
+        }
+        const knownIndex = registeredFields.get(viewComponent.name);
+        if (knownIndex !== undefined) {
+            return [knownIndex, undefined];
+        }
+        const [ref, indexCreated] = createStudioDefinedField(appS, viewComponent.name, tables, state);
+        registeredFields.set(ref, indexCreated);
+        return [indexCreated, undefined];
+    }
+    else if (viewComponent.element === 'html') {
+        const htmlCode = viewComponent.html;
+        if (htmlCode === undefined) {
+            console.error('error while parsing studio installed html attr in a view: no html code');
+            return [-1, undefined];
+        }
+        if (htmlCode.includes('<JAMESPOT.STUDIO.FIXED>')) {
+            const startPos = htmlCode.indexOf('<JAMESPOT.STUDIO.FIXED>') + '<JAMESPOT.STUDIO.FIXED>'.length;
+            const endPos = htmlCode.indexOf('</JAMESPOT.STUDIO.FIXED>');
+            const formItemRefString = htmlCode.substring(startPos, endPos);
+            try {
+                const formItemRef = JSON.parse(formItemRefString);
+                if ((formItemRef === null || formItemRef === void 0 ? void 0 : formItemRef.ref.toUpperCase()) in ExtraAppFieldsItemViews ||
+                    specialAttrName.includes(formItemRef === null || formItemRef === void 0 ? void 0 : formItemRef.ref)) {
+                    return [-1, formItemRef];
+                }
+                const knownIndex = registeredFields.get(formItemRef === null || formItemRef === void 0 ? void 0 : formItemRef.ref);
+                if (knownIndex !== undefined) {
+                    return [knownIndex, formItemRef];
+                }
+                const [ref, indexCreated] = createStudioDefinedField(appS, formItemRef.ref, tables, state);
+                registeredFields.set(ref, indexCreated);
+                return [indexCreated, formItemRef];
+            }
+            catch (_) {
+                console.error('error while parsing studio installed fixed attr in a view: json parsing failed');
+                return [-1, undefined];
+            }
+        }
+        else if (htmlCode.includes('<JAMESPOT.STUDIO.CODEHTML>')) {
+            try {
+                const startPosCode = htmlCode.indexOf('<JAMESPOT.STUDIO.CODEHTML>') + '<JAMESPOT.STUDIO.CODEHTML>'.length;
+                const endPosCode = htmlCode.indexOf('</JAMESPOT.STUDIO.CODEHTML>');
+                const formItemString = htmlCode.substring(startPosCode, endPosCode);
+                const formItem = JSON.parse(formItemString);
+                const knownIndex = registeredFields.get(formItem === null || formItem === void 0 ? void 0 : formItem.name);
+                if (knownIndex !== undefined) {
+                    return [knownIndex, undefined];
+                }
+                const htmlField = createHtmlField(formItem);
+                const indexCreated = appS.fields.push(htmlField) - 1;
+                registeredFields.set(htmlField.id, indexCreated);
+                return [indexCreated, undefined];
+            }
+            catch (_) {
+                console.error('error while parsing studio installed codehtml attr in a view: json parsing failed');
+                return [-1, undefined];
+            }
+        }
+        else {
+            console.error('error while parsing studio installed html attr in a view: unknown html format');
+            return [-1, undefined];
+        }
+    }
+    else if (viewComponent.element === 'image') {
+        const knownIndex = registeredFields.get('image');
+        if (knownIndex !== undefined) {
+            return [knownIndex, undefined];
+        }
+        const imageField = createImageField();
+        const indexCreated = appS.fields.push(imageField) - 1;
+        registeredFields.set('image', indexCreated);
+        return [indexCreated, undefined];
+    }
+    else if (viewComponent.element === 'publishTo') {
+        return [-1, { ref: 'publishTo', fixedValue: undefined }];
+    }
+    else {
+        console.error('error while parsing studio installed attr in a view: unknown attr :O');
+        return [-1, undefined];
+    }
+}
+function createStudioDefinedField(appS, ref, tables, state) {
+    const installedField = getInstalledField(ref, tables);
+    const type = getFormItemType(installedField);
+    const v2Field = (function createField() {
+        switch (type) {
+            case AppFormItemTypes.ADDFILEATTACHMENT:
+                return createAddfileattachmentField(installedField);
+            case AppFormItemTypes.NUMBER:
+                return createNumberField(installedField);
+            case AppFormItemTypes.TAGS:
+                return createTagsField(installedField);
+            case AppFormItemTypes.SELECT:
+                return createSelectField(installedField);
+            case AppFormItemTypes.RADIO:
+                return createRadioField(installedField);
+            case AppFormItemTypes.CHECKBOX:
+                return createCheckboxField(installedField);
+            case AppFormItemTypes.CONTENTLINK:
+                return createContentLinkField(installedField, state);
+            case AppFormItemTypes.DESCRIPTION:
+                return createDescriptionField(installedField);
+            case AppFormItemTypes.TEXTAREAHTML:
+                return createTextareaHTMLField(installedField);
+            case AppFormItemTypes.DATE:
+                return createDateField(installedField);
+            case AppFormItemTypes.DATETIME:
+                return createDatetimeField(installedField);
+            case AppFormItemTypes.URL:
+                return createUrlField(installedField);
+            case AppFormItemTypes.EMAIL:
+                return createEmailField(installedField);
+            case AppFormItemTypes.TOGGLE:
+                return createToggleField(installedField);
+            case AppFormItemTypes.USERLINK:
+                return createUserLinkField(installedField);
+            case AppFormItemTypes.TEXTAREA:
+                return createTextAreaField(installedField);
+            case AppFormItemTypes.TEXT:
+            default:
+                return createTextField(installedField);
+        }
+    })();
+    const index = appS.fields.push(v2Field) - 1;
+    return [ref, index];
+}
+function getInstalledField(ref, tables) {
+    var _a;
+    let foundField = undefined;
+    for (let i = 0; i < tables.length && !foundField; i++) {
+        foundField = (_a = tables[i]) === null || _a === void 0 ? void 0 : _a.attributes.find((attr) => {
+            return attr.name === ref;
+        });
+    }
+    if (!foundField) {
+        throw new Error('error converting installed app to V2: installed field not found in tables ' + ref);
+    }
+    return foundField;
+}
+function addFieldToView(viewName, field, appS, index, fixedInfo) {
+    var _a;
+    if (field.views) {
+        field.views[viewName] = true;
+        appS.views[viewName][field.id] = {
+            type: field.type,
+            properties: field.properties || [],
+            isUsed: true,
+            isOptional: false,
+            isLockedValue: !!(fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue),
+            isFixed: false,
+            value: (_a = fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== null && _a !== void 0 ? _a : null,
+            pos: index,
+        };
+    }
+}
+function getFormItemType(installedField) {
+    var _a, _b, _c;
+    switch (installedField.widget.type) {
+        case 'number':
+            return AppFormItemTypes.NUMBER;
+        case 'taxonomy':
+            return AppFormItemTypes.TAGS;
+        case 'date':
+            return AppFormItemTypes.DATE;
+        case 'datetime':
+            return AppFormItemTypes.DATETIME;
+        case 'select':
+            return AppFormItemTypes.SELECT;
+        case 'radio':
+            return AppFormItemTypes.RADIO;
+        case 'url':
+            return AppFormItemTypes.URL;
+        case 'email':
+            return AppFormItemTypes.EMAIL;
+        case 'file':
+            return AppFormItemTypes.ADDFILEATTACHMENT;
+        case 'checkbox':
+            if (((_a = installedField.widget.options) === null || _a === void 0 ? void 0 : _a['1']) === 'GLOBAL_Yes') {
+                return AppFormItemTypes.TOGGLE;
+            }
+            return AppFormItemTypes.CHECKBOX;
+        case 'uri':
+            if (((_b = installedField.widget.params) === null || _b === void 0 ? void 0 : _b.views) === 'user') {
+                return AppFormItemTypes.USERLINK;
+            }
+            if (((_c = installedField.widget.params) === null || _c === void 0 ? void 0 : _c.views) === 'article') {
+                return AppFormItemTypes.CONTENTLINK;
+            }
+            break;
+        case 'textarea':
+            if (installedField.attrType === 'longtext') {
+                return AppFormItemTypes.TEXTAREA;
+            }
+            if (installedField.attrType === 'html') {
+                if (installedField.name === 'description') {
+                    return AppFormItemTypes.DESCRIPTION;
+                }
+                return AppFormItemTypes.TEXTAREAHTML;
+            }
+            break;
+        case 'text':
+            return AppFormItemTypes.TEXT;
+    }
+    throw new Error('error converting installed app to V2: installed field type not recognized for field ' + installedField.name);
+}
+function addTitleToView(newName, appS, fixedInfo) {
+    var _a;
+    const fieldId = 'title';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.TITLE,
+        properties: [],
+        isUsed: true,
+        isOptional: false,
+        isLockedValue: !!(fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue),
+        isFixed: true,
+        value: (_a = fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== null && _a !== void 0 ? _a : null,
+        pos: 0,
+    };
+}
+function addAlertAuthorToView(newName, appS, fixedInfo) {
+    const fieldId = 'alertAuthor';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.RECEIVEACOPY,
+        properties: [],
+        isUsed: true,
+        isOptional: true,
+        isLockedValue: (fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== undefined,
+        isFixed: false,
+        value: (fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== undefined ? fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue : true,
+        pos: 300,
+    };
+}
+function addSendAlertToView(newName, appS, fixedInfo) {
+    const fieldId = 'sendAlert';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.SENDALERTTOSUBSCRIBERS,
+        properties: [],
+        isUsed: true,
+        isOptional: true,
+        isLockedValue: (fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== undefined,
+        isFixed: false,
+        value: (fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== undefined ? fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue : true,
+        pos: 200,
+    };
+}
+function addPublishToToView(newName, appS, fixedInfo) {
+    var _a;
+    const fieldId = 'publishTo';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.PUBLISHTO,
+        properties: [],
+        isUsed: true,
+        isOptional: true,
+        isLockedValue: !!(fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue),
+        isFixed: false,
+        value: (_a = fixedInfo === null || fixedInfo === void 0 ? void 0 : fixedInfo.fixedValue) !== null && _a !== void 0 ? _a : [],
+        pos: 100,
+    };
+}
+function addUserToView(newName, appS) {
+    const fieldId = 'user';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.USER,
+        properties: [],
+        isUsed: true,
+        isOptional: false,
+        isLockedValue: false,
+        isFixed: true,
+        value: null,
+        pos: 1,
+    };
+}
+function addDateCreationToView(newName, appS) {
+    const fieldId = 'dateCreation';
+    appS.views[newName][fieldId] = {
+        type: ExtraAppFieldsItemViews.CREATIONDATE,
+        properties: [],
+        isUsed: true,
+        isOptional: true,
+        isLockedValue: false,
+        isFixed: false,
+        value: null,
+        pos: 100,
+    };
+}
+
+function InstalledAppStudioAdapter(serverApp, serverApps, state) {
     var _a, _b, _c, _d;
     const { version, dateCreation } = serverApp.manifest;
     const appTypeServer = serverApp.typeModel;
     const views = Object.assign({}, ...viewsList.map((view) => ({
-        [view]: [],
+        [view]: {},
     })));
     const studioApp = {
         idApp: serverApp.idApp,
         status: _formatStatus(serverApp),
         studioVersion: 2,
-        manifest: Object.assign({ appShortName: serverApp.name, appName: serverApp.label, description: serverApp.description, author: serverApp.author, cssColor: (_a = appTypeServer.cssColor) !== null && _a !== void 0 ? _a : '#392994', cssClass: { label: (_b = appTypeServer.cssClass) !== null && _b !== void 0 ? _b : 'star', value: (_c = appTypeServer.cssClass) !== null && _c !== void 0 ? _c : 'star' }, version: version, dateCreation: dateCreation, checkAccess: serverApp.checkAccess, attrExposed: serverApp.attrExposed, viewSolr: serverApp.view, typeLabel: (_d = appTypeServer.typeLabel) !== null && _d !== void 0 ? _d : {} }, (serverApp.articlesCount && { articlesCount: serverApp.articlesCount })),
+        manifest: {
+            appShortName: serverApp.label,
+            appName: serverApp.label,
+            description: serverApp.description,
+            author: serverApp.author,
+            cssColor: (_a = appTypeServer.cssColor) !== null && _a !== void 0 ? _a : '#392994',
+            cssClass: { label: (_b = appTypeServer.cssClass) !== null && _b !== void 0 ? _b : 'star', value: (_c = appTypeServer.cssClass) !== null && _c !== void 0 ? _c : 'star' },
+            version: version,
+            dateCreation: dateCreation,
+            checkAccess: false,
+            accessRightList: "",
+            attrExposed: [],
+            viewSolr: serverApp.view ? STUDIO_VIEW.SOLR : STUDIO_VIEW.NOT_SOLR,
+            typeLabel: appTypeServer.typeLabel,
+            articlesCount: (_d = serverApp.articlesCount) !== null && _d !== void 0 ? _d : 0,
+        },
         fields: [],
         views,
-        installFor: serverApp.accessRightObjectList,
+        installFor: serverApp.accessRightObjectList ? buildAudience(serverApp.accessRightObjectList) : [],
         audience: serverApp.checkAccess === false ? AUDIENCE.ALL : AUDIENCE.CUSTOM,
     };
+    populateFieldsAndViews(serverApp, studioApp, state);
+    studioApp.views = updateViewsFromFields(studioApp, studioApp.fields);
     const inWorkAppVersion = _findAssociatedDraft(serverApp.idApp, serverApps);
     if (!inWorkAppVersion)
         return studioApp;
@@ -3170,12 +3922,13 @@ function DraftAppStudioAdapter(serverApp) {
             manifest: parsedJson.manifest,
             fields: parsedJson.fields,
             views: parsedJson.views,
+            syncViewFieldOrder: parsedJson.syncViewFieldOrder,
             audience: parsedJson.audience,
             installFor: parsedJson.installFor,
         };
     }
     else {
-        return Object.assign(Object.assign({}, migrateJson(JSON.parse(serverApp.value))), { status: _formatStatus(serverApp) });
+        return Object.assign(Object.assign({}, migrateJson(parsedJson)), { status: _formatStatus(serverApp), migratedFrom: 1 });
     }
 }
 function _formatStatus(serverApp) {
@@ -3192,11 +3945,11 @@ function _findAssociatedDraft(idApp, serverApps) {
 function _findAssociatedInstalled(idApp, serverApps) {
     return !!serverApps.find((app) => app.idApp === idApp && app.status === StudioApplicationStatus.installed);
 }
-function serverAppsToStudioApps(serverApps) {
+function serverAppsToStudioApps(serverApps, state) {
     const studioApps = serverApps
         .map((serverApp) => {
         if (serverApp.status === StudioApplicationStatus.installed) {
-            return InstalledAppStudioAdapter(serverApp, serverApps);
+            return InstalledAppStudioAdapter(serverApp, serverApps, state);
         }
         else {
             if (_findAssociatedInstalled(serverApp.idApp, serverApps))
@@ -3262,7 +4015,13 @@ function renderAppView(viewSolr, listView) {
     if (viewSolr === STUDIO_VIEW.SOLR) {
         let xml = '<AppView>solr</AppView>';
         const formItemIdInList = [];
-        Object.entries(listView).forEach(([fieldId, field]) => {
+        Object.entries(listView).sort((a, b) => a[1].pos - b[1].pos).forEach(([fieldId, field]) => {
+            if (!field.isUsed) {
+                return;
+            }
+            if ([AppFormItemTypes.IMAGE].includes(field.type)) {
+                return;
+            }
             formItemIdInList.push(getAttrNameFormItem(field, fieldId));
         });
         xml += `<AppColumns>${formItemIdInList.join()}</AppColumns>`;
@@ -3272,8 +4031,12 @@ function renderAppView(viewSolr, listView) {
 }
 function renderAppSearch(searchView) {
     const formItemIdInFilter = [];
-    Object.entries(searchView).forEach(([fieldId, field]) => {
-        if (![ExtraAppFieldsItemViews.TITLE, AppFormItemTypes.IMAGE].includes(field.type))
+    Object.entries(searchView).sort((a, b) => a[1].pos - b[1].pos).forEach(([fieldId, field]) => {
+        if (!field.isUsed) {
+            return;
+        }
+        const list = [ExtraAppFieldsItemViews.TITLE, AppFormItemTypes.IMAGE];
+        if (!list.includes(field.type))
             formItemIdInFilter.push(getAttrNameFormItem(field, fieldId));
     });
     return `<AttrExposed>${formItemIdInFilter.join()}</AttrExposed>`;
@@ -3308,13 +4071,13 @@ function renderAudience(audience, installFor) {
     return '';
 }
 function renderPrimaryFields(fields) {
-    const primaryFields = fields === null || fields === void 0 ? void 0 : fields.filter((field) => AppFormPrimaryList.includes(field.type));
+    const primaryFields = fields === null || fields === void 0 ? void 0 : fields.filter((field) => AppFormPrimaryListValues.includes(field.type));
     if (primaryFields.length === 0)
         return '';
     return `<primaryFields>${primaryFields.map((field) => formItem2xml(field)).join('')}</primaryFields>`;
 }
 function renderCustomFields(fields) {
-    const customFields = fields === null || fields === void 0 ? void 0 : fields.filter((field) => !AppFormPrimaryList.includes(field.type));
+    const customFields = fields === null || fields === void 0 ? void 0 : fields.filter((field) => !AppFormPrimaryListValues.includes(field.type));
     const filteredCustomFields = customFields === null || customFields === void 0 ? void 0 : customFields.filter((field) => field.type !== AppFormItemTypes.IMAGE);
     if (filteredCustomFields.length === 0)
         return '';
@@ -3380,14 +4143,20 @@ function renderWidget(fieldType, fieldProperties) {
             const isMultiple = optionEditor.value.canSelectMultiple;
             const options = optionEditor.value.propertyOptions;
             const hasDefaultValue = optionEditor.value.defaultSelectOption;
-            const defaultValue = optionEditor.value.defaultSelectOptionValue;
+            const defaultValue = optionEditor.value.defaultSelectOptionValue.value;
+            const userCanModifiyByComment = optionEditor.value.userCanModifiyByComment;
             return `<widget form="select" ${isMultiple ? 'multiple="1"' : ''}>
             <options>
                 ${options
                 .map((option) => `<option value="${option.value}" label="${option.title}"></option>`)
                 .join('')}
             </options>
-            ${hasDefaultValue ? `<params><param key="defaultValue" value="${defaultValue}"/></params>` : ''}
+            ${hasDefaultValue || userCanModifiyByComment
+                ? `<params>
+                ${hasDefaultValue ? `<param key="defaultValue" value="${defaultValue}"/>` : ''}
+                ${userCanModifiyByComment ? `<param key="explain" value="1"/>` : ''}
+            </params>`
+                : ''}
             </widget>`;
         }
         case AppFormItemTypes.RADIO: {
@@ -3526,9 +4295,7 @@ function renderFieldTypeToXmlType(fieldType) {
         case AppFormItemTypes.TAGS:
             return 'taxonomy';
         case AppFormItemTypes.TEXT:
-        case AppFormItemTypes.SELECT:
         case AppFormItemTypes.RADIO:
-        case AppFormItemTypes.CHECKBOX:
         case AppFormItemTypes.URL:
         case AppFormItemTypes.EMAIL:
         case AppFormItemTypes.ADDFILEATTACHMENT:
@@ -3537,6 +4304,8 @@ function renderFieldTypeToXmlType(fieldType) {
         case AppFormItemTypes.CONTENTLINK:
             return 'text';
         case AppFormItemTypes.TEXTAREA:
+        case AppFormItemTypes.CHECKBOX:
+        case AppFormItemTypes.SELECT:
             return 'longtext';
         case AppFormItemTypes.DATE:
             return 'date';
@@ -3577,7 +4346,9 @@ function renderDisplays(studioApp) {
     let toRet = '';
     Object.entries(studioApp.views).forEach(([viewName, viewContent]) => {
         if (Object.prototype.hasOwnProperty.call(internal2XmlView, viewName)) {
-            const viewField = Object.entries(viewContent);
+            const viewField = Object.entries(viewContent)
+                .filter((a) => a[1].isUsed)
+                .sort((a, b) => a[1].pos - b[1].pos);
             toRet += `<display view="${internal2XmlView[viewName]}" mode="${viewName === 'view' ? 'view' : 'form'}">
                 ${viewField.map(([fieldId, view]) => renderDisplayAttr(fieldId, view)).join('')}
             </display>`;
@@ -3629,16 +4400,21 @@ function renderDisplayAttr(fieldId, view) {
             xml += `<input type="hidden" name="${attrName}[]" value=${JSON.stringify(view.value.uri)}>`;
         }
         else if (view.type === AppFormItemTypes.SELECT) {
-            const values = view.value;
             const canSelectMultiple = (_a = view.properties.find((property) => property.propertyType === AppFieldFormPropertyTypes.OPTIONS_EDITOR)) === null || _a === void 0 ? void 0 : _a.value.canSelectMultiple;
-            values.forEach((value) => {
-                xml += `<input type="hidden" name="${attrName}${canSelectMultiple ? '[]' : ''}" value="${value.value}">`;
-            });
+            if (canSelectMultiple) {
+                const values = view.value;
+                values.forEach((value) => {
+                    xml += `<input type="hidden" name="${attrName}[]" value="${value.value}">`;
+                });
+            }
+            else {
+                xml += `<input type="hidden" name="${attrName}" value="${view.value.value}">`;
+            }
         }
         else if (view.type === AppFormItemTypes.CHECKBOX) {
             const values = view.value;
             values.forEach((value) => {
-                xml += `<input type="hidden" name="${attrName}[]" value="${value.value}">`;
+                xml += `<input type="hidden" name="${attrName}[]" value="${value}">`;
             });
         }
         else if (view.type === AppFormItemTypes.DATE) {
@@ -3652,21 +4428,28 @@ function renderDisplayAttr(fieldId, view) {
         }
         else if (view.type === AppFormItemTypes.DATETIME) {
             const dateValue = new Date(view.value);
-            const xmlFixedValue = [
+            const xmlFixedValue = `${[
                 pad(dateValue.getDate()),
                 pad(dateValue.getMonth() + 1),
                 dateValue.getFullYear(),
-                pad(dateValue.getHours()),
-                pad(dateValue.getMinutes()),
-                pad(dateValue.getSeconds()),
-            ].join('/');
+            ].join('/')} ${pad(dateValue.getHours())}:${pad(dateValue.getMinutes())}:${pad(dateValue.getSeconds())}`;
             xml += '<input type="hidden" name="' + attrName + '" value="' + xmlFixedValue + '">';
         }
         else if (view.type === AppFormItemTypes.TAGS) {
             xml += `<input type="hidden" name="${attrName}" value="${(_c = (_b = view.value) === null || _b === void 0 ? void 0 : _b.map((v) => v.uri)) === null || _c === void 0 ? void 0 : _c.join(',')}">`;
         }
         else if (view.type === AppFormItemTypes.DESCRIPTION || view.type === AppFormItemTypes.TEXTAREAHTML) {
-            xml += `<input type="hidden" name="${attrName}" value="${view.value.html}">`;
+            xml += `<input type="hidden" name="${attrName}" value="${view.value}">`;
+        }
+        else if (view.type === ExtraAppFieldsItemViews.RECEIVEACOPY) {
+            if (view.value) {
+                xml += `<input type="hidden" name="alertAuthor[jamespot]"><input type="hidden" name="alertAuthor[]" value="1">`;
+            }
+        }
+        else if (view.type === ExtraAppFieldsItemViews.SENDALERTTOSUBSCRIBERS) {
+            if (view.value) {
+                xml += `<input type="hidden" name="sendAlert[jamespot]"><input type="hidden" name="sendAlert[]" value="1">`;
+            }
         }
         else {
             xml += `<input type="hidden" name="${attrName}" value="${view.value}">`;
@@ -3676,7 +4459,14 @@ function renderDisplayAttr(fieldId, view) {
     else {
         switch (view.type) {
             case AppFormItemTypes.CODEHTML: {
-                xml += `<html><![CDATA[ <!-- <JAMESPOT.STUDIO.CODEHTML>${view.value}</JAMESPOT.STUDIO.CODEHTML><JAMESPOT.STUDIO.FIELD_POS>${view.pos}</JAMESPOT.STUDIO.FIELD_POS>-->${view.value}]]></html>`;
+                const fieldToInclude = {
+                    id: fieldId,
+                    name: fieldId,
+                    properties: {
+                        code: view.value,
+                    },
+                };
+                xml += `<html><![CDATA[ <!-- <JAMESPOT.STUDIO.CODEHTML>${JSON.stringify(fieldToInclude)}</JAMESPOT.STUDIO.CODEHTML><JAMESPOT.STUDIO.FIELD_POS>${view.pos}</JAMESPOT.STUDIO.FIELD_POS>-->${view.value}]]></html>`;
                 break;
             }
             case AppFormItemTypes.IMAGE:
@@ -3703,12 +4493,12 @@ const initialState$1 = {
     installStudioAppStatus: 'idle',
     hasChanged: false,
 };
-const fetchCurrentStudioApp = createAsyncThunk('studio/fetchCurrentStudioApp', ({ idApp, status }, { extra, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchCurrentStudioApp = createAsyncThunk('studio/fetchCurrentStudioApp', ({ idApp, status }, { extra, rejectWithValue, getState }) => __awaiter(void 0, void 0, void 0, function* () {
     const jApi = extra.jApi;
     const error = { error: 1, errorMsg: 'Error fetching application' };
     try {
         const studioApplicationBase = (yield jApi.application.get(idApp, status)).result;
-        const studioApplication = serverAppsToStudioApps([studioApplicationBase])[0];
+        const studioApplication = serverAppsToStudioApps([studioApplicationBase], getState())[0];
         if (!studioApplication) {
             return rejectWithValue(error);
         }
@@ -3812,16 +4602,22 @@ const CurrentStudioAppSlice = createSlice({
     },
 });
 
-function cloneStudioAppFromExistingApp(existingApp, author) {
-    const newApp = existingApp.inWorkVersion
-        ? JSON.parse(JSON.stringify(existingApp.inWorkVersion))
+function cloneStudioAppFromExistingApp(existingApp, author, inWorkVersion) {
+    const newApp = existingApp.studioVersion !== 2
+        ? JSON.parse(JSON.stringify(migrateJson(existingApp)))
         : JSON.parse(JSON.stringify(existingApp));
-    const newAppId = v4();
-    const newAppName = `${existingApp.manifest.appName} Copie`;
-    newApp.idApp = newAppId;
-    newApp.status = APP_STATUS_TYPE.DRAFT;
-    newApp.manifest = Object.assign(Object.assign({}, newApp.manifest), { appName: newAppName, appShortName: newAppName, author: author || '', dateCreation: new Date().toISOString(), version: 0.1, articlesCount: 0 });
-    return [newApp, newAppId];
+    delete newApp.inWorkVersion;
+    if (!inWorkVersion) {
+        const newAppId = v4();
+        const newAppName = `${existingApp.manifest.appName} Copie`;
+        newApp.idApp = newAppId;
+        newApp.status = APP_STATUS_TYPE.DRAFT;
+        newApp.manifest = Object.assign(Object.assign({}, newApp.manifest), { appName: newAppName, appShortName: newAppName, author: author || newApp.manifest.author || '', dateCreation: new Date().toISOString(), version: 0.1, articlesCount: 0 });
+    }
+    else {
+        newApp.manifest.version = newApp.manifest.version + 0.1;
+    }
+    return [newApp, newApp.idApp];
 }
 
 function createNewStudioApp$1({ author, appName }) {
@@ -3883,37 +4679,78 @@ function createNewStudioApp$1({ author, appName }) {
                 attrExposed: [],
                 articlesCount: 0,
             },
+            syncViewFieldOrder: {
+                create: true,
+                popup: true,
+                view: true,
+                edit: true,
+                list: true,
+                filter: true,
+            },
             fields: [],
             views,
-            audience: AUDIENCE.ALL,
+            audience: AUDIENCE.CUSTOM,
             installFor: [],
         },
     };
 }
 
+function appLexicalSort(a, b) {
+    return a.manifest.appName > b.manifest.appName ? 1 : -1;
+}
 const initialState = {
     loadingStudioAppsList: 'idle',
     deleteStudioAppStatus: 'idle',
     suspendStudioAppStatus: 'idle',
     restartStudioAppStatus: 'idle',
     cloneStudioAppStatus: 'idle',
+    createInWorkAppStatus: 'idle',
     createNewStudioAppStatus: 'idle',
 };
-const fetchStudioAppsList = createAsyncThunk('studio/appsList', (_, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+const fetchStudioAppsList = createAsyncThunk('studio/appsList', (intl, { extra, rejectWithValue, dispatch, getState }) => __awaiter(void 0, void 0, void 0, function* () {
     const jApi = extra.jApi;
     try {
         const { result } = yield jApi.application.list();
-        return yield Promise.all(result.map((app) => __awaiter(void 0, void 0, void 0, function* () {
+        const taxonomies = yield jApi.taxonomy.list();
+        const apps = yield Promise.all(result.map((app) => __awaiter(void 0, void 0, void 0, function* () {
             const coreApp = (yield jApi.application.get(app.idApp, app.status)).result;
             const articlesCount = (yield jApi.article.count(app.idApp)).result;
             return Object.assign(Object.assign({}, coreApp), { articlesCount });
         })));
+        const transformedApps = serverAppsToStudioApps(apps, getState());
+        transformedApps.forEach((app) => __awaiter(void 0, void 0, void 0, function* () {
+            app.fields = updateTaxonomies(app.fields, taxonomies, intl);
+            if (app.inWorkVersion) {
+                app.inWorkVersion.fields = updateTaxonomies(app.inWorkVersion.fields, taxonomies, intl);
+            }
+        }));
+        return transformedApps;
     }
     catch (_) {
         dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
         throw rejectWithValue({ error: 1, errorMsg: 'Error retrieving applications' });
     }
 }));
+function updateTaxonomies(fields, taxonomies, intl) {
+    return fields.map((field) => {
+        var _a;
+        if (field.type !== AppFormItemTypes.TAGS) {
+            return field;
+        }
+        const newField = JSON.parse(JSON.stringify(field));
+        const newFieldTaxoProp = (_a = newField.properties) === null || _a === void 0 ? void 0 : _a.find((prop) => {
+            return prop.propertyType === AppFieldFormPropertyTypes.TAXONOMY;
+        });
+        const taxo = taxonomies.find((taxo) => {
+            return taxo.id === (newFieldTaxoProp === null || newFieldTaxoProp === void 0 ? void 0 : newFieldTaxoProp.value.id);
+        });
+        if (taxo && newFieldTaxoProp) {
+            newFieldTaxoProp.value.title = intl.formatMessage({ id: taxo.title });
+            newFieldTaxoProp.value.type = taxo.type;
+        }
+        return newField;
+    });
+}
 const createNewStudioApp = createAsyncThunk('studio/createApp', ({ appName, callback }, { extra, dispatch, rejectWithValue, getState }) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const jApi = extra.jApi;
@@ -3966,12 +4803,20 @@ const restartStudioApp = createAsyncThunk('studio/restartStudioApp', ({ idApp },
         throw rejectWithValue({ error: 1, errorMsg: 'Error restarting application' });
     }
 }));
-const cloneStudioApp = createAsyncThunk('studio/cloneStudioApp', ({ idApp }, { extra, getState, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+const cloneStudioApp = createAsyncThunk('studio/cloneStudioApp', ({ idApp, inWork }, { extra, getState, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
     var _b, _c;
     const jApi = extra.jApi;
-    const existingStudioApp = (_b = getState().studio.studioAppsList.studioAppsList) === null || _b === void 0 ? void 0 : _b.find((app) => app.idApp === idApp);
+    let existingStudioApp = (_b = getState().studio.studioAppsList.studioAppsList) === null || _b === void 0 ? void 0 : _b.find((app) => app.idApp === idApp);
     if (!existingStudioApp)
         return rejectWithValue({ error: 1, errorMsg: 'Error cloning application' });
+    if (inWork) {
+        if (existingStudioApp.inWorkVersion !== undefined) {
+            existingStudioApp = existingStudioApp.inWorkVersion;
+        }
+        else {
+            return rejectWithValue({ error: 1, errorMsg: 'Error cloning application' });
+        }
+    }
     const currentUser = (_c = getState().userCurrent) === null || _c === void 0 ? void 0 : _c.uri;
     const [clonedStudioApp, newAppId] = cloneStudioAppFromExistingApp(existingStudioApp, currentUser);
     const clonedStudioAppReady = JSON.stringify(clonedStudioApp);
@@ -3985,12 +4830,33 @@ const cloneStudioApp = createAsyncThunk('studio/cloneStudioApp', ({ idApp }, { e
         return rejectWithValue({ error: 1, errorMsg: 'Error cloning application' });
     }
 }));
+const createInWorkStudioApp = createAsyncThunk('studio/createInWorkStudioApp', ({ idApp }, { extra, getState, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _d, _e;
+    const jApi = extra.jApi;
+    const existingStudioApp = (_d = getState().studio.studioAppsList.studioAppsList) === null || _d === void 0 ? void 0 : _d.find((app) => app.idApp === idApp);
+    if (!existingStudioApp ||
+        ![APP_STATUS_TYPE.INSTALLED, APP_STATUS_TYPE.SUSPENDED].includes(existingStudioApp.status)) {
+        return rejectWithValue({ error: 1, errorMsg: 'Error cloning application' });
+    }
+    const currentUser = (_e = getState().userCurrent) === null || _e === void 0 ? void 0 : _e.uri;
+    const [clonedStudioApp, newAppId] = cloneStudioAppFromExistingApp(existingStudioApp, currentUser, true);
+    const clonedStudioAppReady = JSON.stringify(clonedStudioApp);
+    try {
+        yield jApi.application.save(newAppId, clonedStudioAppReady, 'saved');
+        dispatch(Toast.actions.success({ label: 'APPSTUDIO_AppItem_CreateInWork' }));
+        return clonedStudioApp;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Error creating in work version for application' });
+    }
+}));
 const StudioAppsListSlice = createSlice({
     name: 'studioAppsList',
     initialState,
     reducers: {
         setAppsList: (state, action) => {
-            state.studioAppsList = action.payload;
+            state.studioAppsList = [...action.payload].sort(appLexicalSort);
         },
     },
     extraReducers: (builder) => {
@@ -4003,7 +4869,7 @@ const StudioAppsListSlice = createSlice({
             if (state.loadingStudioAppsList === 'pending') {
                 state.loadingStudioAppsList = 'idle';
             }
-            state.studioAppsList = serverAppsToStudioApps(action.payload);
+            state.studioAppsList = [...action.payload].sort(appLexicalSort);
         })
             .addCase(fetchStudioAppsList.rejected, (state) => {
             if (state.loadingStudioAppsList === 'pending')
@@ -4024,8 +4890,13 @@ const StudioAppsListSlice = createSlice({
                     let { status } = action.meta.arg;
                     if (status === APP_STATUS_TYPE.INSTALLED)
                         status = APP_STATUS_TYPE.SUSPENDED;
-                    if (app.idApp === idApp && app.status === status)
+                    if (app.idApp === idApp && app.status === status) {
+                        if (app.inWorkVersion && app.status === APP_STATUS_TYPE.SUSPENDED) {
+                            app.inWorkVersion.status = APP_STATUS_TYPE.DRAFT;
+                            return [...acc, app.inWorkVersion];
+                        }
                         return acc;
+                    }
                     if (app.inWorkVersion &&
                         app.inWorkVersion.idApp === idApp &&
                         app.inWorkVersion.status === status) {
@@ -4081,38 +4952,65 @@ const StudioAppsListSlice = createSlice({
                 })) !== null && _b !== void 0 ? _b : [];
         })
             .addCase(restartStudioApp.rejected, (state) => {
-            if (state.restartStudioAppStatus === 'pending')
+            if (state.restartStudioAppStatus === 'pending') {
                 state.restartStudioAppStatus = 'idle';
+            }
         })
             .addCase(cloneStudioApp.pending, (state) => {
-            if (state.cloneStudioAppStatus === 'idle')
+            if (state.cloneStudioAppStatus === 'idle') {
                 state.cloneStudioAppStatus = 'pending';
+            }
         })
             .addCase(cloneStudioApp.fulfilled, (state, action) => {
             var _a;
             if (state.cloneStudioAppStatus === 'pending') {
                 state.cloneStudioAppStatus = 'idle';
             }
-            state.studioAppsList = [...((_a = state.studioAppsList) !== null && _a !== void 0 ? _a : []), action.payload];
+            state.studioAppsList = [...((_a = state.studioAppsList) !== null && _a !== void 0 ? _a : []), action.payload].sort(appLexicalSort);
         })
             .addCase(cloneStudioApp.rejected, (state) => {
-            if (state.cloneStudioAppStatus === 'pending')
+            if (state.cloneStudioAppStatus === 'pending') {
                 state.cloneStudioAppStatus = 'idle';
+            }
+        })
+            .addCase(createInWorkStudioApp.pending, (state) => {
+            if (state.createInWorkAppStatus === 'idle') {
+                state.createInWorkAppStatus = 'pending';
+            }
+        })
+            .addCase(createInWorkStudioApp.fulfilled, (state, action) => {
+            var _a;
+            if (state.createInWorkAppStatus === 'pending') {
+                state.createInWorkAppStatus = 'idle';
+            }
+            const app = (_a = state.studioAppsList) === null || _a === void 0 ? void 0 : _a.find((app) => {
+                return app.idApp === action.payload.idApp;
+            });
+            if (app) {
+                app.inWorkVersion = action.payload;
+            }
+        })
+            .addCase(createInWorkStudioApp.rejected, (state) => {
+            if (state.createInWorkAppStatus === 'pending') {
+                state.createInWorkAppStatus = 'idle';
+            }
         })
             .addCase(createNewStudioApp.pending, (state) => {
-            if (state.createNewStudioAppStatus === 'idle')
+            if (state.createNewStudioAppStatus === 'idle') {
                 state.createNewStudioAppStatus = 'pending';
+            }
         })
             .addCase(createNewStudioApp.fulfilled, (state, action) => {
             var _a;
             if (state.createNewStudioAppStatus === 'pending') {
                 state.createNewStudioAppStatus = 'idle';
             }
-            state.studioAppsList = [...((_a = state.studioAppsList) !== null && _a !== void 0 ? _a : []), action.payload];
+            state.studioAppsList = [...((_a = state.studioAppsList) !== null && _a !== void 0 ? _a : []), action.payload].sort(appLexicalSort);
         })
             .addCase(createNewStudioApp.rejected, (state) => {
-            if (state.createNewStudioAppStatus === 'pending')
+            if (state.createNewStudioAppStatus === 'pending') {
                 state.createNewStudioAppStatus = 'idle';
+            }
         });
     },
 });
@@ -4141,12 +5039,17 @@ const studio = {
         createNewStudioApp,
         fetchCurrentStudioApp,
         saveCurrentStudioApp,
-        installStudioApp }),
+        installStudioApp,
+        createInWorkStudioApp }),
     selectors: {
         selectStudioAppsList,
         selectCurrentStudioApp,
     },
+    utils: {
+        updateViewsFromFields,
+        generateNewFormField,
+    },
 };
 
-export { APP_STATUS_TYPE, AUDIENCE, Animations, AppColumnsDefaultTypes, AppFieldFormPropertyTypes, AppFormBannedFromViews$1 as AppFormBannedFromViews, AppFormFieldOnlyInView, AppFormFixedList$1 as AppFormFixedList, AppFormItemTypes, AppFormNoAsFieldList, AppFormNonPrimaryList, AppFormPrimaryList, AppFormUniqueList, Application, AssetReservation, Bookmark, Comment, ExtraAppFieldsItemViews, Faq, Hook, MODE_EDIT, MODE_VIEW, MagicPad, MapExtraFieldsWithView, MediaLibrary, Model, Network, Platform, STUDIO_VIEW, Share, SocialActions, StatusType$1 as StatusType, TVDisplay, TinyMCE, Toast, UserCurrent, WedocApp, Widget, WidgetEditor, actions, animationsReducer, animationsSlice, fetchMediaLibraryConfig, fetchMediaLibraryFilesStats, fetchMediaLibraryFolders, fetchMediaLibraryFoldersStats, fetchMediaLibraryStats, fetchMediaLibraryUnclassifiedFiles, fetchPads, jland, magicPadSlice, mediaLibraryReducer, mediaLibrarySlice, slice$1 as slice, studio, updateWidgetContent, viewsList };
+export { APP_STATUS_TYPE, AUDIENCE, Animations, AppColumnsDefaultTypes, AppFieldFormPropertyTypes, AppFormBannedFromViews$1 as AppFormBannedFromViews, AppFormFieldOnlyInView, AppFormFixedList$1 as AppFormFixedList, AppFormItemTypes, AppFormNoAsFieldList, AppFormNonPrimaryList, AppFormPrimaryList, AppFormPrimaryListValues, AppFormUniqueList, AppFormUniqueListCheck, Application, AssetReservation, Bookmark, Comment, Description, Element, ExtraAppFieldsItemViews, Faq, Hook, MagicPad, MapExtraFieldsWithView, MediaLibrary, Model, Network, Platform, STUDIO_VIEW, Share, SocialActions, StatusType$1 as StatusType, TVDisplay, TinyMCE, Toast, UserCurrent, WedocApp, Widget, WidgetEditor, actions, animationsReducer, animationsSlice, fetchMediaLibraryConfig, fetchMediaLibraryFilesStats, fetchMediaLibraryFolders, fetchMediaLibraryFoldersStats, fetchMediaLibraryStats, fetchMediaLibraryUnclassifiedFiles, fetchPads, jland, magicPadSlice, mediaLibraryReducer, mediaLibrarySlice, slice$1 as slice, studio, updateWidgetContent, viewsList };
 //# sourceMappingURL=esm.js.map