jamespot-front-business 1.1.38 → 1.1.40

package/dist/esm.js

@@ -3,26 +3,6 @@ import { combineReducers as combineReducers$1 } from 'redux';
 import jamespot, { jEnsure, formatImgUrl, UserLevel, StudioApplicationStatus } from 'jamespot-user-api';
 import { v4 } from 'uuid';
 
-const adapter$1 = createEntityAdapter({
-    selectId: (app) => app.name,
-    sortComparer: (a, b) => a.label.localeCompare(b.label),
-});
-const slice$3 = createSlice({
-    name: 'applications',
-    initialState: adapter$1.getInitialState(),
-    reducers: {
-        addOne: adapter$1.addOne,
-        addMany: adapter$1.addMany,
-        setAll: adapter$1.setAll,
-    },
-});
-const selectors$2 = adapter$1.getSelectors((state) => state.entities.applications);
-const Application = {
-    slice: slice$3,
-    actions: Object.assign({}, slice$3.actions),
-    selectors: selectors$2,
-};
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -60,6 +40,195 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+const toastAdapter = createEntityAdapter({
+    selectId: (toast) => toast.id,
+});
+const slice$3 = createSlice({
+    name: 'toasts',
+    initialState: toastAdapter.getInitialState(),
+    reducers: {
+        addOne: toastAdapter.addOne,
+        removeOne: toastAdapter.removeOne,
+    },
+});
+const randomId = () => Math.random().toString(16).slice(2);
+const addMessage = (_a, type, timeout) => {
+    var { id = randomId() } = _a, toast = __rest(_a, ["id"]);
+    if (type === void 0) { type = 'success'; }
+    if (timeout === void 0) { timeout = 3000; }
+    return (dispatch) => {
+        dispatch(slice$3.actions.addOne(Object.assign(Object.assign({ id }, toast), { timeout, type })));
+        setTimeout(() => {
+            dispatch(slice$3.actions.removeOne(id));
+        }, timeout);
+        return id;
+    };
+};
+const actions = {
+    addMessage,
+    success: (toast, timeout) => addMessage(toast, 'success', timeout),
+    warning: (toast, timeout) => addMessage(toast, 'warning', timeout),
+    error: (toast, timeout) => addMessage(toast, 'error', timeout),
+};
+const selectors$2 = toastAdapter.getSelectors((state) => state.toasts);
+const Toast = {
+    slice: slice$3,
+    actions: Object.assign(Object.assign({}, actions), slice$3.actions),
+    selectors: selectors$2,
+};
+
+const getAnimationsRTHandlers = function (dispatch) {
+    const addAnimationHandler = function (message) {
+        if (message.namespace === 'ANIMATIONS' &&
+            message.function === 'add') {
+            dispatch(fetchCurrentAnimation());
+            dispatch(fetchCurrentAnimationApp());
+        }
+    };
+    const deleteAnimationHandler = function (message) {
+        if (message.namespace === 'ANIMATIONS' &&
+            message.function === 'delete') {
+            dispatch(fetchCurrentAnimation());
+            dispatch(fetchCurrentAnimationApp());
+        }
+    };
+    const toggleIsActiveAnimationHandler = function (message) {
+        if (message.namespace === 'ANIMATIONS' &&
+            message.function === 'toggle') {
+            dispatch(fetchCurrentAnimation());
+        }
+    };
+    return [
+        {
+            namespace: 'ANIMATIONS',
+            function: 'add',
+            handler: addAnimationHandler,
+        },
+        {
+            namespace: 'ANIMATIONS',
+            function: 'delete',
+            handler: deleteAnimationHandler,
+        },
+        {
+            namespace: 'ANIMATIONS',
+            function: 'toggle',
+            handler: toggleIsActiveAnimationHandler,
+        },
+    ];
+};
+
+const initialState$k = {
+    animationConfiguration: null,
+    isActiveForCurrentUser: false,
+    isInitialized: false,
+    isToggleLoading: false,
+};
+const animationsSlice = createSlice({
+    name: 'animations',
+    initialState: initialState$k,
+    reducers: {},
+    extraReducers: (builder) => {
+        builder.addCase(fetchCurrentAnimation.fulfilled, (state, action) => {
+            state.isActiveForCurrentUser = action.payload.isActiveForCurrentUser;
+            state.animationConfiguration = action.payload.animationConfiguration;
+            state.isInitialized = action.payload.isInitialized;
+        });
+        builder.addCase(fetchCurrentAnimationApp.fulfilled, (state, action) => {
+            state.animationConfigurationApp = action.payload;
+        });
+        builder.addCase(toggleAnimationIsActive.pending, (state) => {
+            state.isToggleLoading = true;
+        });
+        builder.addCase(toggleAnimationIsActive.fulfilled, (state) => {
+            state.isToggleLoading = false;
+        });
+        builder.addCase(toggleAnimationIsActive.rejected, (state) => {
+            state.isToggleLoading = false;
+        });
+    },
+});
+const fetchCurrentAnimation = createAsyncThunk('animations/fetchCurrentAnimation', (_, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const animationConfiguration = (yield extra.jApi.animations.GetCurrentAnimation()).result;
+        const isActiveForCurrentUser = (yield extra.jApi.animations.GetAnimationActive()).result;
+        return { animationConfiguration, isActiveForCurrentUser, isInitialized: true };
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Cannot retrieve animation' });
+    }
+}));
+const fetchCurrentAnimationApp = createAsyncThunk('animations/fetchCurrentAnimationApp', (_, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return (yield extra.jApi.animations.GetCurrentAnimationApp()).result;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Cannot retrieve animation' });
+    }
+}));
+const deleteCurrentAnimation = createAsyncThunk('animations/deleteCurrentAnimation', (_, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield extra.jApi.animations.DeleteAnimation();
+        return;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Cannot delete animation' });
+    }
+}));
+const saveCurrentAnimation = createAsyncThunk('animations/saveCurrentAnimation', (params, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield extra.jApi.animations.SaveAnimationConfiguration(params);
+        return;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Cannot update animation' });
+    }
+}));
+const toggleAnimationIsActive = createAsyncThunk('animations/toggleAnimationIsActive', (_, { extra, rejectWithValue, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield extra.jApi.animations.ToggleAnimationActive();
+        return;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue({ error: 1, errorMsg: 'Cannot update animation' });
+    }
+}));
+const selectCurrentAnimation = (state) => state.animations.animationConfiguration;
+const isActiveAnimation = (state) => state.animations.isActiveForCurrentUser;
+const isToggleLoading = (state) => state.animations.isToggleLoading;
+const selectAnimationConfigurationApp = (state) => state.animations.animationConfigurationApp;
+const animationsReducer = animationsSlice.reducer;
+const Animations = {
+    slice: animationsSlice,
+    actions: { saveCurrentAnimation, fetchCurrentAnimation, deleteCurrentAnimation, toggleAnimationIsActive, fetchCurrentAnimationApp },
+    selectors: { selectCurrentAnimation, isActiveAnimation, isToggleLoading, selectAnimationConfigurationApp },
+    getAnimationsRTHandlers
+};
+
+const adapter$1 = createEntityAdapter({
+    selectId: (app) => app.name,
+    sortComparer: (a, b) => a.label.localeCompare(b.label),
+});
+const slice$2 = createSlice({
+    name: 'applications',
+    initialState: adapter$1.getInitialState(),
+    reducers: {
+        addOne: adapter$1.addOne,
+        addMany: adapter$1.addMany,
+        setAll: adapter$1.setAll,
+    },
+});
+const selectors$1 = adapter$1.getSelectors((state) => state.entities.applications);
+const Application = {
+    slice: slice$2,
+    actions: Object.assign({}, slice$2.actions),
+    selectors: selectors$1,
+};
+
 const initialState$j = {
     entities: [],
     loading: 'idle',
@@ -195,43 +364,6 @@ const AssetReservation = {
     },
 };
 
