@umbraco-cms/backoffice 18.2.1 → 18.3.0-rc

package/dist-cms/packages/documents/documents/modals/document-picker-modal/document-picker-modal.element.js

@@ -0,0 +1,511 @@
+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_COLLECTION_ALIAS } from '../../collection/constants.js';
+import { UMB_CONTENT_SECTION_ALIAS, UmbContentCollectionConfigurationContext } from '../../../../content/content/index.js';
+import { UMB_CURRENT_USER_CONTEXT } from '../../../../user/current-user/index.js';
+import { css, customElement, html, ifDefined, keyed, nothing, query, state, } from '../../../../../external/lit/index.js';
+import { UmbDeselectedEvent, UmbSelectedEvent } from '../../../../core/event/index.js';
+import { UmbEntityContext } from '../../../../core/entity/index.js';
+import { UmbPickerModalBaseElement } from '../../../../core/picker/index.js';
+import { UmbTreeItemOpenEvent, UmbTreeItemPickerContext } from '../../../../core/tree/index.js';
+const TREE_MEMORY_UNIQUE = 'UmbTreeItemPickerTree';
+const COLLECTION_MEMORY_UNIQUE = 'UmbItemPickerCollection';
+const ROOT_MEMORY_KEY = 'root';
+/**
+ * A picker that browses documents, rendering the document collection at any level whose node has one configured
+ * (and the user has Content-section access) and the tree everywhere else.
+ * @element umb-document-picker-modal
+ */
+let UmbDocumentPickerModalElement = class UmbDocumentPickerModalElement extends UmbPickerModalBaseElement {
+    /**
+     * Answers `UMB_ENTITY_CONTEXT` for the node being browsed. Without it the collection would bind to the entity of
+     * whichever element opened the modal, because a modal re-dispatches unanswered context requests onto its opener.
+     */
+    #entityContext;
+    #collectionConfiguration;
+    #collectionMemories;
+    constructor() {
+        super();
+        this._selectionConfiguration = {
+            multiple: false,
+            selectable: true,
+            selection: [],
+        };
+        this._collectionSelectionConfiguration = {
+            multiple: false,
+            selectable: true,
+            selectOnly: true,
+            selection: [],
+        };
+        this._hasSelection = false;
+        this._selectionCount = 0;
+        this._isSearchable = false;
+        this._activeTab = 'browse';
+        this._treeExpansion = [];
+        this._hasCollection = false;
+        this._hasContentSectionAccess = false;
+        /**
+         * Answers `UMB_ENTITY_CONTEXT` for the node being browsed. Without it the collection would bind to the entity of
+         * whichever element opened the modal, because a modal re-dispatches unanswered context requests onto its opener.
+         */
+        this.#entityContext = new UmbEntityContext(this);
+        this.#collectionConfiguration = new UmbContentCollectionConfigurationContext(this);
+        this.#collectionMemories = [];
+        this._pickerContext = new UmbTreeItemPickerContext(this);
+        this.#onItemOpen = async (event) => {
+            event.stopPropagation();
+            const { unique, entityType } = event;
+            await this._pickerContext.location.navigateTo({ unique, entityType });
+        };
+        this.#searchSelectableFilter = () => true;
+        // Which collection this picker renders follows from it being a document picker, so it is not a caller's choice.
+        this.#collectionConfiguration.setCollectionAlias(UMB_DOCUMENT_COLLECTION_ALIAS);
+        this._pickerContext.selection.setSelectable(true);
+        this.observe(this._pickerContext.selection.hasSelection, (hasSelection) => {
+            this._hasSelection = hasSelection;
+        }, null);
+        this.#observePickerSelection();
+        this.#observeSearch();
+        this.#observeExpansion();
+        this.#observeTreeInteractionMemories();
+        this.#observeCollectionInteractionMemories();
+        this.#observeCollectionConfiguration();
+        this.#observeContentSectionAccess();
+        this.#observeLocation();
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.addEventListener(UmbTreeItemOpenEvent.TYPE, this.#onItemOpen);
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.removeEventListener(UmbTreeItemOpenEvent.TYPE, this.#onItemOpen);
+    }
+    willUpdate(_changedProperties) {
+        super.willUpdate(_changedProperties);
+        // The single point where a location is turned into a rendering decision. Everything that browses — a tree item
+        // opening, a collection item drilling in, a breadcrumb click, a restore from memory — moves `_currentLocation`
+        // and nothing else, so the renderer, the entity context and the configuration cannot drift apart.
+        if (_changedProperties.has('_currentLocation')) {
+            this.#resolveLocation();
+        }
+    }
+    async updated(_changedProperties) {
+        super.updated(_changedProperties);
+        if (_changedProperties.has('data')) {
+            if (this.data?.search) {
+                this._pickerContext.search.updateConfig({
+                    ...this.data.search,
+                    searchFrom: this.data.startNode,
+                    dataTypeUnique: this._pickerContext.dataType?.unique,
+                });
+            }
+            const multiple = this.data?.multiple ?? false;
+            this._pickerContext.selection.setMultiple(multiple);
+            this._selectionConfiguration = {
+                ...this._selectionConfiguration,
+                multiple,
+            };
+            this._collectionSelectionConfiguration = {
+                ...this._collectionSelectionConfiguration,
+                multiple,
+                selectableFilter: this.data?.pickableFilter,
+            };
+            if (this.data?.treeAlias && this.data.treeAlias !== this._treeAlias) {
+                this._treeAlias = this.data.treeAlias;
+                this._pickerContext.location.setStartNode(this.data.startNode);
+                this._pickerContext.location.setTreeAlias(this.data.treeAlias);
+            }
+            if (this.data?.treeExpansion !== undefined) {
+                this._pickerContext.expansion.setExpansion(this.data.treeExpansion);
+            }
+        }
+        if (_changedProperties.has('value')) {
+            const selection = this.value?.selection ?? [];
+            this._pickerContext.selection.setSelection(selection);
+            this._selectionConfiguration = {
+                ...this._selectionConfiguration,
+                selection: [...selection],
+            };
+            this._collectionSelectionConfiguration = {
+                ...this._collectionSelectionConfiguration,
+                selection: [...selection].filter((unique) => unique !== null),
+            };
+        }
+    }
+    #onItemOpen;
+    #getCollectionUnique(location) {
+        return location?.contentType?.collection
+            ?.unique;
+    }
+    /**
+     * Points the entity context and the collection configuration at the node being browsed, and picks up that node's
+     * remembered collection state. The root renders the tree, as it has no content type and therefore no collection.
+     */
+    #resolveLocation() {
+        const location = this._currentLocation;
+        this.#entityContext.setEntityType(location?.entityType);
+        this.#entityContext.setUnique(location?.unique ?? null);
+        this.#collectionConfiguration.setUnique(location?.unique ?? null);
+        this.#collectionConfiguration.setDataTypeUnique(this.#getCollectionUnique(location));
+        this.#updateCollectionInteractionMemories();
+    }
+    #observeLocation() {
+        this.observe(this._pickerContext.location.currentLocation, (location) => {
+            this._currentLocation = location;
+            this._treeStartNode = location?.unique
+                ? { unique: location.unique, entityType: location.entityType }
+                : undefined;
+        }, 'umbContentPickerLocationObserver');
+    }
+    #observePickerSelection() {
+        this.observe(this._pickerContext.selection.selection, (selection) => {
+            this._selectionCount = selection.length;
+            this.updateValue({ selection });
+            this.requestUpdate();
+        }, 'umbPickerSelectionObserver');
+    }
+    #observeSearch() {
+        this.observe(this._pickerContext.search.searchable, (isSearchable) => {
+            this._isSearchable = isSearchable ?? false;
+        }, 'umbPickerSearchableObserver');
+    }
+    #observeExpansion() {
+        this.observe(this._pickerContext.expansion.expansion, (value) => {
+            this._treeExpansion = value;
+        }, 'umbTreeItemPickerExpansionObserver');
+    }
+    #observeTreeInteractionMemories() {
+        this.observe(this._pickerContext.interactionMemory.memory(TREE_MEMORY_UNIQUE), (memory) => {
+            this._treeInteractionMemories = memory?.memories;
+        }, 'umbTreePickerInteractionMemoriesObserver');
+    }
+    #observeCollectionInteractionMemories() {
+        this.observe(this._pickerContext.interactionMemory.memory(COLLECTION_MEMORY_UNIQUE), (memory) => {
+            this.#collectionMemories = memory?.memories ?? [];
+            this.#updateCollectionInteractionMemories();
+        }, 'umbContentPickerCollectionInteractionMemoriesObserver');
+    }
+    #observeCollectionConfiguration() {
+        this.observe(this.#collectionConfiguration.hasCollection, (hasCollection) => {
+            this._hasCollection = hasCollection;
+        }, null);
+        this.observe(this.#collectionConfiguration.collectionConfig, (collectionConfig) => {
+            this._collectionConfig = collectionConfig;
+        }, null);
+    }
+    /** The Collection endpoint requires Content-section access; the Tree endpoint accepts any section. */
+    #observeContentSectionAccess() {
+        this.consumeContext(UMB_CURRENT_USER_CONTEXT, (context) => {
+            this.observe(context?.allowedSections, (allowedSections) => {
+                this._hasContentSectionAccess = allowedSections?.includes(UMB_CONTENT_SECTION_ALIAS) ?? false;
+            }, 'umbDocumentPickerContentSectionAccessObserver');
+        });
+    }
+    /**
+     * Collection memories are nested per browsed node, so returning to a node restores the view, filter, ordering and
+     * page it was left in while a sibling starts clean. An ordering column configured on one content type need not
+     * exist on another.
+     * @returns {string} The memory key of the node being browsed.
+     */
+    #getCollectionMemoryKey() {
+        return this._currentLocation?.unique ?? ROOT_MEMORY_KEY;
+    }
+    #updateCollectionInteractionMemories() {
+        const key = this.#getCollectionMemoryKey();
+        this._collectionInteractionMemories = this.#collectionMemories.find((memory) => memory.unique === key)?.memories;
+    }
+    #onCollectionInteractionMemoriesChange(event) {
+        event.stopPropagation();
+        const collection = event.currentTarget;
+        const memories = collection.getInteractionMemories();
+        const key = this.#getCollectionMemoryKey();
+        const others = this.#collectionMemories.filter((memory) => memory.unique !== key);
+        const next = memories.length ? [...others, { unique: key, memories }] : others;
+        if (next.length) {
+            this._pickerContext.interactionMemory.setMemory({ unique: COLLECTION_MEMORY_UNIQUE, memories: next });
+        }
+        else {
+            this._pickerContext.interactionMemory.deleteMemory(COLLECTION_MEMORY_UNIQUE);
+        }
+    }
+    #onItemSelected(event) {
+        event.stopPropagation();
+        this._pickerContext.selection.select(event.unique);
+        this.modalContext?.dispatchEvent(new UmbSelectedEvent(event.unique));
+    }
+    #onItemDeselected(event) {
+        event.stopPropagation();
+        this._pickerContext.selection.deselect(event.unique);
+        this.modalContext?.dispatchEvent(new UmbDeselectedEvent(event.unique));
+    }
+    #onTreeItemExpansionChange(event) {
+        const target = event.target;
+        const expansion = target.getExpansion();
+        this._pickerContext.expansion.setExpansion(expansion);
+    }
+    #onTreeInteractionMemoriesChange(event) {
+        event.stopPropagation();
+        const tree = event.currentTarget;
+        const memories = tree.interactionMemories;
+        if (memories.length > 0) {
+            this._pickerContext.interactionMemory.setMemory({ unique: TREE_MEMORY_UNIQUE, memories });
+        }
+        else {
+            this._pickerContext.interactionMemory.deleteMemory(TREE_MEMORY_UNIQUE);
+        }
+    }
+    #searchSelectableFilter;
+    async #setActiveTab(tab) {
+        if (this._activeTab === tab)
+            return;
+        this._activeTab = tab;
+        if (tab === 'search') {
+            await this.updateComplete;
+            this._searchField?.focus();
+        }
+    }
+    /** Whether the collection is actually being rendered for the browsed node, rather than merely configured for it. */
+    #willRenderCollection() {
+        return this._hasCollection && this._hasContentSectionAccess;
+    }
+    render() {
+        return html `
+			<umb-body-layout
+				headline=${this.localize.string(this.data?.headline ?? '#general_choose')}
+				?main-no-padding=${this.#willRenderCollection()}>
+				${this.#renderTabs()}
+				<div id="browse" ?hidden=${this._activeTab !== 'browse'}>${this.#renderBrowse()}</div>
+				<div id="search" ?hidden=${this._activeTab !== 'search'}>${this.#renderSearch()}</div>
+				${this.#renderSelectionCount()} ${this.#renderActions()}
+			</umb-body-layout>
+		`;
+    }
+    #renderTabs() {
+        if (!this._isSearchable)
+            return nothing;
+        return html `
+			<uui-tab-group slot="navigation">
+				${this.#renderTab('browse', 'picker_browseTab', 'icon-list')}
+				${this.#renderTab('search', 'picker_searchTab', 'icon-search')}
+			</uui-tab-group>
+		`;
+    }
+    // The label is passed as both property and child text: `uui-tab` renders its `label` in the default
+    // slot, which the whitespace of a multi-line template would otherwise occupy.
+    #renderTab(tab, labelKey, icon) {
+        const label = this.localize.term(labelKey);
+        return html `<uui-tab
+			label=${label}
+			?active=${this._activeTab === tab}
+			@click=${() => this.#setActiveTab(tab)}
+			data-mark="picker:tab:${tab}">
+			<umb-icon slot="icon" name=${icon}></umb-icon>
+			${label}
+		</uui-tab>`;
+    }
+    #renderSearch() {
+        if (!this._isSearchable)
+            return nothing;
+        const selectableFilter = this.data?.search?.pickableFilter ?? this.data?.pickableFilter ?? this.#searchSelectableFilter;
+        return html `
+			<umb-picker-search-field .alias=${this._treeAlias}></umb-picker-search-field>
+			<umb-picker-search-result .pickableFilter=${selectableFilter}></umb-picker-search-result>
+		`;
+    }
+    #renderBrowse() {
+        return html `${this.#renderBreadcrumb()} ${this.#renderChildren()}`;
+    }
+    #renderChildren() {
+        // Which renderer a level needs is only known once the location is, and mounting the tree in the meantime would
+        // tear it down again mid-initialisation.
+        if (this._currentLocation === undefined)
+            return html `<umb-view-loader></umb-view-loader>`;
+        // A level the tree cannot describe has no renderer, so neither the tree nor the collection stands in for it.
+        if (this._currentLocation === null)
+            return this.#renderNotFound();
+        if (!this.#willRenderCollection())
+            return this.#renderTree();
+        // The configuration is resolved from a data type, so the collection is held back rather than briefly showing
+        // the tree in its place.
+        return this._collectionConfig ? this.#renderCollection() : html `<umb-view-loader></umb-view-loader>`;
+    }
+    #renderNotFound() {
+        return html `<div id="not-found" class="uui-text">
+			<h4>${this.localize.term('general_notFound')}</h4>
+		</div>`;
+    }
+    #renderTree() {
+        return html `
+			<umb-tree
+				alias=${ifDefined(this.data?.treeAlias)}
+				.props=${{
+            showToolbar: true,
+            drillable: true,
+            hideTreeItemActions: true,
+            hideTreeRoot: this.data?.hideTreeRoot,
+            expandTreeRoot: this.data?.expandTreeRoot,
+            selectionConfiguration: this._selectionConfiguration,
+            filter: this.data?.filter,
+            selectableFilter: this.data?.pickableFilter,
+            startNode: this._treeStartNode,
+            foldersOnly: this.data?.foldersOnly,
+            expansion: this._treeExpansion,
+            interactionMemories: this._treeInteractionMemories,
+        }}
+				@selected=${this.#onItemSelected}
+				@deselected=${this.#onItemDeselected}
+				@expansion-change=${this.#onTreeItemExpansionChange}
+				@interaction-memories-change=${this.#onTreeInteractionMemoriesChange}></umb-tree>
+		`;
+    }
+    #renderCollection() {
+        const config = {
+            ...this._collectionConfig,
+            selectionConfiguration: this._collectionSelectionConfiguration,
+            bulkActionConfiguration: { enabled: false },
+            hideItemActions: true,
+            hideCollectionActions: true,
+        };
+        // Re-created per browsed node: a collection cannot be retargeted once configured, and a fresh instance also
+        // resets pagination and the per-view registrations.
+        return keyed(this.#getCollectionMemoryKey(), html `<umb-collection
+				alias=${UMB_DOCUMENT_COLLECTION_ALIAS}
+				.config=${config}
+				.interactionMemories=${this._collectionInteractionMemories}
+				@selected=${this.#onItemSelected}
+				@deselected=${this.#onItemDeselected}
+				@interaction-memories-change=${this.#onCollectionInteractionMemoriesChange}></umb-collection>`);
+    }
+    #renderBreadcrumb() {
+        return html `<umb-tree-item-picker-breadcrumb id="breadcrumb"></umb-tree-item-picker-breadcrumb>`;
+    }
+    #renderSelectionCount() {
+        if (!this._selectionConfiguration.multiple || !this._hasSelection)
+            return nothing;
+        return html `
+			<div id="selection-info" slot="footer">${this.localize.term('picker_selectedCount', this._selectionCount)}</div>
+		`;
+    }
+    #renderActions() {
+        return html `
+			<div slot="actions">
+				<uui-button label=${this.localize.term('general_close')} @click=${this._rejectModal}></uui-button>
+				<uui-button
+					label=${this.localize.string(this.data?.confirmLabel ?? '#general_choose')}
+					look="primary"
+					color="positive"
+					@click=${this._submitModal}
+					?disabled=${!this._hasSelection}></uui-button>
+			</div>
+		`;
+    }
+    static { this.styles = css `
+		uui-tab-group {
+			--uui-tab-divider: var(--uui-color-border);
+			border-left: 1px solid var(--uui-color-border);
+			border-right: 1px solid var(--uui-color-border);
+		}
+
+		umb-body-layout[main-no-padding] #search {
+			padding: var(--uui-size-layout-1);
+		}
+
+		#breadcrumb {
+			margin-bottom: var(--uui-size-space-4);
+		}
+
+		#not-found {
+			text-align: center;
+			padding: var(--uui-size-layout-1);
+		}
+
+		/* A collection lays itself out inside its own body layout, so the main padding is dropped for it and only the
+		   breadcrumb above it is inset — padding the whole panel would inset the collection twice. */
+		umb-body-layout[main-no-padding] #breadcrumb {
+			padding: var(--uui-size-layout-1) var(--uui-size-layout-1) 0;
+			margin-bottom: 0;
+		}
+
+		uui-breadcrumbs {
+			overflow: hidden;
+			min-width: 0;
+		}
+
+		uui-breadcrumb-item:not([last-item]) {
+			cursor: pointer;
+		}
+
+		umb-collection {
+			display: block;
+			height: fit-content;
+		}
+
+		#selection-info {
+			display: flex;
+			align-items: center;
+			box-sizing: border-box;
+			width: 100%;
+			padding: var(--uui-size-space-4) var(--uui-size-space-6);
+			background-color: var(--uui-color-selected);
+			color: var(--uui-color-selected-contrast);
+		}
+	`; }
+};
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_selectionConfiguration", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_collectionSelectionConfiguration", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_hasSelection", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_selectionCount", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_isSearchable", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_activeTab", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_treeExpansion", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_treeInteractionMemories", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_collectionInteractionMemories", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_currentLocation", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_treeStartNode", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_hasCollection", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_collectionConfig", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_hasContentSectionAccess", void 0);
+__decorate([
+    query('umb-picker-search-field')
+], UmbDocumentPickerModalElement.prototype, "_searchField", void 0);
+__decorate([
+    state()
+], UmbDocumentPickerModalElement.prototype, "_treeAlias", void 0);
+UmbDocumentPickerModalElement = __decorate([
+    customElement('umb-document-picker-modal')
+], UmbDocumentPickerModalElement);
+export { UmbDocumentPickerModalElement };
+export default UmbDocumentPickerModalElement;

