@umbraco-cms/backoffice 18.2.1 → 18.3.0-rc

package/dist-cms/packages/documents/document-types/repository/structure/document-type-structure.server.data-source.js

@@ -28,17 +28,19 @@ export class UmbDocumentTypeStructureServerDataSource extends UmbContentTypeStru
         return { data: mappedData };
     }
 }
-const getAllowedChildrenOf = (unique, parentContentUnique) => {
+const getAllowedChildrenOf = (unique, parentContentUnique, paging) => {
     if (unique) {
         // eslint-disable-next-line local-rules/no-direct-api-import
         return DocumentTypeService.getDocumentTypeByIdAllowedChildren({
             path: { id: unique },
-            query: { parentContentKey: parentContentUnique ?? undefined },
+            query: { parentContentKey: parentContentUnique ?? undefined, skip: paging?.skip, take: paging?.take },
         });
     }
     else {
         // eslint-disable-next-line local-rules/no-direct-api-import
-        return DocumentTypeService.getDocumentTypeAllowedAtRoot({});
+        return DocumentTypeService.getDocumentTypeAllowedAtRoot({
+            query: { skip: paging?.skip, take: paging?.take },
+        });
     }
 };
 const mapper = (item) => {

package/dist-cms/packages/documents/document-types/tree/folder/manifests.js

@@ -2,6 +2,9 @@ import { manifests as repositoryManifests } from './repository/manifests.js';
 import { manifests as workspaceManifests } from './workspace/manifests.js';
 import { UMB_DOCUMENT_TYPE_FOLDER_REPOSITORY_ALIAS } from './repository/constants.js';
 import { UMB_DOCUMENT_TYPE_FOLDER_ENTITY_TYPE } from './entity.js';
+import { UMB_DOCUMENT_TYPE_FOLDER_WORKSPACE_ALIAS } from './workspace/constants.js';
+import { UMB_DOCUMENT_TYPE_MENU_ITEM_ALIAS } from '../../menu/constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '../../../../core/workspace/index.js';
 export const manifests = [
     {
         type: 'entityAction',
@@ -23,6 +26,34 @@ export const manifests = [
             folderRepositoryAlias: UMB_DOCUMENT_TYPE_FOLDER_REPOSITORY_ALIAS,
         },
     },
+    {
+        type: 'workspaceContext',
+        kind: 'menuStructure',
+        name: 'Document Type Folder Menu Structure Workspace Context',
+        alias: 'Umb.Context.DocumentTypeFolder.Menu.Structure',
+        api: () => import('../../menu/document-type-menu-structure.context.js'),
+        meta: {
+            menuItemAlias: UMB_DOCUMENT_TYPE_MENU_ITEM_ALIAS,
+        },
+        conditions: [
+            {
+                alias: UMB_WORKSPACE_CONDITION_ALIAS,
+                match: UMB_DOCUMENT_TYPE_FOLDER_WORKSPACE_ALIAS,
+            },
+        ],
+    },
+    {
+        type: 'workspaceFooterApp',
+        kind: 'menuBreadcrumb',
+        alias: 'Umb.WorkspaceFooterApp.DocumentTypeFolder.Breadcrumb',
+        name: 'Document Type Folder Breadcrumb Workspace Footer App',
+        conditions: [
+            {
+                alias: UMB_WORKSPACE_CONDITION_ALIAS,
+                match: UMB_DOCUMENT_TYPE_FOLDER_WORKSPACE_ALIAS,
+            },
+        ],
+    },
     ...repositoryManifests,
     ...workspaceManifests,
 ];

package/dist-cms/packages/documents/document-types/tree/folder/workspace/document-type-folder-workspace.context.d.ts

@@ -1,8 +1,10 @@
 import { type UmbDocumentTypeFolderRepository } from '../repository/index.js';
 import type { UmbControllerHost } from '../../../../../../libs/controller-api/index.js';
 import { UmbEntityNamedDetailWorkspaceContextBase, type UmbRoutableWorkspaceContext, type UmbSubmittableWorkspaceContext } from '../../../../../core/workspace/index.js';
+import type { UmbEntityModel } from '../../../../../core/entity/index.js';
 import type { UmbFolderModel } from '../../../../../core/tree/index.js';
 export declare class UmbDocumentTypeFolderWorkspaceContext extends UmbEntityNamedDetailWorkspaceContextBase<UmbFolderModel, UmbDocumentTypeFolderRepository> implements UmbSubmittableWorkspaceContext, UmbRoutableWorkspaceContext {
     constructor(host: UmbControllerHost);
+    protected _getNavigationParentItemPath(entity: UmbEntityModel | undefined): string | undefined;
 }
 export { UmbDocumentTypeFolderWorkspaceContext as api };

package/dist-cms/packages/documents/document-types/tree/folder/workspace/document-type-folder-workspace.context.js

@@ -1,7 +1,9 @@
 import { UMB_DOCUMENT_TYPE_FOLDER_REPOSITORY_ALIAS, } from '../repository/index.js';
 import { UMB_DOCUMENT_TYPE_FOLDER_ENTITY_TYPE } from '../entity.js';
+import { UMB_EDIT_DOCUMENT_TYPE_FOLDER_WORKSPACE_PATH_PATTERN } from './paths.js';
 import { UMB_DOCUMENT_TYPE_FOLDER_WORKSPACE_ALIAS } from './constants.js';
 import { UmbDocumentTypeFolderWorkspaceEditorElement } from './document-type-folder-editor.element.js';
+import { UMB_DOCUMENT_TYPE_ROOT_WORKSPACE_PATH } from '../../../paths.js';
 import { UmbEntityNamedDetailWorkspaceContextBase, } from '../../../../../core/workspace/index.js';
 export class UmbDocumentTypeFolderWorkspaceContext extends UmbEntityNamedDetailWorkspaceContextBase {
     constructor(host) {
@@ -21,5 +23,10 @@ export class UmbDocumentTypeFolderWorkspaceContext extends UmbEntityNamedDetailW
             },
         ]);
     }