-const toastAdapter = createEntityAdapter({
-    selectId: (toast) => toast.id,
-});
-const slice$2 = createSlice({
-    name: 'toasts',
-    initialState: toastAdapter.getInitialState(),
-    reducers: {
-        addOne: toastAdapter.addOne,
-        removeOne: toastAdapter.removeOne,
-    },
-});
-const randomId = () => Math.random().toString(16).slice(2);
-const addMessage = (_a, type, timeout) => {
-    var { id = randomId() } = _a, toast = __rest(_a, ["id"]);
-    if (type === void 0) { type = 'success'; }
-    if (timeout === void 0) { timeout = 3000; }
-    return (dispatch) => {
-        dispatch(slice$2.actions.addOne(Object.assign(Object.assign({ id }, toast), { timeout, type })));
-        setTimeout(() => {
-            dispatch(slice$2.actions.removeOne(id));
-        }, timeout);
-        return id;
-    };
-};
-const actions = {
-    addMessage,
-    success: (toast, timeout) => addMessage(toast, 'success', timeout),
-    warning: (toast, timeout) => addMessage(toast, 'warning', timeout),
-    error: (toast, timeout) => addMessage(toast, 'error', timeout),
-};
-const selectors$1 = toastAdapter.getSelectors((state) => state.toasts);
-const Toast = {
-    slice: slice$2,
-    actions: Object.assign(Object.assign({}, actions), slice$2.actions),
-    selectors: selectors$1,
-};
-
 const initialState$g = {
     loading: 'idle',
     comments: [],
@@ -1656,6 +1788,22 @@ const widgetArticleTitleContent = {
     backgroundColor: 'transparent',
 };
 
+const widgetApiDefinition = {
+    label: 'WIDGET_Api',
+    description: 'WIDGET_Api_Description',
+    name: 'widget-api',
+    img: '/img/fast-intranet/widget-text.png',
+    available: true,
+    panel: {
+        useWrapper: false,
+        useEditor: true,
+        useWidgets: false,
+    },
+};
+const widgetApiContent = {
+    url: '',
+};
+
 const widgetArticleSliderDefinition = {
     label: 'WIDGET_Slider',
     description: 'WIDGET_Slider_Description',
@@ -1702,6 +1850,8 @@ function content(name) {
         default:
         case 'widget-article-attachment':
             return Object.assign({}, widgetArticleAttachmentContent);
+        case 'widget-api':
+            return Object.assign({}, widgetApiContent);
         case 'widget-article-slider':
             return Object.assign({}, widgetArticleSliderContent);
         case 'widget-article-gallery':
@@ -1750,6 +1900,8 @@ function widgetDefinition(name) {
             return widgetArticleTitleDefinition;
         case 'widget-article-image':
             return widgetArticleImageDefinition;
+        case 'widget-api':
+            return widgetApiDefinition;
         case 'widget-article-button':
             return widgetArticleButtonDefinition;
     }
@@ -1971,16 +2123,16 @@ const AUDIENCE = {
     ALL: '1',
     CUSTOM: '0',
 };
-var StatusType;
+var StatusType$1;
 (function (StatusType) {
     StatusType["draft"] = "draft";
     StatusType["installed"] = "installed";
     StatusType["suspended"] = "suspended";
-})(StatusType || (StatusType = {}));
+})(StatusType$1 || (StatusType$1 = {}));
 const APP_STATUS_TYPE = {
-    DRAFT: StatusType.draft,
-    INSTALLED: StatusType.installed,
-    SUSPENDED: StatusType.suspended,
+    DRAFT: StatusType$1.draft,
+    INSTALLED: StatusType$1.installed,
+    SUSPENDED: StatusType$1.suspended,
 };
 const STUDIO_VIEW = {
     SOLR: '1',
@@ -2008,6 +2160,7 @@ var AppFormItemTypes;
     AppFormItemTypes["CODEHTML"] = "CODEHTML";
     AppFormItemTypes["USERLINK"] = "USERLINK";
     AppFormItemTypes["CONTENTLINK"] = "CONTENTLINK";
+    AppFormItemTypes["RANGE"] = "RANGE";
 })(AppFormItemTypes || (AppFormItemTypes = {}));
 var ExtraAppFieldsItemViews;
 (function (ExtraAppFieldsItemViews) {
@@ -2029,8 +2182,8 @@ var AppFieldFormPropertyTypes;
     AppFieldFormPropertyTypes["CONTENTTYPE"] = "contenttype";
 })(AppFieldFormPropertyTypes || (AppFieldFormPropertyTypes = {}));
 const AppFormUniqueList = [AppFormItemTypes.DESCRIPTION, AppFormItemTypes.IMAGE];