package/dist-cms/packages/documents/documents/modals/document-picker-modal/document-picker-modal.token.d.ts

@@ -0,0 +1,7 @@
+import type { UmbDocumentPickerModalData, UmbDocumentPickerModalValue } from './types.js';
+import { UmbModalToken } from '../../../../core/modal/index.js';
+/**
+ * Picks documents, browsing the document tree and rendering the document collection at any level whose document type
+ * has one configured.
+ */
+export declare const UMB_DOCUMENT_PICKER_MODAL: UmbModalToken<UmbDocumentPickerModalData, UmbDocumentPickerModalValue>;

package/dist-cms/packages/documents/documents/modals/document-picker-modal/document-picker-modal.token.js

@@ -0,0 +1,20 @@
+import { UMB_DOCUMENT_SEARCH_PROVIDER_ALIAS } from '../../search/index.js';
+import { UMB_DOCUMENT_TREE_ALIAS } from '../../tree/constants.js';
+import { UMB_DOCUMENT_PICKER_MODAL_ALIAS } from './constants.js';
+import { UmbModalToken } from '../../../../core/modal/index.js';
+/**
+ * Picks documents, browsing the document tree and rendering the document collection at any level whose document type
+ * has one configured.
+ */
+export const UMB_DOCUMENT_PICKER_MODAL = new UmbModalToken(UMB_DOCUMENT_PICKER_MODAL_ALIAS, {
+    modal: {
+        type: 'sidebar',
+        size: 'medium',
+    },
+    data: {
+        treeAlias: UMB_DOCUMENT_TREE_ALIAS,
+        search: {
+            providerAlias: UMB_DOCUMENT_SEARCH_PROVIDER_ALIAS,
+        },
+    },
+});