+    _getNavigationParentItemPath(entity) {
+        if (!entity?.unique)
+            return UMB_DOCUMENT_TYPE_ROOT_WORKSPACE_PATH;
+        return UMB_EDIT_DOCUMENT_TYPE_FOLDER_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: entity.unique });
+    }
 }
 export { UmbDocumentTypeFolderWorkspaceContext as api };

package/dist-cms/packages/documents/document-types/tree/tree-item-children/collection/views/manifests.js

@@ -8,7 +8,7 @@ export const manifests = [
         element: () => import('./document-type-tree-item-table-collection-view.element.js'),
         weight: 300,
         meta: {
-            label: 'Table',
+            label: '#collection_tableViewLabel',
             icon: 'icon-table',
             pathName: 'table',
         },

package/dist-cms/packages/documents/document-types/workspace/document-type/document-type-workspace.context.d.ts

@@ -18,6 +18,7 @@ export declare class UmbDocumentTypeWorkspaceContext extends UmbContentTypeWorks
     readonly cleanup: import("rxjs").Observable<import("../../types.js").UmbDocumentTypeCleanupModel | undefined>;
     createTemplateMode: boolean;
     constructor(host: UmbControllerHost);
+    protected _getNavigationParentItemPath(entity: UmbEntityModel | undefined): string | undefined;
     setAllowedAtRoot(allowedAtRoot: boolean): void;
     setAllowedInLibrary(allowedInLibrary: boolean): void;
     setVariesByCulture(variesByCulture: boolean): void;

package/dist-cms/packages/documents/document-types/workspace/document-type/document-type-workspace.context.js

@@ -1,6 +1,8 @@
-import { UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN, UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PRESET_ELEMENT, UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PRESET_TEMPLATE, UMB_EDIT_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN, } from '../../paths.js';
+import { UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN, UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PRESET_ELEMENT, UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PRESET_TEMPLATE, UMB_DOCUMENT_TYPE_ROOT_WORKSPACE_PATH, UMB_EDIT_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN, } from '../../paths.js';
 import { UMB_DOCUMENT_TYPE_ENTITY_TYPE, UMB_DOCUMENT_TYPE_DETAIL_REPOSITORY_ALIAS } from '../../constants.js';
 import { UmbDocumentTypeTemplateRepository } from '../../repository/template/document-type-template.repository.js';
+import { UMB_DOCUMENT_TYPE_FOLDER_ENTITY_TYPE } from '../../tree/folder/entity.js';
+import { UMB_EDIT_DOCUMENT_TYPE_FOLDER_WORKSPACE_PATH_PATTERN } from '../../tree/folder/workspace/paths.js';
 import { UMB_DOCUMENT_TYPE_WORKSPACE_ALIAS } from './constants.js';
 import { UmbDocumentTypeWorkspaceEditorElement } from './document-type-workspace-editor.element.js';
 import { CompositionTypeModel } from '../../../../core/backend-api/index.js';
@@ -54,6 +56,14 @@ export class UmbDocumentTypeWorkspaceContext extends UmbContentTypeWorkspaceCont
             },
         ]);
     }
