@umbraco-cms/backoffice 18.3.0-rc → 19.0.0-beta1

package/dist-cms/packages/documents/documents/language-access/manifests.js

@@ -0,0 +1,16 @@
+import { UMB_DOCUMENT_WORKSPACE_ALIAS } from '../constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../core/workspace/index.js';
+export const manifests = [
+    {
+        type: 'workspaceContext',
+        kind: 'contentLanguageAccess',
+        name: 'Document Language Access Workspace Context',
+        alias: 'Umb.WorkspaceContext.DocumentLanguageAccess',
+        conditions: [
+            {
+                alias: UMB_WORKSPACE_CONDITION_ALIAS,
+                match: UMB_DOCUMENT_WORKSPACE_ALIAS,
+            },
+        ],
+    },
+];

package/dist-cms/packages/documents/documents/manifests.js

@@ -2,6 +2,7 @@ import { manifests as startNodeManifests } from './user-start-node/manifests.js'
 import { manifests as auditLogManifests } from './audit-log/manifests.js';
 import { manifests as collectionManifests } from './collection/manifests.js';
 import { manifests as configurationManifests } from './configuration/manifests.js';
+import { manifests as dynamicRootManifests } from './dynamic-root/manifests.js';
 import { manifests as entityActionManifests } from './entity-actions/manifests.js';
 import { manifests as entityBulkActionManifests } from './entity-bulk-actions/manifests.js';
 import { manifests as entitySignManifests } from './entity-sign/manifests.js';
@@ -24,13 +25,14 @@ import { manifests as urlManifests } from './url/manifests.js';
 import { manifests as userPermissionManifests } from './user-permissions/manifests.js';
 import { manifests as variantStateManifests } from './variant-state/manifests.js';
 import { manifests as workspaceManifests } from './workspace/manifests.js';
-import { manifests as allowEditInvariantFromNonDefaultManifests } from './allow-edit-invariant-from-non-default/manifests.js';
+import { manifests as languageAccessManifests } from './language-access/manifests.js';
 import * as entryPointModule from './entry-point.js';
 export const manifests = [
     ...startNodeManifests,
     ...auditLogManifests,
     ...collectionManifests,
     ...configurationManifests,
+    ...dynamicRootManifests,
     ...entityActionManifests,
     ...entityBulkActionManifests,
     ...entitySignManifests,
@@ -53,7 +55,7 @@ export const manifests = [
     ...userPermissionManifests,
     ...variantStateManifests,
     ...workspaceManifests,
-    ...allowEditInvariantFromNonDefaultManifests,
+    ...languageAccessManifests,
     {
         name: 'Document Backoffice Entry Point',
         alias: 'Umb.BackofficeEntryPoint.Document',

package/dist-cms/packages/documents/documents/modals/shared/document-variant-language-picker.element.js

@@ -49,6 +49,10 @@ let UmbDocumentVariantLanguagePickerElement = class UmbDocumentVariantLanguagePi
             });
         }
     }
+    #hasSelectableOption() {
+        const isAllowed = this.selectionManager.getAllowLimitation();
+        return this.variantLanguageOptions.some((option) => isAllowed(option.unique));
+    }
     #onSelectAllChange(event) {
         const allUniques = this.variantLanguageOptions.map((o) => o.unique);
         const filter = this.selectionManager.getAllowLimitation();