-const AppFormBannedFromViews = new Map();
-AppFormBannedFromViews.set(AppFormItemTypes.IMAGE, ['list', 'filter', 'view']);
+const AppFormBannedFromViews$1 = new Map();
+AppFormBannedFromViews$1.set(AppFormItemTypes.IMAGE, ['list', 'filter', 'view']);
 const MapExtraFieldsWithView = {
     create: {
         fixed: [ExtraAppFieldsItemViews.TITLE],
@@ -2061,6 +2214,275 @@ const MapExtraFieldsWithView = {
         optional: [],
     },
 };
+const AppColumnsDefaultTypes = [
+    ExtraAppFieldsItemViews.TITLE,
+    ExtraAppFieldsItemViews.USER,
+    ExtraAppFieldsItemViews.CREATIONDATE,
+    AppFormItemTypes.DESCRIPTION,
+];
+const AppFormPrimaryList = [AppFormItemTypes.DESCRIPTION];
+
+var StatusType;
+(function (StatusType) {
+    StatusType["draft"] = "draft";
+    StatusType["installed"] = "installed";
+    StatusType["suspended"] = "suspended";
+})(StatusType || (StatusType = {}));
+({
+    DRAFT: StatusType.draft,
+    INSTALLED: StatusType.installed,
+    SUSPENDED: StatusType.suspended,
+});
+var AppFormItemType;
+(function (AppFormItemType) {
+    AppFormItemType["TITLE"] = "TITLE";
+    AppFormItemType["IMAGE"] = "IMAGE";
+    AppFormItemType["DESCRIPTION"] = "DESCRIPTION";
+    AppFormItemType["IDUSER"] = "IDUSER";
+    AppFormItemType["PUBLISHTO"] = "PUBLISHTO";
+    AppFormItemType["SENDALERTTOSUBSCRIBERS"] = "SENDALERTTOSUBSCRIBERS";
+    AppFormItemType["RECEIVEACOPY"] = "RECEIVEACOPY";
+    AppFormItemType["TEXT"] = "TEXT";
+    AppFormItemType["TEXTAREA"] = "TEXTAREA";
+    AppFormItemType["TEXTAREAHTML"] = "TEXTAREAHTML";
+    AppFormItemType["DATE"] = "DATE";
+    AppFormItemType["DATETIME"] = "DATETIME";
+    AppFormItemType["RANGE"] = "RANGE";
+    AppFormItemType["NUMBER"] = "NUMBER";
+    AppFormItemType["URL"] = "URL";
+    AppFormItemType["EMAIL"] = "EMAIL";
+    AppFormItemType["SELECT"] = "SELECT";
+    AppFormItemType["CHECKBOX"] = "CHECKBOX";
+    AppFormItemType["TOGGLE"] = "TOGGLE";
+    AppFormItemType["RADIO"] = "RADIO";
+    AppFormItemType["TAGS"] = "TAGS";
+    AppFormItemType["ADDFILEATTACHMENT"] = "ADDFILEATTACHMENT";
+    AppFormItemType["AUDIENCE"] = "AUDIENCE";
+    AppFormItemType["CODEHTML"] = "CODEHTML";
+    AppFormItemType["DATECREATION"] = "DATECREATION";
+    AppFormItemType["USERLINK"] = "USERLINK";
+    AppFormItemType["CONTENTLINK"] = "CONTENTLINK";
+})(AppFormItemType || (AppFormItemType = {}));
+[AppFormItemType.DESCRIPTION];
+const AppFormNotFields = [AppFormItemType.AUDIENCE, AppFormItemType.RANGE];
+({
+    create: [AppFormItemType.TITLE],
+    popup: [AppFormItemType.TITLE],
+    edit: [AppFormItemType.TITLE],
+    list: [AppFormItemType.TITLE, AppFormItemType.IDUSER],
+    filter: [AppFormItemType.TITLE, AppFormItemType.IDUSER],
+    view: [AppFormItemType.TITLE],
+});
+({
+    create: [AppFormItemType.PUBLISHTO, AppFormItemType.SENDALERTTOSUBSCRIBERS, AppFormItemType.RECEIVEACOPY],
+    popup: [AppFormItemType.PUBLISHTO],
+    edit: [AppFormItemType.PUBLISHTO],
+    list: [AppFormItemType.DATECREATION],
+    filter: [AppFormItemType.DATECREATION],
+    view: [],
+});
+const AppFormFixedList = [
+    AppFormItemType.TITLE,
+    AppFormItemType.PUBLISHTO,
+    AppFormItemType.SENDALERTTOSUBSCRIBERS,
+    AppFormItemType.RECEIVEACOPY,
+    AppFormItemType.IDUSER,
+    AppFormItemType.DATECREATION,
+];
+[AppFormItemType.DESCRIPTION, AppFormItemType.IMAGE];
+const AppFormBannedFromViews = new Map();
+AppFormBannedFromViews.set(AppFormItemType.IMAGE, ['list', 'filter', 'view']);
+const AppListFilter = [
+    AppFormItemType.TITLE,
+    AppFormItemType.DESCRIPTION,
+    AppFormItemType.TEXT,
+    AppFormItemType.TEXTAREA,
+    AppFormItemType.TEXTAREAHTML,
+    AppFormItemType.DATE,
+    AppFormItemType.DATETIME,
+    AppFormItemType.RANGE,
+    AppFormItemType.NUMBER,
+    AppFormItemType.URL,
+    AppFormItemType.EMAIL,
+    AppFormItemType.SELECT,
+    AppFormItemType.TOGGLE,
+    AppFormItemType.CHECKBOX,
+    AppFormItemType.RADIO,
+    AppFormItemType.TAGS,
+    AppFormItemType.PUBLISHTO,
+    AppFormItemType.SENDALERTTOSUBSCRIBERS,
+    AppFormItemType.RECEIVEACOPY,
+    AppFormItemType.ADDFILEATTACHMENT,
+    AppFormItemType.CODEHTML,
+    AppFormItemType.IDUSER,
+    AppFormItemType.DATECREATION,
+    AppFormItemType.USERLINK,
+    AppFormItemType.CONTENTLINK,
+];
+({
+    create: [AppFormItemType.IMAGE, AppFormItemType.ADDFILEATTACHMENT, AppFormItemType.CODEHTML],
+    popup: [AppFormItemType.IMAGE, AppFormItemType.ADDFILEATTACHMENT, AppFormItemType.CODEHTML],
+    edit: [AppFormItemType.IMAGE, AppFormItemType.ADDFILEATTACHMENT, AppFormItemType.CODEHTML],
+    list: AppListFilter,
+    filter: AppListFilter,
+    view: AppListFilter,
+});
+AppFormFixedList.concat(AppFormNotFields)
+    .concat(AppFormItemType.IDUSER)
+    .concat(AppFormItemType.TITLE);
+[AppFormItemType.CODEHTML];
+
+function migrateJson(v1Json) {
+    const v1 = v1Json;
+    const v1Manifest = v1.manifest;
+    const newFields = _renderFields();
+    const v2 = {
+        idApp: v1.idApp,
+        status: v1.status,
+        studioVersion: 2,
+        author: v1.author || '',
+        manifest: {
+            appShortName: v1Manifest.appShortName,
+            appName: v1Manifest.appName,
+            description: v1Manifest.description,
+            author: v1Manifest.author || '',
+            typeLabel: v1Manifest.typeLabel,
+            cssColor: v1Manifest.cssColor,
+            cssClass: v1Manifest.cssClass,
+            version: v1Manifest.version,
+            dateCreation: new Date(v1Manifest.dateCreation).toISOString(),
+            viewSolr: v1Manifest.viewSolr,
+            checkAccess: v1Manifest.checkAccess,
+            accessRightList: v1Manifest.accessRightList || '',
+            attrExposed: v1Manifest.attrExposed,
+        },
+        fields: newFields,
+        views: _renderViews(),
+        audience: v1.audience || '1',
+        installFor: v1.installFor || [],
+    };
+    function _renderFields() {
+        var _a;
+        const v2Fields = [];
+        for (const v1FormItem of v1.form.formItems) {
+            const type = _matctTypes(v1FormItem.type);
+            v2Fields.push({
+                id: v1FormItem.id,
+                type,
+                properties: _renderProperties((_a = v1FormItem.properties) !== null && _a !== void 0 ? _a : {}),
+                mandatory: v1FormItem.mandatory || false,
+                views: v1FormItem.views,
+                isActive: true,
+                isFixed: false,
+                isOptional: false,
+                value: null,
+            });
+        }
+        return v2Fields;
+    }
+    function _matctTypes(v1Type) {
+        return AppFormItemTypes[v1Type];
+    }
+    function _renderProperties(v1FormItemProperties) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const v2Properties = [];
+        const isEnhancedOptionEditor = v1FormItemProperties.options &&
+            Object.prototype.hasOwnProperty.call(v1FormItemProperties, 'hasDefaultValue');
+        const baseProperty = Object.assign({ isRequired: v1FormItemProperties.mandatory || false }, (isEnhancedOptionEditor && { isOptionsEditorEnhanced: true }));
+        if (v1FormItemProperties.labels) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.LABEL, value: ((_a = v1FormItemProperties.labels.label) === null || _a === void 0 ? void 0 : _a.content) || '' }, baseProperty));
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.DESCRIPTION, value: ((_b = v1FormItemProperties.labels.description) === null || _b === void 0 ? void 0 : _b.content) || '' }, baseProperty));
+        }
+        if (v1FormItemProperties.options) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.OPTIONS_EDITOR, value: isEnhancedOptionEditor
+                    ? {
+                        propertyOptions: _renderSelectOptions((_c = v1FormItemProperties.options) !== null && _c !== void 0 ? _c : []),
+                        defaultSelectOptionValue: v1FormItemProperties.defaultValue,
+                        defaultSelectOption: (_d = v1FormItemProperties.hasDefaultValue) !== null && _d !== void 0 ? _d : false,
+                        canSelectMultiple: (_e = v1FormItemProperties.multiple) !== null && _e !== void 0 ? _e : false,
+                        userCanModifiyByComment: (_f = v1FormItemProperties.explain) !== null && _f !== void 0 ? _f : false,
+                    }
+                    : { propertyOptions: _renderSelectOptions((_g = v1FormItemProperties.options) !== null && _g !== void 0 ? _g : []) } }, baseProperty));
+        }
+        if (v1FormItemProperties.code) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.RICHTEXT, value: v1FormItemProperties.code.html || v1FormItemProperties.code.text || '' }, baseProperty));
+        }
+        if (Object.prototype.hasOwnProperty.call(v1FormItemProperties, 'digits')) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.CHECKBOX, value: v1FormItemProperties.digits || false, checkBoxOptions: [{ label: 'APPSTUDIO_FormEditProps_Digits', value: v1FormItemProperties.digits }] }, baseProperty));
+        }
+        if (Object.prototype.hasOwnProperty.call(v1FormItemProperties, 'taxonomy')) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.TAXONOMY, value: v1FormItemProperties.taxonomy || '' }, baseProperty));
+        }
+        if (Object.prototype.hasOwnProperty.call(v1FormItemProperties, 'contentType')) {
+            v2Properties.push(Object.assign({ propertyType: AppFieldFormPropertyTypes.CONTENTTYPE, value: v1FormItemProperties.contentType || '' }, baseProperty));
+        }
+        return v2Properties;
+    }
+    function _renderSelectOptions(v1Options) {
+        const v2Options = [];
+        for (const option of v1Options) {
+            v2Options.push({
+                title: option.label,
+                value: option.value,
+            });
+        }
+        return v2Options;
+    }
+    function _renderViews() {
+        return {
+            create: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'create').formItemRefs),
+            popup: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'popup').formItemRefs),
+            edit: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'edit').formItemRefs),
+            list: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'list').formItemRefs),
+            filter: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'filter').formItemRefs),
+            view: _renderViewFields(v1.formItemsViewList.find((view) => view.view == 'view').formItemRefs),
+        };
+    }
+    function _renderViewFields(v1FormItemRefs) {
+        const viewItems = {};
+        v1FormItemRefs.forEach((v1FormItemRef) => {
+            const viewBase = {
+                isUsed: true,
+                isFixed: false,
+                isOptional: false,
+                properties: [],
+                pos: 0,
+                isLockedValue: !!v1FormItemRef.fixedValue || false,
+                value: v1FormItemRef.fixedValue || '',
+            };
+            if (v1FormItemRef.ref === AppFormItemType.TITLE) {
+                viewItems[v4()] = Object.assign(Object.assign({}, viewBase), { type: ExtraAppFieldsItemViews.TITLE, isFixed: true });
+            }
+            else if (v1FormItemRef.ref === AppFormItemType.IDUSER) {
+                viewItems[v4()] = Object.assign(Object.assign({}, viewBase), { type: ExtraAppFieldsItemViews.USER, isFixed: true });
+            }
+            else if (v1FormItemRef.ref === AppFormItemType.PUBLISHTO) {
+                viewItems[v4()] = Object.assign(Object.assign({}, viewBase), { type: ExtraAppFieldsItemViews.PUBLISHTO, isOptional: true });
+            }
+            else if (v1FormItemRef.ref === AppFormItemType.SENDALERTTOSUBSCRIBERS) {
+                viewItems[v4()] = Object.assign(Object.assign({}, viewBase), { type: ExtraAppFieldsItemViews.SENDALERTTOSUBSCRIBERS, isOptional: true });
+            }
+            else if (v1FormItemRef.ref === AppFormItemType.RECEIVEACOPY) {
+                viewItems[v4()] = Object.assign(Object.assign({}, viewBase), { type: ExtraAppFieldsItemViews.RECEIVEACOPY, isOptional: true });
+            }
+            else {
+                const v2Field = _mapFormItemRefWithField(v1FormItemRef);
+                if (v2Field) {
+                    viewItems[v2Field.id] = Object.assign(Object.assign({ type: v2Field.type }, viewBase), { properties: v2Field.properties || [] });
+                }
+            }
+        });
+        return viewItems;
+    }
+    function _mapFormItemRefWithField(v1FormItemRef) {
+        const v1Field = v1.form.formItems.find((field) => v1FormItemRef.ref === field.id || v1FormItemRef.ref === field.name);
+        if (v1Field) {
+            return newFields.find((field) => field.id === v1Field.id);
+        }
+        return null;
+    }
+    return v2;
+}
 
 function InstalledAppStudioAdapter(serverApp, serverApps) {
     const { version, dateCreation } = serverApp.manifest;
@@ -2071,6 +2493,7 @@ function InstalledAppStudioAdapter(serverApp, serverApps) {
     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: appTypeServer.cssColor, cssClass: { label: appTypeServer.cssClass, value: appTypeServer.cssClass }, version: version, dateCreation: dateCreation, checkAccess: serverApp.checkAccess, attrExposed: serverApp.attrExposed, viewSolr: serverApp.view, typeLabel: appTypeServer.typeLabel }, (serverApp.articlesCount && { articlesCount: serverApp.articlesCount })),
         fields: [],
         views,