+    _getNavigationParentItemPath(entity) {
+        if (!entity?.unique)
+            return UMB_DOCUMENT_TYPE_ROOT_WORKSPACE_PATH;
+        if (entity.entityType === UMB_DOCUMENT_TYPE_FOLDER_ENTITY_TYPE) {
+            return UMB_EDIT_DOCUMENT_TYPE_FOLDER_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: entity.unique });
+        }
+        return UMB_EDIT_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: entity.unique });
+    }
     setAllowedAtRoot(allowedAtRoot) {
         this.structure.updateOwnerContentType({ allowedAtRoot });
     }

package/dist-cms/packages/documents/documents/collection/action/create-document-collection-action.element.js

@@ -37,7 +37,7 @@ let UmbCreateDocumentCollectionActionElement = class UmbCreateDocumentCollection
         }
     }
     async #retrieveAllowedDocumentTypesOf(unique, parentContentUnique) {
-        const { data } = await this.#documentTypeStructureRepository.requestAllowedChildrenOf(unique, parentContentUnique);
+        const { data } = await this.#documentTypeStructureRepository.requestAllAllowedChildrenOf(unique, parentContentUnique);
         if (data && data.items) {
             this._allowedDocumentTypes = data.items;
         }

package/dist-cms/packages/documents/documents/collection/item/document-collection-item-card.element.js

@@ -11,6 +11,7 @@ import { getDocumentVariantStateTagConfig } from '../../variant-state/utils.js';
 import { css, customElement, html, ifDefined, nothing, property, repeat, state, when, } from '../../../../../external/lit/index.js';
 import { UmbLitElement } from '../../../../core/lit-element/index.js';
 import { UmbDeselectedEvent, UmbSelectedEvent } from '../../../../core/event/index.js';
+import { UmbTreeItemOpenEvent } from '../../../../core/tree/index.js';
 import { UmbEntityContentTypeEntityContext } from '../../../../content/content-type/index.js';
 import { UMB_DOCUMENT_TYPE_ENTITY_TYPE } from '../../../document-types/index.js';
 import { fromCamelCase } from '../../../../core/utils/index.js';
@@ -65,6 +66,12 @@ let UmbDocumentCollectionItemCardElement = class UmbDocumentCollectionItemCardEl
         event.stopPropagation();
         this.dispatchEvent(new UmbDeselectedEvent(this.item.unique));
     }
+    #onOpen(event) {
+        if (!this.item?.hasChildren)
+            return;
+        event.stopPropagation();
+        this.dispatchEvent(new UmbTreeItemOpenEvent({ unique: this.item.unique, entityType: this.item.entityType }));
+    }
     #getPropertyValueByAlias(alias) {
         if (!this.item)
             return { value: '' };