@@ -76,7 +80,8 @@ let UmbDocumentVariantLanguagePickerElement = class UmbDocumentVariantLanguagePi
 			<uui-checkbox
 				@change=${this.#onSelectAllChange}
 				label=${this.localize.term('general_selectAll')}
-				.checked=${this._isAllSelected}></uui-checkbox>
+				.checked=${this._isAllSelected}
+				?disabled=${!this.#hasSelectableOption()}></uui-checkbox>
 			${repeat(this.variantLanguageOptions, (option) => option.unique, (option) => html ` ${this.#renderItem(option)} `)}
 		`;
     }

package/dist-cms/packages/documents/documents/picker/document-picker-search-result-item.element.d.ts

@@ -3,7 +3,7 @@ import { nothing } from '../../../../external/lit/index.js';
 import { UmbPickerSearchResultItemElementBase } from '../../../core/picker/index.js';
 export declare class UmbDocumentPickerSearchResultItemElement extends UmbPickerSearchResultItemElementBase<UmbDocumentSearchItemModel> {
     #private;
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
 }
 export { UmbDocumentPickerSearchResultItemElement as element };
 declare global {

package/dist-cms/packages/documents/documents/property-dataset-context/document-property-dataset.context.d.ts

@@ -4,5 +4,5 @@ import type { UmbDocumentTypeDetailModel } from '../../document-types/index.js';
 import type { UmbVariantId } from '../../../core/variant/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 export declare class UmbDocumentPropertyDatasetContext extends UmbContentPropertyDatasetContext<UmbDocumentDetailModel, UmbDocumentTypeDetailModel, UmbDocumentVariantModel> {
-    constructor(host: UmbControllerHost, dataOwner: UmbDocumentWorkspaceContext, variantId?: UmbVariantId);
+    constructor(host: UmbControllerHost, dataOwner: UmbDocumentWorkspaceContext, variantId: UmbVariantId);
 }

package/dist-cms/packages/documents/documents/property-editors/document-picker/manifests.js

@@ -1,3 +1,4 @@
+import { UMB_DOCUMENT_DYNAMIC_ROOT_PROPERTY_EDITOR_UI_ALIAS } from '../../dynamic-root/constants.js';
 import { manifest as schemaManifest } from './Umbraco.ContentPicker.js';
 import { manifests as valueSummaryManifests } from './value-summary/manifests.js';
 export const manifests = [
@@ -7,8 +8,7 @@ export const manifests = [
         name: 'Document Picker Property Editor UI',
         element: () => import('./property-editor-ui-document-picker.element.js'),
         meta: {
-            supportsVariantChange: true,
-            label: 'Document Picker',
+            label: 'Single Document Picker',
             propertyEditorSchemaAlias: 'Umbraco.ContentPicker',
             icon: 'icon-document',
             group: '#propertyEditorUIGroups_pickers',
@@ -37,6 +37,13 @@ export const manifests = [
                         ],
                         weight: 20,
                     },
+                    {
+                        alias: 'dynamicRoot',
+                        label: 'Dynamic root',
+                        description: 'Resolve the start node from the content being edited, when no start node is set',
+                        propertyEditorUiAlias: UMB_DOCUMENT_DYNAMIC_ROOT_PROPERTY_EDITOR_UI_ALIAS,
+                        weight: 30,
+                    },
                 ],
             },
         },

package/dist-cms/packages/documents/documents/property-editors/document-picker/property-editor-ui-document-picker.element.d.ts

@@ -19,7 +19,7 @@ export declare class UmbPropertyEditorUIDocumentPickerElement extends UmbPropert
     private _allowedContentTypes?;
     private _interactionMemories;
     constructor();
-    firstUpdated(): void;
+    firstUpdated(): Promise<void>;
     render(): import("lit-html").TemplateResult<1>;
 }
 export default UmbPropertyEditorUIDocumentPickerElement;

package/dist-cms/packages/documents/documents/property-editors/document-picker/property-editor-ui-document-picker.element.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../../entity.js';
+import { UmbDocumentDynamicRootResolver } from '../../dynamic-root/document-dynamic-root-resolver.controller.js';
 import { customElement, html, property, state } from '../../../../../external/lit/index.js';
 import { UmbChangeEvent } from '../../../../core/event/index.js';
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
@@ -21,9 +22,12 @@ let UmbPropertyEditorUIDocumentPickerElement = class UmbPropertyEditorUIDocument
             this._max = minMax.max && minMax.max > 0 ? minMax.max : 1;
         }
         this._startNodeId = config.getValueByAlias('startNodeId');
+        this.#dynamicRoot = config.getValueByAlias('dynamicRoot');
         const allowedContentTypes = config.getValueByAlias('allowedContentTypes');
         this._allowedContentTypes = allowedContentTypes ? allowedContentTypes.split(',').filter(Boolean) : undefined;
     }
+    #dynamicRoot;
+    #dynamicRootResolver;
     #interactionMemoryManager;
     constructor() {
         super();
@@ -40,6 +44,7 @@ let UmbPropertyEditorUIDocumentPickerElement = class UmbPropertyEditorUIDocument
         // NOTE: The legacy "Content Picker" property-editor only supported 1 item,
         // so that's why it's being enforced here. We'll evolve this in a future version. [LK]
         this._max = 1;
+        this.#dynamicRootResolver = new UmbDocumentDynamicRootResolver(this);
         this._interactionMemories = [];
         this.#interactionMemoryManager = new UmbPropertyEditorUiInteractionMemoryManager(this, {
             memoryUniquePrefix: 'UmbDocumentPicker',
@@ -48,8 +53,12 @@ let UmbPropertyEditorUIDocumentPickerElement = class UmbPropertyEditorUIDocument
             this._interactionMemories = interactionMemories ?? [];
         }, null);
     }
-    firstUpdated() {
+    async firstUpdated() {
         this.addFormControlElement(this.shadowRoot.querySelector('umb-input-document'));
+        // A fixed start node wins; the dynamic root is only resolved when there is none.
+        if (!this._startNodeId) {
+            this._startNodeId = await this.#dynamicRootResolver.resolveStartNodeUnique(this.#dynamicRoot);
+        }
     }
     #onChange(event) {
         this.value = event.target.value;

package/dist-cms/packages/documents/documents/property-editors/document-picker/value-summary/manifests.js

@@ -1,4 +1,5 @@
 import { UMB_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE } from '../value-type/constants.js';
+import { UMB_MULTIPLE_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE } from '../../multiple-document-picker/value-type/constants.js';
 export const manifests = [
     {
         type: 'valueSummary',
@@ -9,4 +10,13 @@ export const manifests = [
         element: () => import('./value-summary.js'),
         valueResolver: () => import('./value-summary.js'),
     },
+    {
+        type: 'valueSummary',
+        kind: 'default',
+        alias: 'Umb.ValueSummary.PropertyEditor.MultipleDocumentPicker',
+        name: 'Multiple Document Picker Property Editor Value Summary',
+        forValueType: UMB_MULTIPLE_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE,
+        element: () => import('./value-summary.js'),
+        valueResolver: () => import('./value-summary.js'),
+    },
 ];

package/dist-cms/packages/documents/documents/property-editors/document-picker/value-summary/value-summary.element.d.ts

@@ -2,12 +2,15 @@ import type { UmbDocumentItemModel } from '../../../item/repository/types.js';
 import { nothing } from '../../../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../../../core/value-summary/index.js';
 import type { PropertyValueMap } from '../../../../../../external/lit/index.js';
+/**
+ * Renders the picked documents' names, variant-aware and comma-joined, for the document pickers holding one or
+ * several documents.
+ */
 export declare class UmbDocumentPickerPropertyEditorValueSummaryElement extends UmbValueSummaryElementBase<Array<UmbDocumentItemModel>> {
     #private;
-    private _name?;
-    constructor();
+    private _names;
     protected willUpdate(changedProperties: PropertyValueMap<this>): void;
-    render(): import("lit-html").TemplateResult<1> | typeof nothing;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist-cms/packages/documents/documents/property-editors/document-picker/value-summary/value-summary.element.js

@@ -7,27 +7,71 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { UmbDocumentItemDataResolver } from '../../../item/document-item-data-resolver.js';
 import { customElement, html, nothing, state } from '../../../../../../external/lit/index.js';
 import { UmbValueSummaryElementBase } from '../../../../../core/value-summary/index.js';
+/**
+ * Renders the picked documents' names, variant-aware and comma-joined, for the document pickers holding one or
+ * several documents.
+ */
 let UmbDocumentPickerPropertyEditorValueSummaryElement = class UmbDocumentPickerPropertyEditorValueSummaryElement extends UmbValueSummaryElementBase {
-    #resolver = new UmbDocumentItemDataResolver(this);
     constructor() {
-        super();
-        this.observe(this.#resolver.name, (name) => (this._name = name), null);
+        super(...arguments);
+        this._names = [];
+        this.#resolvers = new Map();
+        this.#resolvedNames = new Map();
     }
+    #resolvers;
+    #resolvedNames;
     willUpdate(changedProperties) {
         super.willUpdate(changedProperties);
         if (changedProperties.has('_value')) {
-            this.#resolver.setData(this._value?.[0]);
+            this.#syncResolvers();
         }
     }
+    #syncResolvers() {
+        const value = this._value ?? [];
+        for (const unique of this.#resolvers.keys()) {
+            if (!value.some((item) => item.unique === unique)) {
+                this.#removeResolver(unique);
+            }
+        }
+        for (const item of value) {
+            this.#addOrUpdateResolver(item);
+        }
+        this.#buildNames();
+    }
+    #removeResolver(unique) {
+        this.#resolvers.get(unique)?.destroy();
+        this.#resolvers.delete(unique);
+        this.#resolvedNames.delete(unique);
+        this.removeUmbControllerByAlias(`document-${unique}`);
+    }
+    #addOrUpdateResolver(item) {
+        if (this.#resolvers.has(item.unique)) {
+            this.#resolvers.get(item.unique).setData(item);
+            return;
+        }
+        const resolver = new UmbDocumentItemDataResolver(this);
+        resolver.setData(item);
+        this.#resolvers.set(item.unique, resolver);
+        this.observe(resolver.name, (name) => {
+            this.#resolvedNames.set(item.unique, name ?? '');
+            this.#buildNames();
+        }, `document-${item.unique}`);
+    }
+    #buildNames() {
+        this._names = (this._value ?? []).map((item) => this.#resolvedNames.get(item.unique) ?? '');
+    }
     render() {
-        if (!this._value?.length || !this._name)
+        if (!this._value?.length)
+            return nothing;
+        const text = this._names.filter(Boolean).join(', ');
+        if (!text)
             return nothing;
-        return html `<span title="${this._name}">${this._name}</span>`;
+        return html `<span title="${text}">${text}</span>`;
     }
 };
 __decorate([
     state()
-], UmbDocumentPickerPropertyEditorValueSummaryElement.prototype, "_name", void 0);
+], UmbDocumentPickerPropertyEditorValueSummaryElement.prototype, "_names", void 0);
 UmbDocumentPickerPropertyEditorValueSummaryElement = __decorate([
     customElement('umb-document-picker-property-editor-value-summary')
 ], UmbDocumentPickerPropertyEditorValueSummaryElement);

package/dist-cms/packages/documents/documents/property-editors/document-picker/value-summary/value-summary.resolver.d.ts

@@ -1,7 +1,15 @@
 import type { UmbDocumentItemModel } from '../../../item/repository/types.js';
 import type { UmbValueSummaryResolveResult, UmbValueSummaryResolver } from '../../../../../core/value-summary/index.js';
 import { UmbControllerBase } from '../../../../../../libs/class-api/index.js';
-export declare class UmbDocumentPickerValueSummaryResolver extends UmbControllerBase implements UmbValueSummaryResolver<string | undefined, Array<UmbDocumentItemModel>> {
+/**
+ * The value of a document picker property: a comma-separated string of document uniques for a picker holding one
+ * document, or an array of document uniques for a picker holding several.
+ */
+export type UmbDocumentPickerValueSummaryValue = string | Array<string> | undefined;
+/**
+ * Batch-resolves document picker values to the picked documents' item models, whichever shape the value takes.
+ */
+export declare class UmbDocumentPickerValueSummaryResolver extends UmbControllerBase implements UmbValueSummaryResolver<UmbDocumentPickerValueSummaryValue, Array<UmbDocumentItemModel>> {
     #private;
-    resolveValues(values: ReadonlyArray<string | undefined>): Promise<UmbValueSummaryResolveResult<Array<UmbDocumentItemModel>>>;
+    resolveValues(values: ReadonlyArray<UmbDocumentPickerValueSummaryValue>): Promise<UmbValueSummaryResolveResult<Array<UmbDocumentItemModel>>>;
 }

package/dist-cms/packages/documents/documents/property-editors/document-picker/value-summary/value-summary.resolver.js

@@ -2,10 +2,13 @@ import { UmbDocumentItemRepository } from '../../../item/repository/index.js';
 import { UmbControllerBase } from '../../../../../../libs/class-api/index.js';
 import { createObservablePart } from '../../../../../../libs/observable-api/index.js';
 import { splitStringToArray } from '../../../../../core/utils/index.js';
+/**
+ * Batch-resolves document picker values to the picked documents' item models, whichever shape the value takes.
+ */
 export class UmbDocumentPickerValueSummaryResolver extends UmbControllerBase {
     #repo = new UmbDocumentItemRepository(this);
     async resolveValues(values) {
-        const allKeys = [...new Set(values.flatMap((v) => splitStringToArray(v)))];
+        const allKeys = [...new Set(values.flatMap((v) => this.#toKeys(v)))];
         if (!allKeys.length)
             return { data: values.map(() => []) };
         const { data, asObservable } = await this.#repo.requestItems(allKeys);
@@ -17,9 +20,12 @@ export class UmbDocumentPickerValueSummaryResolver extends UmbControllerBase {
                 : undefined,
         };
     }
+    #toKeys(value) {
+        return Array.isArray(value) ? value : splitStringToArray(value);
+    }
     #map(values, items) {
         const itemByKey = new Map(items.map((item) => [item.unique, item]));
-        return values.map((v) => splitStringToArray(v)
+        return values.map((v) => this.#toKeys(v)
             .map((key) => itemByKey.get(key))
             .filter((item) => !!item));
     }

package/dist-cms/packages/documents/documents/property-editors/manifests.js

@@ -1,3 +1,8 @@
 import { manifests as documentPickerManifests } from './document-picker/manifests.js';
+import { manifests as multipleDocumentPickerManifests } from './multiple-document-picker/manifests.js';
 import { manifests as documentStartNodeAccessManifests } from './document-start-node-access/manifests.js';
-export const manifests = [...documentPickerManifests, ...documentStartNodeAccessManifests];
+export const manifests = [
+    ...documentPickerManifests,
+    ...multipleDocumentPickerManifests,
+    ...documentStartNodeAccessManifests,
+];

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/Umbraco.DocumentPicker.Multiple.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestPropertyEditorSchema } from '../../../../core/property-editor/index.js';
+export declare const manifest: ManifestPropertyEditorSchema;

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/Umbraco.DocumentPicker.Multiple.js

@@ -0,0 +1,19 @@
+export const manifest = {
+    type: 'propertyEditorSchema',
+    name: 'Multiple Document Picker',
+    alias: 'Umbraco.DocumentPicker.Multiple',
+    meta: {
+        defaultPropertyEditorUiAlias: 'Umb.PropertyEditorUi.DocumentPicker.Multiple',
+        settings: {
+            properties: [
+                {
+                    alias: 'ignoreUserStartNodes',
+                    label: 'Ignore user start nodes',
+                    description: "Selecting this option allows a user to choose nodes that they normally don't have access to.",
+                    propertyEditorUiAlias: 'Umb.PropertyEditorUi.Toggle',
+                    weight: 100,
+                },
+            ],
+        },
+    },
+};

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/manifests.d.ts

@@ -0,0 +1 @@
+export declare const manifests: Array<UmbExtensionManifest>;

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/manifests.js

@@ -0,0 +1,65 @@
+import { UMB_DOCUMENT_DYNAMIC_ROOT_PROPERTY_EDITOR_UI_ALIAS } from '../../dynamic-root/constants.js';
+import { manifest as schemaManifest } from './Umbraco.DocumentPicker.Multiple.js';
+export const manifests = [
+    {
+        type: 'propertyEditorUi',
+        alias: 'Umb.PropertyEditorUi.DocumentPicker.Multiple',
+        name: 'Multiple Document Picker Property Editor UI',
+        element: () => import('./property-editor-ui-multiple-document-picker.element.js'),
+        meta: {
+            label: 'Document Picker',
+            propertyEditorSchemaAlias: 'Umbraco.DocumentPicker.Multiple',
+            icon: 'icon-documents',
+            group: '#propertyEditorUIGroups_pickers',
+            keywords: [
+                'select',
+                'page',
+                'link',
+                'reference',
+                'related',
+                'document',
+                'target',
+                'destination',
+                'multiple',
+                'several',
+            ],
+            supportsReadOnly: true,
+            settings: {
+                properties: [
+                    {
+                        alias: 'allowedContentTypes',
+                        label: 'Accepted types',
+                        description: 'Limit to specific types',
+                        propertyEditorUiAlias: 'Umb.PropertyEditorUi.DocumentTypePicker',
+                        config: [{ alias: 'onlyPickDocumentTypes', value: true }],
+                        weight: 10,
+                    },
+                    {
+                        alias: 'validationLimit',
+                        label: 'Amount',
+                        description: '{#validation_minimumOnlyWhenInUse}',
+                        propertyEditorUiAlias: 'Umb.PropertyEditorUi.NumberRange',
+                        config: [{ alias: 'validationRange', value: { min: 0, max: Infinity } }],
+                        weight: 20,
+                    },
+                    {
+                        alias: 'startNodeId',
+                        label: 'Start node',
+                        description: '',
+                        propertyEditorUiAlias: 'Umb.PropertyEditorUi.DocumentPicker',
+                        config: [{ alias: 'validationLimit', value: { min: 0, max: 1 } }],
+                        weight: 30,
+                    },
+                    {
+                        alias: 'dynamicRoot',
+                        label: 'Dynamic root',
+                        description: 'Resolve the start node from the content being edited, when no start node is set',
+                        propertyEditorUiAlias: UMB_DOCUMENT_DYNAMIC_ROOT_PROPERTY_EDITOR_UI_ALIAS,
+                        weight: 40,
+                    },
+                ],
+            },
+        },
+    },
+    schemaManifest,
+];

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/property-editor-ui-multiple-document-picker.element.d.ts

@@ -0,0 +1,35 @@
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import type { UmbPropertyEditorConfigCollection, UmbPropertyEditorUiElement } from '../../../../core/property-editor/index.js';
+import '../../components/input-document/input-document.element.js';
+declare const UmbMultipleDocumentPickerPropertyEditorUIElement_base: import("../../../../../libs/extension-api/index.js").HTMLElementConstructor<import("../../../../core/validation/index.js").UmbFormControlMixinElement<string[] | undefined>> & typeof UmbLitElement;
+/**
+ * @element umb-property-editor-ui-multiple-document-picker
+ */
+export declare class UmbMultipleDocumentPickerPropertyEditorUIElement extends UmbMultipleDocumentPickerPropertyEditorUIElement_base implements UmbPropertyEditorUiElement {
+    #private;
+    set config(config: UmbPropertyEditorConfigCollection | undefined);
+    /**
+     * Sets the input to readonly mode, meaning value cannot be changed but still able to read and select its content.
+     * @type {boolean}
+     * @attr
+     * @default false
+     */
+    readonly: boolean;
+    mandatory: boolean;
+    mandatoryMessage: string;
+    private _min;
+    private _max;
+    private _startNodeId?;
+    private _allowedContentTypes?;
+    private _interactionMemories;
+    constructor();
+    firstUpdated(): Promise<void>;
+    focus(): void | undefined;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export { UmbMultipleDocumentPickerPropertyEditorUIElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-property-editor-ui-multiple-document-picker': UmbMultipleDocumentPickerPropertyEditorUIElement;
+    }
+}

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/property-editor-ui-multiple-document-picker.element.js

@@ -0,0 +1,133 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { UMB_DOCUMENT_ENTITY_TYPE } from '../../entity.js';
+import { UmbDocumentDynamicRootResolver } from '../../dynamic-root/document-dynamic-root-resolver.controller.js';
+import { customElement, html, property, state } from '../../../../../external/lit/index.js';
+import { UmbChangeEvent } from '../../../../core/event/index.js';
+import { UmbLitElement } from '../../../../core/lit-element/index.js';
+import { UmbPropertyEditorUiInteractionMemoryManager } from '../../../../core/property-editor/index.js';
+import { UMB_VALIDATION_EMPTY_LOCALIZATION_KEY, UmbFormControlMixin } from '../../../../core/validation/index.js';
+import '../../components/input-document/input-document.element.js';
+/**
+ * @element umb-property-editor-ui-multiple-document-picker
+ */
+let UmbMultipleDocumentPickerPropertyEditorUIElement = class UmbMultipleDocumentPickerPropertyEditorUIElement extends UmbFormControlMixin(UmbLitElement) {
+    set config(config) {
+        this.#interactionMemoryManager.setPropertyEditorConfig(config);
+        if (!config)
+            return;
+        const minMax = config.getValueByAlias('validationLimit');
+        this._min = minMax?.min ?? 0;
+        this._max = minMax?.max ?? Infinity;
+        this._startNodeId = config.getValueByAlias('startNodeId');
+        this.#dynamicRoot = config.getValueByAlias('dynamicRoot');
+        const allowedContentTypes = config.getValueByAlias('allowedContentTypes');
+        this._allowedContentTypes = allowedContentTypes ? allowedContentTypes.split(',').filter(Boolean) : undefined;
+    }
+    #dynamicRoot;
+    #dynamicRootResolver;
+    #interactionMemoryManager;
+    constructor() {
+        super();
+        /**
+         * Sets the input to readonly mode, meaning value cannot be changed but still able to read and select its content.
+         * @type {boolean}
+         * @attr
+         * @default false
+         */
+        this.readonly = false;
+        this.mandatory = false;
+        this.mandatoryMessage = UMB_VALIDATION_EMPTY_LOCALIZATION_KEY;
+        this._min = 0;
+        this._max = Infinity;
+        this.#dynamicRootResolver = new UmbDocumentDynamicRootResolver(this);
+        this._interactionMemories = [];
+        this.#interactionMemoryManager = new UmbPropertyEditorUiInteractionMemoryManager(this, {
+            memoryUniquePrefix: 'UmbMultipleDocumentPicker',
+        });
+        this.observe(this.#interactionMemoryManager.memoriesForPropertyEditor, (interactionMemories) => {
+            this._interactionMemories = interactionMemories ?? [];
+        }, null);
+    }
+    async firstUpdated() {
+        this.addFormControlElement(this.shadowRoot.querySelector('umb-input-document'));
+        // A fixed start node wins; the dynamic root is only resolved when there is none.
+        if (!this._startNodeId) {
+            this._startNodeId = await this.#dynamicRootResolver.resolveStartNodeUnique(this.#dynamicRoot);
+        }
+        if (this._min && this._max && this._min > this._max) {
+            console.warn(`Property (Multiple Document Picker) has been misconfigured, 'min' is greater than 'max'. Please correct your data type configuration.`, this);
+        }
+    }
+    focus() {
+        return this.shadowRoot?.querySelector('umb-input-document')?.focus();
+    }
+    #onChange(event) {
+        const selection = event.target.selection;
+        this.value = selection.length > 0 ? selection : undefined;
+        this.dispatchEvent(new UmbChangeEvent());
+    }
+    async #onInputInteractionMemoriesChange(event) {
+        const target = event.target;
+        const interactionMemories = target.interactionMemories;
+        if (interactionMemories && interactionMemories.length > 0) {
+            await this.#interactionMemoryManager.saveMemoriesForPropertyEditor(interactionMemories);
+        }
+        else {
+            await this.#interactionMemoryManager.deleteMemoriesForPropertyEditor();
+        }
+    }
+    render() {
+        const startNode = this._startNodeId
+            ? { unique: this._startNodeId, entityType: UMB_DOCUMENT_ENTITY_TYPE }
+            : undefined;
+        return html `
+			<umb-input-document
+				.min=${this._min}
+				.max=${this._max}
+				.startNode=${startNode}
+				.allowedContentTypeIds=${this._allowedContentTypes}
+				.selection=${this.value ?? []}
+				@change=${this.#onChange}
+				?readonly=${this.readonly}
+				?required=${this.mandatory}
+				.requiredMessage=${this.mandatoryMessage}
+				.interactionMemories=${this._interactionMemories}
+				@interaction-memories-change=${this.#onInputInteractionMemoriesChange}>
+			</umb-input-document>
+		`;
+    }
+};
+__decorate([
+    property({ type: Boolean, reflect: true })
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "readonly", void 0);
+__decorate([
+    property({ type: Boolean })
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "mandatory", void 0);
+__decorate([
+    property({ type: String })
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "mandatoryMessage", void 0);
+__decorate([
+    state()
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "_min", void 0);
+__decorate([
+    state()
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "_max", void 0);
+__decorate([
+    state()
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "_startNodeId", void 0);
+__decorate([
+    state()
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "_allowedContentTypes", void 0);
+__decorate([
+    state()
+], UmbMultipleDocumentPickerPropertyEditorUIElement.prototype, "_interactionMemories", void 0);
+UmbMultipleDocumentPickerPropertyEditorUIElement = __decorate([
+    customElement('umb-property-editor-ui-multiple-document-picker')
+], UmbMultipleDocumentPickerPropertyEditorUIElement);
+export { UmbMultipleDocumentPickerPropertyEditorUIElement };
+export { UmbMultipleDocumentPickerPropertyEditorUIElement as element };

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/value-type/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const UMB_MULTIPLE_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE: "Umbraco.DocumentPicker.Multiple";
+declare global {
+    interface UmbValueTypeMap {
+        [UMB_MULTIPLE_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE]: Array<string>;
+    }
+}

package/dist-cms/packages/documents/documents/property-editors/multiple-document-picker/value-type/constants.js

@@ -0,0 +1 @@
+export const UMB_MULTIPLE_DOCUMENT_PICKER_PROPERTY_EDITOR_VALUE_TYPE = 'Umbraco.DocumentPicker.Multiple';

package/dist-cms/packages/documents/documents/publishing/constants.d.ts

@@ -1,6 +1,4 @@
 export * from './publish-with-descendants/constants.js';
-export * from './publish/constants.js';
 export * from './repository/constants.js';
 export * from './schedule-publish/constants.js';
-export * from './unpublish/constants.js';
 export * from './workspace-context/constants.js';

package/dist-cms/packages/documents/documents/publishing/constants.js

@@ -1,6 +1,4 @@
 export * from './publish-with-descendants/constants.js';
-export * from './publish/constants.js';
 export * from './repository/constants.js';
 export * from './schedule-publish/constants.js';
-export * from './unpublish/constants.js';
 export * from './workspace-context/constants.js';