@@ -2090,22 +2513,28 @@ function DraftAppStudioAdapter(serverApp) {
     if (!serverApp.value)
         return undefined;
     const parsedJson = JSON.parse(serverApp.value);
-    return {
-        idApp: serverApp.idApp,
-        status: _formatStatus(serverApp),
-        manifest: parsedJson.manifest,
-        fields: parsedJson.fields,
-        views: parsedJson.views,
-        audience: parsedJson.audience,
-        installFor: parsedJson.installFor,
-    };
+    if (parsedJson.studioVersion == 2) {
+        return {
+            idApp: serverApp.idApp,
+            studioVersion: 2,
+            status: _formatStatus(serverApp),
+            manifest: parsedJson.manifest,
+            fields: parsedJson.fields,
+            views: parsedJson.views,
+            audience: parsedJson.audience,
+            installFor: parsedJson.installFor,
+        };
+    }
+    else {
+        return Object.assign(Object.assign({}, migrateJson(JSON.parse(serverApp.value))), { status: _formatStatus(serverApp) });
+    }
 }
 function _formatStatus(serverApp) {
     return serverApp.status === StudioApplicationStatus.installed
         ? serverApp.suspended
-            ? StatusType.suspended
-            : StatusType.installed
-        : StatusType.draft;
+            ? StatusType$1.suspended
+            : StatusType$1.installed
+        : StatusType$1.draft;
 }
 function _findAssociatedDraft(idApp, serverApps) {
     const draft = serverApps.find((app) => app.idApp === idApp && app.status === StudioApplicationStatus.saved);
@@ -2130,10 +2559,493 @@ function serverAppsToStudioApps(serverApps) {
     return studioApps;
 }
 
+function appToXml(studioApp) {
+    const { manifest, views, audience, installFor } = studioApp;
+    return `<?xml version='1.0' encoding='utf-8'?>
+    <Application>
+        ${createAppManifest(manifest, views, audience, installFor)}
+        <Types>
+            <objecttype
+                label="${manifest.typeLabel}" 
+                labelPlural="${manifest.typeLabel}" 
+                labelLinkSingular="${manifest.typeLabel}" 
+                labelLinkPlural="${manifest.typeLabel}" 
+                name="${manifest.appShortName}" 
+                classImpl="JPBEContent" 
+                classCodeLocation="jamespot/jpro/objs/JPBEContent.php" 
+                cssClass="${manifest.cssClass.value}" 
+                cssColor="${manifest.cssColor}" 
+                searchtab="${manifest.appShortName}"
+                searchtablabel="${manifest.typeLabel}" 
+                buttonlabel="${manifest.typeLabel}"
+                extends="article">
+            ${renderPrimaryFields(studioApp.fields)}
+            ${renderCustomFields(studioApp.fields)}
+            </objecttype>
+            ${renderDisplays(studioApp)}
+        </Types>
+    </Application>`;
+}
+function createAppManifest(manifest, views, audience, installFor) {
+    var _a;
+    return `<Manifest>
+            <ShowImport>true</ShowImport>
+            <AppShortName>${manifest.appShortName}</AppShortName>
+            <AppName>${manifest.appName}</AppName>
+            <Description>${manifest.description}</Description>
+            <Version>${manifest.version}</Version>
+            <ManifestVersion>1.0</ManifestVersion>
+            <StudioVersion>2</StudioVersion>
+            <DateCreation>${manifest.dateCreation.toString().split('T')[0]}</DateCreation>
+            <CssClass>${(_a = manifest.cssClass) === null || _a === void 0 ? void 0 : _a.label}</CssClass>
+            <CssColor>${manifest.cssColor}</CssColor>
+            <Categories>N.A.</Categories>
+            <Editor>Jamespot</Editor>
+            <EditorUrl>https://www.fr.jamespot.com/</EditorUrl>
+            <Type>${manifest.appShortName}</Type>
+            ${renderAppView(manifest.viewSolr, views.list)}
+            ${renderAppSearch(views.filter)}
+            ${renderAudience(audience, installFor)}
+            <Order>1</Order>
+        </Manifest>`;
+}
+function renderAppView(viewSolr, listView) {
+    if (viewSolr === 'solr') {
+        let xml = '<AppView>solr</AppView>';
+        const formItemIdInList = [];
+        Object.entries(listView).forEach(([fieldId, field]) => {
+            formItemIdInList.push(getAttrNameFormItem(field, fieldId));
+        });
+        xml += `<AppColumns>${formItemIdInList.join()}</AppColumns>`;
+        return xml;
+    }
+    return '';
+}
+function renderAppSearch(searchView) {
+    const formItemIdInFilter = [];
+    Object.entries(searchView).forEach(([fieldId, field]) => {
+        if (![ExtraAppFieldsItemViews.TITLE, AppFormItemTypes.IMAGE].includes(field.type))
+            formItemIdInFilter.push(getAttrNameFormItem(field, fieldId));
+    });
+    return `<AttrExposed>${formItemIdInFilter.join()}</AttrExposed>`;
+}
+function getAttrNameFormItem(field, fieldId) {
+    function fieldType() {
+        if (field.type === ExtraAppFieldsItemViews.USER)
+            return 'idUser';
+        if (field.type === ExtraAppFieldsItemViews.CREATIONDATE)
+            return 'dateCreation';
+        return field.type;
+    }
+    return (AppColumnsDefaultTypes.includes(field.type) ? fieldType() : uuid2Alpha(fieldId)).toLowerCase();
+}
+function renderAudience(audience, installFor) {
+    if (audience === AUDIENCE.ALL)
+        return '<checkAccess>false</checkAccess>';
+    else if (installFor.length > 0) {
+        return `<checkAccess>true</checkAccess>
+        <accessRightList>${installFor.map((user) => user.uri).join()}</accessRightList>`;
+    }
+    return '';
+}
+function renderPrimaryFields(fields) {
+    const primaryFields = fields === null || fields === void 0 ? void 0 : fields.filter((field) => AppFormPrimaryList.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 filteredCustomFields = customFields === null || customFields === void 0 ? void 0 : customFields.filter((field) => field.type !== AppFormItemTypes.IMAGE);
+    if (filteredCustomFields.length === 0)
+        return '';
+    const articlesTablesItems = filteredCustomFields.filter((f) => f.type !== AppFormItemTypes.TAGS);
+    const linksTableItems = filteredCustomFields.filter((f) => f.type === AppFormItemTypes.TAGS);
+    return `<custom>
+        ${articlesTablesItems.length > 0
+        ? `<articlemstable>
+                    ${articlesTablesItems.map((field) => formItem2xml(field)).join('')}
+                </articlemstable>`
+        : ''}
+        ${linksTableItems.length > 0
+        ? `<linkstable>
+                    ${linksTableItems.map((field) => formItem2xml(field)).join('')}
+                </linkstable>`
+        : ''}</custom>`;
+}
+function formItem2xml(field) {
+    return `<field
+        type="${renderFieldTypeToXmlType(field.type)}" 
+        name="${getAttrNameFormItem(field, field.id)}" 
+        sqlname="${renderSqlName(field.type, field.id)}" 
+        ${field.properties && renderProperty(field.properties, AppFieldFormPropertyTypes.LABEL)} 
+        ${field.properties && renderProperty(field.properties, AppFieldFormPropertyTypes.DESCRIPTION)} 
+        mandatory="${field.mandatory}" 
+        solr.type="${renderSolrType(field.type)}" 
+        solr.used="true" 
+        solr.indexed="true" 
+        solr.stored="true" 
+        solr.searchable="true" 
+        solr.multiValued="${field.type === AppFormItemTypes.TAGS || (field.type === AppFormItemTypes.CHECKBOX && true) || false}"
+        teaser="true"
+        display="true"
+        >
+            ${renderWidget(field.type, field.properties)}
+        </field>`;
+}
+function renderWidget(fieldType, fieldProperties) {
+    var _a;
+    switch (fieldType) {
+        case AppFormItemTypes.DESCRIPTION:
+            return '<widget form="textarea"><params><param key="class" value="mceEditor"></param><param key="mention" value="1"></param></params></widget>';
+        case AppFormItemTypes.TEXT:
+            return '<widget form="text"></widget>';
+        case AppFormItemTypes.TEXTAREA:
+            return '<widget form="textarea"></widget>';
+        case AppFormItemTypes.TEXTAREAHTML:
+            return '<widget form="textarea"><params><param key="class" value="mceEditor"></param></params></widget>';
+        case AppFormItemTypes.DATE:
+            return '<widget form="date" format="d/m/Y"></widget>';
+        case AppFormItemTypes.DATETIME:
+            return `<widget form="datetime" format="d/m/Y H:i:s"></widget>`;
+        case AppFormItemTypes.NUMBER: {
+            const isFloat = ((_a = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.CHECKBOX)) === null || _a === void 0 ? void 0 : _a.value) === true;
+            return `<widget form="number">
+                ${isFloat ? `<params><param value="0.01" key="step"/></params>` : ''}
+            </widget>`;
+        }
+        case AppFormItemTypes.SELECT: {
+            const optionEditor = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.OPTIONS_EDITOR);
+            if (!optionEditor)
+                return '';
+            const isMultiple = optionEditor.value.canSelectMultiple;
+            const options = optionEditor.value.propertyOptions;
+            const hasDefaultValue = optionEditor.value.defaultSelectOption;
+            const defaultValue = optionEditor.value.defaultSelectOptionValue;
+            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>` : ''}
+            </widget>`;
+        }
+        case AppFormItemTypes.RADIO: {
+            const optionEditor = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.CHECKBOX);
+            if (!optionEditor)
+                return '';
+            const options = optionEditor.value.propertyOptions;
+            return `<widget form="radio">
+            ${options
+                .map((option) => `<option value="${option.value}" label="${option.title}"></option>`)
+                .join('')}
+            </widget>`;
+        }
+        case AppFormItemTypes.TOGGLE:
+            return `<widget form="checkbox">
+                <options>
+                    <option value="1" label="GLOBAL_Yes"></option>
+                </options>
+                <params>
+                    <param key="jagCheckbox" value="1"></param>
+                </params>
+            </widget>`;
+        case AppFormItemTypes.TAGS: {
+            const taxonomy = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.TAXONOMY);
+            if (!taxonomy)
+                return '';
+            const taxonomyId = taxonomy.value.id;
+            return `<widget form="taxonomy">
+                <params><param key="idTaxonomy" value="${taxonomyId}"></param></params>
+            </widget>`;
+        }
+        case AppFormItemTypes.CHECKBOX: {
+            const optionEditor = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.CHECKBOX);
+            if (!optionEditor)
+                return '';
+            const options = optionEditor.value.propertyOptions;
+            return `<widget form="checkbox" multiple="1">
+                <options>
+                    ${options
+                .map((option) => `<option value="${option.value}" label="${option.label}"></option>`)
+                .join('')}
+                </options>
+            </widget>`;
+        }
+        case AppFormItemTypes.ADDFILEATTACHMENT:
+            return `<widget form="file" type="fileArticle" multiple="1"></widget>`;
+        case AppFormItemTypes.URL:
+            return `<widget form="url"`;
+        case AppFormItemTypes.EMAIL:
+            return `<widget form="email"></widget>`;
+        case ExtraAppFieldsItemViews.USER:
+            return `<widget form="idUser"></widget>`;
+        case AppFormItemTypes.USERLINK:
+            return `<widget form="uri">
+                <params>
+                    <param key="mode" value="ng-view"></param>
+                    <param key="class" value="jcomplete"></param>
+                    <param key="namespace" value="jamespot"></param>
+                    <param key="types" value="user"></param>
+                    <param key="views" value="user"></param>
+                    <param key="jcomplete-url" value="/?action=ajax&amp;group=autocomplete&amp;export function=user"></param>
+                </params>
+            </widget>`;
+        case AppFormItemTypes.CONTENTLINK: {
+            const contentType = fieldProperties === null || fieldProperties === void 0 ? void 0 : fieldProperties.find((property) => property.propertyType === AppFieldFormPropertyTypes.CONTENTTYPE);
+            if (!contentType)
+                return '';
+            const type = contentType.value.type;
+            return `<widget form="uri">
+                <params>
+                    <param key="mode" value="ng-view"></param>
+                    <param key="namespace" value="jamespot"></param>
+                    <param key="types" value="${type}"></param>
+                    <param key="views" value="article"></param>
+                    <param key="jcomplete-url" value="/?action=ajax&amp;group=autocomplete&amp;export function=article&amp;types=[]=${type}"></param>
+                </params>
+            </widget>`;
+        }
+        default:
+            return '';
+    }
+}
+function renderProperty(properties, propertyToFind) {
+    const labelProperty = properties === null || properties === void 0 ? void 0 : properties.find((property) => property.propertyType === propertyToFind);
+    if (labelProperty) {
+        return `${propertyToFind.toLowerCase()}="${labelProperty.value}"`;
+    }
+    return '';
+}
+function renderSqlName(fieldType, fieldId) {
+    switch (fieldType) {
+        case AppFormItemTypes.DESCRIPTION:
+            return 'Description';
+        case ExtraAppFieldsItemViews.USER:
+            return 'IdUser';
+        default:
+            return uuid2Alpha(fieldId);
+    }
+}
+function renderSolrType(fieldType) {
+    switch (fieldType) {
+        case AppFormItemTypes.DESCRIPTION:
+        case AppFormItemTypes.TEXT:
+        case AppFormItemTypes.TEXTAREA:
+        case AppFormItemTypes.TEXTAREAHTML:
+        case AppFormItemTypes.URL:
+        case AppFormItemTypes.EMAIL:
+        case AppFormItemTypes.USERLINK:
+        case AppFormItemTypes.CONTENTLINK:
+        case AppFormItemTypes.NUMBER:
+        case AppFormItemTypes.ADDFILEATTACHMENT:
+            return 'text';
+        case AppFormItemTypes.DATE:
+        case AppFormItemTypes.DATETIME:
+            return 'date';
+        case ExtraAppFieldsItemViews.USER:
+            return 'integer';
+        case AppFormItemTypes.SELECT:
+        case AppFormItemTypes.RADIO:
+        case AppFormItemTypes.TOGGLE:
+        case AppFormItemTypes.CHECKBOX:
+        case AppFormItemTypes.TAGS:
+            return 'string';
+        default:
+            return '';
+    }
+}
+function renderFieldTypeToXmlType(fieldType) {
+    switch (fieldType) {
+        default:
+        case AppFormItemTypes.DESCRIPTION:
+        case AppFormItemTypes.TEXTAREAHTML:
+            return 'html';
+        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:
+        case ExtraAppFieldsItemViews.USER:
+        case AppFormItemTypes.USERLINK:
+        case AppFormItemTypes.CONTENTLINK:
+            return 'text';
+        case AppFormItemTypes.TEXTAREA:
+            return 'longtext';
+        case AppFormItemTypes.DATE:
+            return 'date';
+        case AppFormItemTypes.DATETIME: {
+            return 'date';
+        }
+        case AppFormItemTypes.NUMBER:
+            return 'float';
+    }
+}
+const uuid2Alpha = (id) => {
+    let alphaUuid = '';
+    for (let i = 0; i < id.length; i++) {
+        const c = id.charAt(i);
+        if (c >= '0' && c <= '9')
+            alphaUuid += numToAlpha(Number(c));
+        else if (c >= 'a' && c <= 'z')
+            alphaUuid += c;
+    }
+    return alphaUuid;
+};
+const numToAlpha = (num) => {
+    let s = '', t;
+    while (num > 0) {
+        t = (num - 1) % 26;
+        s = String.fromCharCode(97 + t) + s;
+        num = ((num - t) / 26) | 0;
+    }
+    return s;
+};
+const internal2XmlView = {
+    create: 'create',
+    popup: 'create-popup',
+    edit: 'edit',
+    view: 'display',
+};
+function renderDisplays(studioApp) {
+    let toRet = '';
+    Object.entries(studioApp.views).forEach(([viewName, viewContent]) => {
+        if (Object.prototype.hasOwnProperty.call(internal2XmlView, viewName)) {
+            const viewField = Object.entries(viewContent);
+            toRet += `<display view="${internal2XmlView[viewName]}" mode="${viewName === 'view' ? 'view' : 'form'}">
+                ${viewField.map(([fieldId, view]) => renderDisplayAttr(fieldId, view)).join('')}
+            </display>`;
+        }
+    });
+    if (toRet.length > 0) {
+        toRet = `<displays type="${studioApp.manifest.appShortName}">${toRet}</displays>`;
+    }
+    return toRet;
+}
+function getDisplayName(fieldId, view) {
+    switch (view.type) {
+        case ExtraAppFieldsItemViews.TITLE:
+            return 'title';
+        case ExtraAppFieldsItemViews.SENDALERTTOSUBSCRIBERS:
+            return 'sendAlert';
+        case ExtraAppFieldsItemViews.RECEIVEACOPY:
+            return 'alertAuthor';
+        case ExtraAppFieldsItemViews.PUBLISHTO:
+            return 'publishTo';
+        case ExtraAppFieldsItemViews.USER:
+            return 'idUser';
+        case ExtraAppFieldsItemViews.CREATIONDATE:
+            return 'dateCreation';
+        default:
+            return uuid2Alpha(fieldId);
+    }
+}
+function renderDisplayAttr(fieldId, view) {
+    var _a, _b, _c;
+    let xml = '';
+    const attrName = getDisplayName(fieldId, view);
+    const isFixed = view.isLockedValue;
+    if (isFixed) {
+        const formItemRefWithName = {
+            ref: attrName,
+            fixedValue: view.value,
+        };
+        xml += `<html><![CDATA[ <!-- <JAMESPOT.STUDIO.FIXED>${JSON.stringify(formItemRefWithName)}</JAMESPOT.STUDIO.FIXED> -->`;
+        if (view.type === ExtraAppFieldsItemViews.PUBLISHTO) {
+            const uris = view.value.map((user) => user.uri).join(',');
+            xml += `<input type="hidden" name="publishTo" value="${uris}">`;
+        }
+        else if (view.type === ExtraAppFieldsItemViews.USER ||
+            view.type === AppFormItemTypes.USERLINK ||
+            view.type === AppFormItemTypes.CONTENTLINK) {
+            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}">`;
+            });
+        }
+        else if (view.type === AppFormItemTypes.CHECKBOX) {
+            const values = view.value;
+            values.forEach((value) => {
+                xml += `<input type="hidden" name="${attrName}[]" value="${value.value}">`;
+            });
+        }
+        else if (view.type === AppFormItemTypes.DATE) {
+            const dateValue = new Date(view.value);
+            const xmlFixedValue = [
+                pad(dateValue.getDate()),
+                pad(dateValue.getMonth() + 1),
+                dateValue.getFullYear(),
+            ].join('/');
+            xml += '<input type="hidden" name="' + attrName + '" value="' + xmlFixedValue + '">';
+        }
+        else if (view.type === AppFormItemTypes.DATETIME) {
+            const dateValue = new Date(view.value);
+            const xmlFixedValue = [
+                pad(dateValue.getDate()),
+                pad(dateValue.getMonth() + 1),
+                dateValue.getFullYear(),
+                pad(dateValue.getHours()),
+                pad(dateValue.getMinutes()),
+                pad(dateValue.getSeconds()),
+            ].join('/');
+            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}">`;
+        }
+        else {
+            xml += `<input type="hidden" name="${attrName}" value="${view.value}">`;
+        }
+        xml += ']]></html>';
+    }
+    else {
+        switch (view.type) {
+            case AppFormItemTypes.CODEHTML: {
+                const content = {
+                    ref: attrName,
+                    fixedValue: {
+                        html: view.value.html,
+                        text: view.value.text,
+                    },
+                };
+                xml += `<html><![CDATA[ <!-- <JAMESPOT.STUDIO.CODEHTML>${JSON.stringify(content)}</JAMESPOT.STUDIO.CODEHTML><JAMESPOT.STUDIO.FIELD_POS></JAMESPOT.STUDIO.FIELD_POS>-->]]></html>`;
+                break;
+            }
+            case AppFormItemTypes.IMAGE:
+                xml += '<image />';
+                break;
+            case ExtraAppFieldsItemViews.PUBLISHTO:
+                xml += '<publishTo />';
+                break;
+            default:
+                xml += "<attr name='" + attrName + "' />";
+                break;
+        }
+    }
+    return xml;
+}
+function pad(s) {
+    return s < 10 ? '0' + s : s;
+}
+
 const initialState$1 = {
     currentStudioApp: null,
     fetchCurrentStudioAppStatus: 'idle',
     saveCurrentStudioAppStatus: 'idle',
+    installStudioAppStatus: 'idle',
+    hasChanged: false,
 };
 const fetchCurrentStudioApp = createAsyncThunk('studio/fetchCurrentStudioApp', ({ idApp, status }, { extra, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
     const jApi = extra.jApi;
@@ -2168,6 +3080,24 @@ const saveCurrentStudioApp = createAsyncThunk('studio/saveCurrentStudioApp', (_,
         return rejectWithValue(error);
     }
 }));
+const installStudioApp = createAsyncThunk('studio/installApp', (_, { extra, rejectWithValue, getState, dispatch }) => __awaiter(void 0, void 0, void 0, function* () {
+    const jApi = extra.jApi;
+    const error = { error: 1, errorMsg: 'Error saving application' };
+    const currentStudioApp = getState().studio.currentStudioApp.currentStudioApp;
+    if (!currentStudioApp) {
+        return rejectWithValue(error);
+    }
+    const xml = appToXml(currentStudioApp);
+    try {
+        yield jApi.application.install(xml);
+        dispatch(Toast.actions.success({ label: 'APPSTUDIO_AppItem_Edition_Saved' }));
+        return;
+    }
+    catch (_) {
+        dispatch(Toast.actions.error({ label: 'GLOBAL_Technical_Error' }));
+        return rejectWithValue(error);
+    }
+}));
 const CurrentStudioAppSlice = createSlice({
     name: 'currentStudioApp',
     initialState: initialState$1,
@@ -2178,6 +3108,9 @@ const CurrentStudioAppSlice = createSlice({
         resetCurrentApp: (state) => {
             state.currentStudioApp = null;
         },
+        setHasChanged: (state, action) => {
+            state.hasChanged = action.payload;
+        },
     },
     extraReducers: (builder) => {
         builder
@@ -2205,6 +3138,18 @@ const CurrentStudioAppSlice = createSlice({
             .addCase(saveCurrentStudioApp.rejected, (state) => {
             if (state.saveCurrentStudioAppStatus === 'pending')
                 state.saveCurrentStudioAppStatus = 'idle';
+        })
+            .addCase(installStudioApp.pending, (state) => {
+            if (state.installStudioAppStatus === 'idle')
+                state.installStudioAppStatus = 'pending';
+        })
+            .addCase(installStudioApp.fulfilled, (state) => {
+            if (state.installStudioAppStatus === 'pending')
+                state.installStudioAppStatus = 'idle';
+        })
+            .addCase(installStudioApp.rejected, (state) => {
+            if (state.installStudioAppStatus === 'pending')
+                state.installStudioAppStatus = 'idle';
         });
     },
 });
@@ -2260,6 +3205,7 @@ function createNewStudioApp$1({ author, appName }) {
             idApp: newAppId,
             status: APP_STATUS_TYPE.DRAFT,
             author: author || '',
+            studioVersion: 2,
             manifest: {
                 appShortName: appName,
                 appName: appName,
@@ -2524,12 +3470,13 @@ const studio = {
         cloneStudioApp,
         createNewStudioApp,
         fetchCurrentStudioApp,
-        saveCurrentStudioApp }),
+        saveCurrentStudioApp,
+        installStudioApp }),
     selectors: {
         selectStudioAppsList,
         selectCurrentStudioApp,
     },
 };
 
-export { APP_STATUS_TYPE, AUDIENCE, AppFieldFormPropertyTypes, AppFormBannedFromViews, AppFormItemTypes, AppFormUniqueList, Application, AssetReservation, Bookmark, Comment, ExtraAppFieldsItemViews, Faq, MODE_EDIT, MODE_VIEW, MapExtraFieldsWithView, Model, Network, Platform, STUDIO_VIEW, Share, StatusType, TVDisplay, TinyMCE, Toast, UserCurrent, WedocApp, Widget, WidgetEditor, actions, jland, slice, studio, updateWidgetContent, viewsList };
+export { APP_STATUS_TYPE, AUDIENCE, Animations, AppColumnsDefaultTypes, AppFieldFormPropertyTypes, AppFormBannedFromViews$1 as AppFormBannedFromViews, AppFormItemTypes, AppFormPrimaryList, AppFormUniqueList, Application, AssetReservation, Bookmark, Comment, ExtraAppFieldsItemViews, Faq, MODE_EDIT, MODE_VIEW, MapExtraFieldsWithView, Model, Network, Platform, STUDIO_VIEW, Share, StatusType$1 as StatusType, TVDisplay, TinyMCE, Toast, UserCurrent, WedocApp, Widget, WidgetEditor, actions, animationsReducer, animationsSlice, deleteCurrentAnimation, fetchCurrentAnimation, fetchCurrentAnimationApp, jland, saveCurrentAnimation, slice, studio, toggleAnimationIsActive, updateWidgetContent, viewsList };
 //# sourceMappingURL=esm.js.map