@@ -95,19 +102,25 @@ let UmbDocumentCollectionItemCardElement = class UmbDocumentCollectionItemCardEl
             }
         }
     }
+    get #selectOnly() {
+        return !this.item?.hasChildren && this.selectOnly;
+    }
     render() {
         if (!this.item)
             return nothing;
+        const href = this.selectOnly ? undefined : this.href;
         return html `
 			<uui-card-content-node
 				.name=${this._name}
-				href=${ifDefined(this.href)}
+				href=${ifDefined(href)}
+				?has-children=${this.item.hasChildren}
 				?selectable=${this.selectable}
-				?select-only=${this.selectOnly}
+				?select-only=${this.#selectOnly}
 				?selected=${this.selected}
 				?disabled=${this.disabled}
 				@selected=${this.#onSelected}
-				@deselected=${this.#onDeselected}>
+				@deselected=${this.#onDeselected}
+				@open=${this.#onOpen}>
 				${this.#renderIcon()} ${this.#renderState()}
 				<div id="properties">${this.#renderProperties()}</div>
 				<slot name="actions" slot="actions"></slot>

package/dist-cms/packages/documents/documents/collection/item/types.d.ts

@@ -2,15 +2,26 @@ import type { UmbDocumentEntityType } from '../../entity.js';
 import type { UmbDocumentItemVariantModel } from '../../types.js';
 import type { UmbEntityModel } from '../../../../core/entity/index.js';
 import type { UmbEntityWithFlags } from '../../../../core/entity-flag/index.js';
+import type { UmbReferenceByUnique } from '../../../../core/models/index.js';
 export interface UmbDocumentCollectionItemModel extends UmbEntityWithFlags {
     ancestors: Array<UmbEntityModel>;
     creator?: string | null;
+    contentType?: {
+        unique: string;
+        icon: string;
+        alias: string;
+        collection: UmbReferenceByUnique | null;
+    };
+    /**
+     * @deprecated Use `contentType` instead. This field will be removed in v20.
+     */
     documentType: {
         unique: string;
         icon: string;
         alias: string;
     };
     entityType: UmbDocumentEntityType;
+    hasChildren: boolean;
     isProtected: boolean;
     isTrashed: boolean;
     sortOrder: number;
@@ -27,5 +38,8 @@ export interface UmbDocumentCollectionItemModel extends UmbEntityWithFlags {
 }
 export interface UmbEditableDocumentCollectionItemModel {
     item: UmbDocumentCollectionItemModel;
-    editPath: string;
+    /** When set, the name becomes an anchor linking to this href. */
+    href?: string;
+    /** When set (and no `href` is provided), the name becomes a button invoking this callback. */
+    onOpen?: () => void;
 }

package/dist-cms/packages/documents/documents/collection/repository/document-collection.server.data-source.js

@@ -22,6 +22,12 @@ export class UmbDocumentCollectionServerDataSource {
         const { data, error } = await tryExecute(this.#host, DocumentService.getCollectionDocumentById({ path: { id: filter.unique }, query }));
         if (data) {
             const items = data.items.map((item) => {
+                const contentType = {
+                    unique: item.documentType.id,
+                    icon: item.documentType.icon,
+                    alias: item.documentType.alias,
+                    collection: item.documentType.collection ? { unique: item.documentType.collection.id } : null,
+                };
                 const model = {
                     ancestors: item.ancestors.map((ancestor) => {
                         return {
@@ -32,6 +38,7 @@ export class UmbDocumentCollectionServerDataSource {
                     unique: item.id,
                     entityType: UMB_DOCUMENT_ENTITY_TYPE,
                     creator: item.creator,
+                    hasChildren: item.hasChildren,
                     isProtected: item.isProtected,
                     isTrashed: item.isTrashed,
                     sortOrder: item.sortOrder,
@@ -46,11 +53,9 @@ export class UmbDocumentCollectionServerDataSource {
                             value: item.value,
                         };
                     }),
-                    documentType: {
-                        unique: item.documentType.id,
-                        icon: item.documentType.icon,
-                        alias: item.documentType.alias,
-                    },
+                    contentType,
+                    // TODO (V20): remove when the deprecated `documentType` field is removed.
+                    documentType: { unique: contentType.unique, icon: contentType.icon, alias: contentType.alias },
                     variants: item.variants.map((item) => {
                         return {
                             name: item.name,

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

@@ -21,7 +21,7 @@ export const manifests = [
         element: () => import('./table/document-table-collection-view.element.js'),
         weight: 300,
         meta: {
-            label: 'Table',
+            label: '#collection_tableViewLabel',
             icon: 'icon-table',
             pathName: 'table',
         },

package/dist-cms/packages/documents/documents/collection/views/table/column-layouts/document-table-column-name.element.js

@@ -25,14 +25,22 @@ let UmbDocumentTableColumnNameElement = class UmbDocumentTableColumnNameElement
         this._name = '';
         this.#resolver.observe(this.#resolver.name, (name) => (this._name = name || ''));
     }
+    #onOpenClick(e) {
+        e.stopPropagation();
+        this.value.onOpen?.();
+    }
     render() {
         if (!this.value)
             return nothing;
-        if (!this.value.editPath)
-            return nothing;
         if (!this._name)
             return nothing;
-        return html `<uui-button compact href=${this.value.editPath} label=${this._name}></uui-button>`;
+        if (this.value.href) {
+            return html `<uui-button compact href=${this.value.href} label=${this._name}></uui-button>`;
+        }
+        if (this.value.onOpen) {
+            return html `<uui-button compact label=${this._name} @click=${this.#onOpenClick}>${this._name}</uui-button>`;
+        }
+        return html `<span>${this._name}</span>`;
     }
     static { this.styles = [
         css `

package/dist-cms/packages/documents/documents/collection/views/table/document-table-collection-view.element.d.ts

@@ -1,19 +1,19 @@
-import { UmbLitElement } from '../../../../../core/lit-element/index.js';
+import type { UmbDocumentCollectionItemModel } from '../../types.js';
+import { type PropertyValues } from '../../../../../../external/lit/index.js';
+import { UmbCollectionViewElementBase } from '../../../../../core/collection/index.js';
 import './column-layouts/document-entity-actions-table-column-view.element.js';
 import './column-layouts/document-table-column-name.element.js';
 import './column-layouts/document-table-column-property-value.element.js';
 import './column-layouts/document-table-column-state.element.js';
-export declare class UmbDocumentTableCollectionViewElement extends UmbLitElement {
+export declare class UmbDocumentTableCollectionViewElement extends UmbCollectionViewElementBase<UmbDocumentCollectionItemModel> {
     #private;
     private _userDefinedProperties?;
-    private _items?;
-    private _tableConfig;
     private _tableColumns;
     private _tableItems;
-    private _selection;
     private _orderingColumn;
     private _orderingDesc;
     constructor();
+    willUpdate(changedProperties: PropertyValues): void;
     render(): import("lit-html").TemplateResult<1>;
     static styles: import("lit").CSSResult[];
 }

package/dist-cms/packages/documents/documents/collection/views/table/document-table-collection-view.element.js

@@ -8,21 +8,21 @@ import { UMB_DOCUMENT_COLLECTION_CONTEXT } from '../../document-collection.conte
 import { UMB_DOCUMENT_ENTITY_TYPE } from '../../../entity.js';
 import { UMB_EDIT_DOCUMENT_WORKSPACE_PATH_PATTERN } from '../../../paths.js';
 import { css, customElement, html, state } from '../../../../../../external/lit/index.js';
-import { UmbLitElement } from '../../../../../core/lit-element/index.js';
 import { UmbTextStyles } from '../../../../../core/style/index.js';
+import { UmbCollectionViewElementBase } from '../../../../../core/collection/index.js';
+import { UmbTreeItemOpenEvent } from '../../../../../core/tree/index.js';
 import './column-layouts/document-entity-actions-table-column-view.element.js';
 import './column-layouts/document-table-column-name.element.js';
 import './column-layouts/document-table-column-property-value.element.js';
 import './column-layouts/document-table-column-state.element.js';
-let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionViewElement extends UmbLitElement {
+let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionViewElement extends UmbCollectionViewElementBase {
+    #tableConfig;
     #systemColumns;
     #collectionContext;
     constructor() {
         super();
-        this._tableConfig = {
-            allowSelection: true,
-        };
         this._tableColumns = [];
+        this.#tableConfig = { allowSelection: false, allowSelectAll: false, selectOnly: false };
         this.#systemColumns = [
             {
                 name: this.localize.term('general_name'),
@@ -38,7 +38,6 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
             },
         ];
         this._tableItems = [];
-        this._selection = [];
         this._orderingColumn = '';
         this._orderingDesc = false;
         this.consumeContext(UMB_DOCUMENT_COLLECTION_CONTEXT, (collectionContext) => {
@@ -52,21 +51,35 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
             return;
         this.observe(this.#collectionContext.userDefinedProperties, (userDefinedProperties) => {
             this._userDefinedProperties = userDefinedProperties;
-            this.#createTableHeadings();
         }, '_observeUserDefinedProperties');
-        this.observe(this.#collectionContext.items, (items) => {
-            this._items = items;
-            this.#createTableItems(this._items);
-        }, '_observeItems');
-        this.observe(this.#collectionContext.selection.selection, (selection) => {
-            this._selection = selection;
-        }, '_observeSelection');
         this.observe(this.#collectionContext.filter, (filter) => {
             const { orderBy, orderDirection } = filter;
             this._orderingColumn = orderBy ?? '';
             this._orderingDesc = orderDirection === 'desc';
         }, '_observeOrdering');
     }
+    willUpdate(changedProperties) {
+        super.willUpdate(changedProperties);
+        if (changedProperties.has('_selectable') ||
+            changedProperties.has('_multiple') ||
+            changedProperties.has('_selectOnly')) {
+            this.#tableConfig = {
+                allowSelection: this._selectable,
+                allowSelectAll: this._multiple,
+                selectOnly: this._selectOnly,
+            };
+        }
+        // The rows carry their own selectability and href, so they are rebuilt when selection or select-only
+        // mode changes too - not just when the underlying items change.
+        if (changedProperties.has('_items') ||
+            changedProperties.has('_userDefinedProperties') ||
+            changedProperties.has('_selectable') ||
+            changedProperties.has('_selectOnly') ||
+            changedProperties.has('_hideItemActions')) {
+            this.#createTableHeadings();
+            this.#createTableItems();
+        }
+    }
     #createTableHeadings() {
         if (this._userDefinedProperties && this._userDefinedProperties.length > 0) {
             const userColumns = this._userDefinedProperties.map((item) => {
@@ -82,14 +95,23 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
             this._tableColumns = [
                 ...this.#systemColumns,
                 ...userColumns,
-                { name: '', alias: 'entityActions', align: 'right' },
+                ...(this._hideItemActions ? [] : [{ name: '', alias: 'entityActions', align: 'right' }]),
             ];
         }
     }
-    #createTableItems(items) {
-        this._tableItems = items.map((item) => {
+    #createTableItems() {
+        this._tableItems = this._items.map((item) => {
             if (!item.unique)
                 throw new Error('Item id is missing.');
+            // While select-only (i.e. in a picker), the name must not navigate away from the picker. An item with
+            // children still needs a way to be opened, so it drills further into it via an open event instead.
+            const editPath = UMB_EDIT_DOCUMENT_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: item.unique });
+            const href = this._selectOnly ? undefined : editPath;
+            const hasCollection = !!item.contentType?.collection;
+            const indicatorHref = href && hasCollection ? `${href}?openCollection=true` : href;
+            const onOpen = item.hasChildren || hasCollection
+                ? () => this.dispatchEvent(new UmbTreeItemOpenEvent({ unique: item.unique, entityType: item.entityType }))
+                : undefined;
             const data = this._tableColumns?.map((column) => {
                 if (column.alias === 'entityActions') {
                     return {
@@ -98,35 +120,57 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
 								.value=${item}></umb-document-entity-actions-table-column-view>`,
                     };
                 }
