@umbraco-cms/backoffice 17.0.0-rc2 → 17.0.0-rc4

package/dist-cms/packages/core/localization/manifests.js

@@ -2,281 +2,335 @@ export const manifests = [
     {
         type: 'localization',
         alias: 'Umb.Localization.AR',
-        weight: 100,
         name: 'Arabic Backoffice UI Localization',
-        meta: {
-            culture: 'ar',
-        },
+        meta: { culture: 'ar' },
         js: () => import('../../../assets/lang/ar.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.BS',
-        weight: 100,
         name: 'Bosnian Backoffice UI Localization',
-        meta: {
-            culture: 'bs',
-        },
+        meta: { culture: 'bs' },
         js: () => import('../../../assets/lang/bs.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.CS',
-        weight: 100,
         name: 'Czech Backoffice UI Localization',
-        meta: {
-            culture: 'cs',
-        },
+        meta: { culture: 'cs' },
         js: () => import('../../../assets/lang/cs.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.CS_CZ',
+        name: 'Czech (Czechia) Backoffice UI Localization',
+        meta: { culture: 'cs-CZ' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.CY',
-        weight: 100,
         name: 'Welsh Backoffice UI Localization',
-        meta: {
-            culture: 'cy',
-        },
+        meta: { culture: 'cy' },
         js: () => import('../../../assets/lang/cy.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.CY_GB',
+        name: 'Welsh (UK) Backoffice UI Localization',
+        meta: { culture: 'cy-GB' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.DA',
-        weight: 100,
         name: 'Danish Backoffice UI Localization',
-        meta: {
-            culture: 'da',
-        },
+        meta: { culture: 'da' },
         js: () => import('../../../assets/lang/da.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.DA-DK',
+        name: 'Danish (Denmark) Backoffice UI Localization',
+        meta: { culture: 'da-DK' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.DE',
-        weight: 100,
         name: 'German Backoffice UI Localization',
-        meta: {
-            culture: 'de',
-        },
+        meta: { culture: 'de' },
         js: () => import('../../../assets/lang/de.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.DE_DE',
+        name: 'German (Germany) Backoffice UI Localization',
+        meta: { culture: 'de-DE' },
+    },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.DE_CH',
+        name: 'German (Switzerland) Backoffice UI Localization',
+        meta: { culture: 'de-CH' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.EN',
-        weight: 100,
         name: 'English (United Kingdom) Backoffice UI Localization',
-        meta: {
-            culture: 'en',
-        },
+        meta: { culture: 'en' },
         js: () => import('../../../assets/lang/en.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.EN_US',
-        weight: 100,
         name: 'English (United States) Backoffice UI Localization',
-        meta: {
-            culture: 'en-US',
-        },
+        meta: { culture: 'en-US' },
         js: () => import('../../../assets/lang/en-us.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.ES',
-        weight: 100,
         name: 'Spanish Backoffice UI Localization',
-        meta: {
-            culture: 'es',
-        },
+        meta: { culture: 'es' },
         js: () => import('../../../assets/lang/es.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.ES_ES',
+        name: 'Spanish (Spain) Backoffice UI Localization',
+        meta: { culture: 'es-ES' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.FR',
-        weight: 100,
         name: 'French Backoffice UI Localization',
-        meta: {
-            culture: 'fr',
-        },
+        meta: { culture: 'fr' },
         js: () => import('../../../assets/lang/fr.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.FR_FR',
+        name: 'French (France) Backoffice UI Localization',
+        meta: { culture: 'fr-FR' },
+    },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.FR_CH',
+        name: 'French (Switzerland) Backoffice UI Localization',
+        meta: { culture: 'fr-CH' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.HE',
-        weight: 100,
         name: 'Hebrew Backoffice UI Localization',
-        meta: {
-            culture: 'he',
-        },
+        meta: { culture: 'he' },
         js: () => import('../../../assets/lang/he.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.HE_IL',
+        name: 'Hebrew (Israel) Backoffice UI Localization',
+        meta: { culture: 'he-IL' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.HR',
-        weight: 100,
         name: 'Croatian Backoffice UI Localization',
-        meta: {
-            culture: 'hr',
-        },
+        meta: { culture: 'hr' },
         js: () => import('../../../assets/lang/hr.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.HR_HR',
+        name: 'Croatian (Croatia) Backoffice UI Localization',
+        meta: { culture: 'hr-HR' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.IT',
-        weight: 100,
         name: 'Italian Backoffice UI Localization',
-        meta: {
-            culture: 'it',
-        },
+        meta: { culture: 'it' },
         js: () => import('../../../assets/lang/it.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.IT_IT',
+        name: 'Italian (Italy) Backoffice UI Localization',
+        meta: { culture: 'it-IT' },
+    },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.IT_CH',
+        name: 'Italian (Switzerland) Backoffice UI Localization',
+        meta: { culture: 'it-CH' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.JA',
-        weight: 100,
         name: 'Japanese Backoffice UI Localization',
-        meta: {
-            culture: 'ja',
-        },
+        meta: { culture: 'ja' },
         js: () => import('../../../assets/lang/ja.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.JA_JP',
+        name: 'Japanese (Japan) Backoffice UI Localization',
+        meta: { culture: 'ja-JP' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.KO',
-        weight: 100,
         name: 'Korean Backoffice UI Localization',
-        meta: {
-            culture: 'ko',
-        },
+        meta: { culture: 'ko' },
         js: () => import('../../../assets/lang/ko.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.KO_KR',
+        name: 'Korean (Korea) Backoffice UI Localization',
+        meta: { culture: 'ko-KR' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.NB',
-        weight: 100,
         name: 'Norwegian Backoffice UI Localization',
-        meta: {
-            culture: 'nb',
-        },
+        meta: { culture: 'nb' },
         js: () => import('../../../assets/lang/nb.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.NB_NO',
+        name: 'Norwegian (Norway) Backoffice UI Localization',
+        meta: { culture: 'nb-NO' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.NL',
-        weight: 100,
         name: 'Dutch Backoffice UI Localization',
-        meta: {
-            culture: 'nl',
-        },
+        meta: { culture: 'nl' },
         js: () => import('../../../assets/lang/nl.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.NL_NL',
+        name: 'Dutch (Netherlands) Backoffice UI Localization',
+        meta: { culture: 'nl-NL' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.PL',
-        weight: 100,
         name: 'Polish Backoffice UI Localization',
-        meta: {
-            culture: 'pl',
-        },
+        meta: { culture: 'pl' },
         js: () => import('../../../assets/lang/pl.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.PL_PL',
+        name: 'Polish (Poland) Backoffice UI Localization',
+        meta: { culture: 'pl-PL' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.PT',
-        weight: 100,
         name: 'Portuguese Backoffice UI Localization',
-        meta: {
-            culture: 'pt',
-        },
+        meta: { culture: 'pt' },
         js: () => import('../../../assets/lang/pt.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.PT_BR',
-        weight: 100,
         name: 'Portuguese (Brazil) Backoffice UI Localization',
-        meta: {
-            culture: 'pt-BR',
-        },
+        meta: { culture: 'pt-BR' },
         js: () => import('../../../assets/lang/pt-br.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.RO',
-        weight: 100,
         name: 'Romanian Backoffice UI Localization',
-        meta: {
-            culture: 'ro',
-        },
+        meta: { culture: 'ro' },
         js: () => import('../../../assets/lang/ro.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.RO_RO',
+        name: 'Romanian (Romania) Backoffice UI Localization',
+        meta: { culture: 'ro-RO' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.RU',
-        weight: 100,
         name: 'Russian Backoffice UI Localization',
-        meta: {
-            culture: 'ru',
-        },
+        meta: { culture: 'ru' },
         js: () => import('../../../assets/lang/ru.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.RU_RU',
+        name: 'Russian (Russia) Backoffice UI Localization',
+        meta: { culture: 'ru-RU' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.SV',
-        weight: 100,
         name: 'Swedish Backoffice UI Localization',
-        meta: {
-            culture: 'sv',
-        },
+        meta: { culture: 'sv' },
         js: () => import('../../../assets/lang/sv.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.SV_SE',
+        name: 'Swedish (Sweden) Backoffice UI Localization',
+        meta: { culture: 'sv-SE' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.TR',
-        weight: 100,
         name: 'Turkish Backoffice UI Localization',
-        meta: {
-            culture: 'tr',
-        },
+        meta: { culture: 'tr' },
         js: () => import('../../../assets/lang/tr.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.TR_TR',
+        name: 'Turkish (Türkiye) Backoffice UI Localization',
+        meta: { culture: 'tr-TR' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.UK',
-        weight: 100,
         name: 'Ukrainian Backoffice UI Localization',
-        meta: {
-            culture: 'uk',
-        },
+        meta: { culture: 'uk' },
         js: () => import('../../../assets/lang/uk.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.UK_UA',
+        name: 'Ukrainian (Ukraine) Backoffice UI Localization',
+        meta: { culture: 'uk-UA' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.ZH',
-        weight: 100,
         name: 'Chinese Backoffice UI Localization',
-        meta: {
-            culture: 'zh',
-        },
+        meta: { culture: 'zh' },
         js: () => import('../../../assets/lang/zh.js'),
     },
+    {
+        type: 'localization',
+        alias: 'Umb.Localization.ZH_CN',
+        name: 'Chinese (Simplified, China) Backoffice UI Localization',
+        meta: { culture: 'zh-CN' },
+    },
     {
         type: 'localization',
         alias: 'Umb.Localization.ZH_TW',
-        weight: 100,
         name: 'Chinese (Taiwan) Backoffice UI Localization',
-        meta: {
-            culture: 'zh-TW',
-        },
+        meta: { culture: 'zh-TW' },
         js: () => import('../../../assets/lang/zh-tw.js'),
     },
     {
         type: 'localization',
         alias: 'Umb.Localization.VI',
-        weight: 100,
         name: 'Vietnamese Backoffice UI Localization',
-        meta: {
-            culture: 'vi',
-        },
+        meta: { culture: 'vi' },
         js: () => import('../../../assets/lang/vi.js'),
     },
 ];

package/dist-cms/packages/core/picker-input/picker-input.context.d.ts

@@ -35,7 +35,10 @@ export declare class UmbPickerInputContext<PickedItemType extends UmbItemModel =
      */
     constructor(host: UmbControllerHost, repositoryAlias: string, modalAlias?: string | UmbModalToken<UmbPickerModalData<PickerItemType>, PickerModalValueType>);
     getSelection(): string[];
+    getSelectedItems(): PickedItemType[];
+    getSelectedItemByUnique(unique: string): PickedItemType | undefined;
     setSelection(selection: Array<string | null>): void;
     openPicker(pickerData?: Partial<PickerModalConfigType>): Promise<void>;
+    protected _requestItemName(unique: string): Promise<string>;
     requestRemoveItem(unique: string): Promise<void>;
 }

package/dist-cms/packages/core/picker-input/picker-input.context.js

@@ -49,6 +49,12 @@ export class UmbPickerInputContext extends UmbContextBase {
     getSelection() {
         return this.#itemManager.getUniques();
     }
+    getSelectedItems() {
+        return this.#itemManager.getItems();
+    }
+    getSelectedItemByUnique(unique) {
+        return this.#itemManager.getItems().find((item) => item.unique === unique);
+    }
     setSelection(selection) {
         // Note: Currently we do not support picking root item. So we filter out null values:
         this.#itemManager.setUniques(selection.filter((value) => value !== null));
@@ -72,9 +78,11 @@ export class UmbPickerInputContext extends UmbContextBase {
         this.setSelection(modalValue.selection);
         this.getHostElement().dispatchEvent(new UmbChangeEvent());
     }
+    async _requestItemName(unique) {
+        return this.getSelectedItemByUnique(unique)?.name ?? '#general_notFound';
+    }
     async requestRemoveItem(unique) {
-        const item = this.#itemManager.getItems().find((item) => item.unique === unique);
-        const name = item?.name ?? '#general_notFound';
+        const name = await this._requestItemName(unique);
         await umbConfirmModal(this, {
             color: 'danger',
             headline: `#actions_remove ${name}?`,

package/dist-cms/packages/core/resources/try-execute/tryXhrRequest.function.js

@@ -36,6 +36,7 @@ function createXhrRequest(options) {
     return new UmbCancelablePromise(async (resolve, reject, onCancel) => {
         const xhr = new XMLHttpRequest();
         xhr.open(options.method, `${baseUrl}${options.url}`, true);
+        xhr.withCredentials = options.withCredentials ?? true;
         // Set default headers
         if (options.token) {
             const token = typeof options.token === 'function' ? await options.token() : options.token;

package/dist-cms/packages/core/resources/types.d.ts

@@ -4,6 +4,7 @@ export interface XhrRequestOptions extends UmbTryExecuteOptions {
     baseUrl?: string;
     method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
     url: string;
+    withCredentials?: boolean;
     body?: unknown;
     token?: string | (() => undefined | string | Promise<string | undefined>);
     headers?: Record<string, string>;

package/dist-cms/packages/core/utils/config-collection/index.d.ts

@@ -1,8 +1,10 @@
-import type { UmbConfigCollectionModel } from './types.js';
+import type { UmbConfigCollectionEntryModel } from './types.js';
 /**
  * Get a value from a config collection by its alias.
- * @param {UmbConfigCollectionModel | undefined} config - The config collection to get the value from.
- * @param {string} alias - The alias of the value to get.
- * @returns {T | undefined} The value with the specified alias, or undefined if not found or if the config is undefined.
+ * @param config - The config collection to get the value from.
+ * @param alias - The alias of the config entry to get the value for.
+ * @returns The value of the config entry with the specified alias, or undefined if not found.
  */
-export declare function getConfigValue<T>(config: UmbConfigCollectionModel | undefined, alias: string): T | undefined;
+export declare function getConfigValue<T extends UmbConfigCollectionEntryModel, K extends T['alias']>(config: T[] | undefined, alias: K): Extract<T, {
+    alias: K;
+}>["value"] | undefined;

package/dist-cms/packages/core/utils/config-collection/index.js

@@ -1,10 +1,9 @@
 /**
  * Get a value from a config collection by its alias.
- * @param {UmbConfigCollectionModel | undefined} config - The config collection to get the value from.
- * @param {string} alias - The alias of the value to get.
- * @returns {T | undefined} The value with the specified alias, or undefined if not found or if the config is undefined.
+ * @param config - The config collection to get the value from.
+ * @param alias - The alias of the config entry to get the value for.
+ * @returns The value of the config entry with the specified alias, or undefined if not found.
  */
 export function getConfigValue(config, alias) {
-    const entry = config?.find((entry) => entry.alias === alias);
-    return entry?.value;
+    return config?.find((entry) => entry.alias === alias)?.value;
 }

package/dist-cms/packages/documents/documents/components/input-document/input-document.context.d.ts

@@ -18,5 +18,6 @@ UmbDocumentTreeItemModel, UmbDocumentPickerModalData, UmbDocumentPickerModalValu
     #private;
     constructor(host: UmbControllerHost);
     openPicker(pickerData?: Partial<UmbDocumentPickerModalData>, args?: UmbDocumentPickerInputContextOpenArgs): Promise<void>;
+    protected _requestItemName(unique: string): Promise<string>;
 }
 export {};

package/dist-cms/packages/documents/documents/components/input-document/input-document.context.js

@@ -2,6 +2,7 @@ import { UMB_DOCUMENT_PICKER_MODAL, UMB_DOCUMENT_SEARCH_PROVIDER_ALIAS } from '.
 import { UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS } from '../../item/constants.js';
 import { UmbPickerInputContext } from '../../../../core/picker-input/index.js';
 import { UMB_VARIANT_CONTEXT } from '../../../../core/variant/index.js';
+import { UmbDocumentItemDataResolver } from '../../item/index.js';
 export class UmbDocumentPickerInputContext extends UmbPickerInputContext {
     constructor(host) {
         super(host, UMB_DOCUMENT_ITEM_REPOSITORY_ALIAS, UMB_DOCUMENT_PICKER_MODAL);
@@ -30,6 +31,14 @@ export class UmbDocumentPickerInputContext extends UmbPickerInputContext {
         };
         await super.openPicker(combinedPickerData);
     }
+    async _requestItemName(unique) {
+        const item = this.getSelectedItemByUnique(unique);
+        const resolver = new UmbDocumentItemDataResolver(this);
+        resolver.setData(item);
+        const name = await resolver.getName();
+        this.removeUmbController(resolver);
+        return name ?? '#general_notFound';
+    }
     #pickableFilter = (item, allowedContentTypes) => {
         if (allowedContentTypes && allowedContentTypes.length > 0) {
             return allowedContentTypes

package/dist-cms/packages/documents/documents/user-permissions/document/repository/document-permission.server.data.js

@@ -16,6 +16,7 @@ export class UmbDocumentPermissionServerDataSource {
     requestPermissions(id) {
         return tryExecute(this.#host, fetch(`/umbraco/management/api/v1/document/${id}/permissions`, {
             method: 'GET',
+            credentials: 'include',
             headers: {
                 'Content-Type': 'application/json',
             },