package/dist-cms/packages/documents/documents/modals/document-picker-modal/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './document-picker-modal.token.js';
+export type * from './types.js';

package/dist-cms/packages/documents/documents/modals/document-picker-modal/index.js

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export * from './document-picker-modal.token.js';

package/dist-cms/packages/documents/documents/modals/document-picker-modal/manifests.d.ts

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

package/dist-cms/packages/documents/documents/modals/document-picker-modal/manifests.js

@@ -0,0 +1,9 @@
+import { UMB_DOCUMENT_PICKER_MODAL_ALIAS } from './constants.js';
+export const manifests = [
+    {
+        type: 'modal',
+        alias: UMB_DOCUMENT_PICKER_MODAL_ALIAS,
+        name: 'Document Picker Modal',
+        element: () => import('./document-picker-modal.element.js'),
+    },
+];

package/dist-cms/packages/documents/documents/modals/document-picker-modal/types.d.ts

@@ -0,0 +1,6 @@
+import type { UmbDocumentTreeItemModel } from '../../tree/types.js';
+import type { UmbTreePickerModalData, UmbTreePickerModalValue } from '../../../../core/tree/index.js';
+export interface UmbDocumentPickerModalData extends UmbTreePickerModalData<UmbDocumentTreeItemModel> {
+}
+export interface UmbDocumentPickerModalValue extends UmbTreePickerModalValue {
+}