-                const editPath = UMB_EDIT_DOCUMENT_WORKSPACE_PATH_PATTERN.generateAbsolute({
-                    unique: item.unique,
-                });
                 return {
                     columnAlias: column.alias,
-                    value: { item, editPath },
+                    value: { item, href, onOpen },
                 };
             }) ?? [];
             return {
                 id: item.unique,
                 icon: item.documentType.icon,
                 entityType: UMB_DOCUMENT_ENTITY_TYPE,
+                childrenIndicator: item.hasChildren || hasCollection
+                    ? {
+                        href: indicatorHref,
+                        onOpen,
+                        renderExpandSymbol: hasCollection
+                            ? () => html `<umb-icon name="icon-list" style="font-size: 8px;"></umb-icon>`
+                            : undefined,
+                    }
+                    : undefined,
+                selectable: this._isSelectableItem(item),
+                // select-only disables all row interaction, which would leave no way to open an item with
+                // children while a selection is in progress.
+                selectOnly: item.hasChildren || hasCollection ? false : undefined,
                 data: data,
             };
         });
     }
-    #handleSelect(event) {
+    #onSelected(event) {
         event.stopPropagation();
-        const table = event.target;
-        const selection = table.selection;
-        this.#collectionContext?.selection.setSelection(selection);
+        const itemId = event.getItemId();
+        // We get the same event for both single and multiple selection.
+        if (itemId) {
+            this._selectItem(itemId);
+        }
+        else {
+            const target = event.target;
+            this._setSelection(target.selection);
+        }
     }
-    #handleDeselect(event) {
+    #onDeselected(event) {
         event.stopPropagation();
-        const table = event.target;
-        const selection = table.selection;
-        this.#collectionContext?.selection.setSelection(selection);
+        const itemId = event.getItemId();
+        // We get the same event for both single and multiple deselection.
+        if (itemId) {
+            this._deselectItem(itemId);
+        }
+        else {
+            const target = event.target;
+            this._setSelection(target.selection);
+        }
     }
-    #handleOrdering(event) {
+    #onOrdering(event) {
         const table = event.target;
         const orderingColumn = table.orderingColumn;
         const orderingDesc = table.orderingDesc;
@@ -138,15 +182,15 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
     render() {
         return html `
 			<umb-table
-				.config=${this._tableConfig}
+				.config=${this.#tableConfig}
 				.columns=${this._tableColumns}
 				.items=${this._tableItems}
 				.selection=${this._selection}
 				.orderingColumn=${this._orderingColumn}
 				.orderingDesc=${this._orderingDesc}
-				@selected=${this.#handleSelect}
-				@deselected=${this.#handleDeselect}
-				@ordered=${this.#handleOrdering}></umb-table>
+				@selected=${this.#onSelected}
+				@deselected=${this.#onDeselected}
+				@ordered=${this.#onOrdering}></umb-table>
 		`;
     }
     static { this.styles = [
@@ -171,21 +215,12 @@ let UmbDocumentTableCollectionViewElement = class UmbDocumentTableCollectionView
 __decorate([
     state()
 ], UmbDocumentTableCollectionViewElement.prototype, "_userDefinedProperties", void 0);
-__decorate([
-    state()
-], UmbDocumentTableCollectionViewElement.prototype, "_items", void 0);
-__decorate([
-    state()
-], UmbDocumentTableCollectionViewElement.prototype, "_tableConfig", void 0);
 __decorate([
     state()
 ], UmbDocumentTableCollectionViewElement.prototype, "_tableColumns", void 0);
 __decorate([
     state()
 ], UmbDocumentTableCollectionViewElement.prototype, "_tableItems", void 0);
-__decorate([
-    state()
-], UmbDocumentTableCollectionViewElement.prototype, "_selection", void 0);
 __decorate([
     state()
 ], UmbDocumentTableCollectionViewElement.prototype, "_orderingColumn", void 0);

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

@@ -18,6 +18,12 @@ UmbDocumentTreeItemModel, UmbDocumentPickerModalData, UmbDocumentPickerModalValu
     #private;
     constructor(host: UmbControllerHost);
     openPicker(pickerData?: Partial<UmbDocumentPickerModalData>, args?: UmbDocumentPickerInputContextOpenArgs): Promise<void>;
+    /**
+     * Resolves the display name for a picked document, using the variant aware item data resolver.
+     * @param {string} unique The unique identifier of the document.
+     * @returns {Promise<string>} The resolved display name.
+     * @memberof UmbDocumentPickerInputContext
+     */
     protected _requestItemName(unique: string): Promise<string>;
 }
 export {};

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

@@ -32,13 +32,30 @@ export class UmbDocumentPickerInputContext extends UmbPickerInputContext {
         };
         await super.openPicker(combinedPickerData);
     }