package/dist-cms/packages/documents/documents/modals/document-picker-modal/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,2 +1,3 @@
+import { manifests as documentPickerModalManifests } from './document-picker-modal/manifests.js';
 import { manifest as saveModalManifest } from './save-modal/manifest.js';
-export const manifests = [saveModalManifest];
+export const manifests = [saveModalManifest, ...documentPickerModalManifests];

package/dist-cms/packages/documents/documents/modals/types.d.ts

@@ -3,4 +3,4 @@ import type { UmbContentVariantPickerData, UmbContentVariantPickerValue } from '
 export type UmbDocumentVariantPickerData = UmbContentVariantPickerData<UmbDocumentVariantOptionModel>;
 export type UmbDocumentVariantPickerValue = UmbContentVariantPickerValue;
 export type * from './save-modal/constants.js';
-export type * from './document-picker-modal.token.js';
+export type * from './document-picker-modal/types.js';

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

@@ -7,6 +7,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',
             propertyEditorSchemaAlias: 'Umbraco.ContentPicker',
             icon: 'icon-document',

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

@@ -0,0 +1,11 @@
+import { UmbStartNodeAccessPropertyEditorUiElementBase } from '../../../../core/property-editor/index.js';
+export declare class UmbDocumentStartNodeAccessPropertyEditorUIElement extends UmbStartNodeAccessPropertyEditorUiElementBase {
+    #private;
+    protected renderPicker(): import("lit-html").TemplateResult<1>;
+}
+export { UmbDocumentStartNodeAccessPropertyEditorUIElement as element };
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-property-editor-ui-document-start-node-access': UmbDocumentStartNodeAccessPropertyEditorUIElement;
+    }
+}