+    /**
+     * Resolves the display name for a picked document, using the variant aware item data resolver.
+     * @param {string} unique The unique identifier of the document.
+     * @returns {Promise<string>} The resolved display name.
+     * @memberof UmbDocumentPickerInputContext
+     */
     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';
+        // A selection can hold uniques that no longer resolve to an item. The resolver cannot name
+        // something it has no data for, so let the base implementation supply the fallback label.
+        if (item) {
+            const resolver = new UmbDocumentItemDataResolver(this);
+            resolver.setData(item);
+            try {
+                const name = await resolver.getName();
+                if (name) {
+                    return name;
+                }
+            }
+            finally {
+                this.removeUmbController(resolver);
+            }
+        }
+        return super._requestItemName(unique);
     }
     #pickableFilter = (item, allowedContentTypes) => {
         // Check if the user has no access to this item (tree items only)

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

@@ -91,6 +91,7 @@ let UmbInputDocumentElement = class UmbInputDocumentElement extends UmbFormContr
             },
             identifier: 'Umb.SorterIdentifier.InputDocument',
             itemSelector: 'umb-entity-item-ref',
+            disabledItemSelector: '[error]',
             containerSelector: 'uui-ref-list',
             onChange: ({ model }) => {
                 this.selection = model;
@@ -164,7 +165,10 @@ let UmbInputDocumentElement = class UmbInputDocumentElement extends UmbFormContr
             return;
         return html `
 			<uui-ref-list>
-				${repeat(this._statuses, (status) => status.unique, (status) => {
+				${repeat(this._statuses, 
+        // Re-key on error state so the sorter re-evaluates `disabledItemSelector` when an item settles
+        // into "not found" — the sorter only checks this when an element is first mounted.
+        (status) => `${status.unique}:${status.state.type === 'error'}`, (status) => {
             const unique = status.unique;
             const item = this._items?.find((x) => x.unique === unique);
             const isError = status.state.type === 'error';
@@ -175,7 +179,7 @@ let UmbInputDocumentElement = class UmbInputDocumentElement extends UmbFormContr
 								?error=${isError}
 								.errorMessage=${status.state.error}
 								.errorDetail=${isError ? unique : undefined}
-								?readonly=${this.readonly}
+								?readonly=${this.readonly || isError}
 								?standalone=${this.max === 1 && this._statuses?.length === 1}>
 								${when(!this.readonly, () => html `
 										<uui-action-bar slot="actions">