package/dist-cms/packages/documents/documents/property-editors/document-start-node-access/document-start-node-access-property-editor-ui.element.js

@@ -0,0 +1,29 @@
+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 { customElement, html } from '../../../../../external/lit/index.js';
+import { UmbStartNodeAccessPropertyEditorUiElementBase } from '../../../../core/property-editor/index.js';
+let UmbDocumentStartNodeAccessPropertyEditorUIElement = class UmbDocumentStartNodeAccessPropertyEditorUIElement extends UmbStartNodeAccessPropertyEditorUiElementBase {
+    #onChange(event) {
+        this._onPick(event.target.selection);
+    }
+    renderPicker() {
+        return html `
+			<umb-input-document
+				.selection=${this._selection}
+				.min=${this._min}
+				.max=${this._max}
+				?readonly=${this.readonly}
+				@change=${this.#onChange}>
+			</umb-input-document>
+		`;
+    }
+};
+UmbDocumentStartNodeAccessPropertyEditorUIElement = __decorate([
+    customElement('umb-property-editor-ui-document-start-node-access')
+], UmbDocumentStartNodeAccessPropertyEditorUIElement);
+export { UmbDocumentStartNodeAccessPropertyEditorUIElement };
+export { UmbDocumentStartNodeAccessPropertyEditorUIElement as element };

package/dist-cms/packages/documents/documents/property-editors/document-start-node-access/manifests.d.ts

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

package/dist-cms/packages/documents/documents/property-editors/document-start-node-access/manifests.js

@@ -0,0 +1,14 @@
+export const manifests = [
+    {
+        type: 'propertyEditorUi',
+        alias: 'Umb.PropertyEditorUi.DocumentStartNodeAccess',
+        name: 'Document Start Node Access Property Editor UI',
+        element: () => import('./document-start-node-access-property-editor-ui.element.js'),
+        meta: {
+            label: 'Document Start Node Access',
+            icon: 'icon-page',
+            group: '#propertyEditorUIGroups_pickers',
+            supportsReadOnly: true,
+        },
+    },
+];

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

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