@umbraco-cms/backoffice 18.0.2 → 18.1.0-rc

package/dist-cms/packages/core/tree/components/tree-pagination.element.js

@@ -0,0 +1,62 @@
+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_TREE_CONTEXT } from '../tree.context.token.js';
+import { UmbTextStyles } from '../../style/index.js';
+import { css, customElement, html, nothing, state } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+let UmbTreePaginationElement = class UmbTreePaginationElement extends UmbLitElement {
+    #treeContext;
+    constructor() {
+        super();
+        this._totalPages = 1;
+        this._currentPage = 1;
+        this.consumeContext(UMB_TREE_CONTEXT, (context) => {
+            this.#treeContext = context;
+            this.observe(context?.pagination.currentPage, (currentPage) => (this._currentPage = currentPage ?? 1), '_observeCurrentPage');
+            this.observe(context?.pagination.totalPages, (totalPages) => (this._totalPages = totalPages ?? 1), '_observeTotalPages');
+        });
+    }
+    #onChange(event) {
+        this.#treeContext?.loadPage?.(event.target.current);
+    }
+    render() {
+        if (this._totalPages <= 1)
+            return nothing;
+        return html `<uui-pagination
+			.current=${this._currentPage}
+			.total=${this._totalPages}
+			firstlabel=${this.localize.term('general_first')}
+			previouslabel=${this.localize.term('general_previous')}
+			nextlabel=${this.localize.term('general_next')}
+			lastlabel=${this.localize.term('general_last')}
+			@change=${this.#onChange}></uui-pagination>`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				display: block;
+				text-align: center;
+			}
+
+			uui-pagination {
+				display: block;
+				margin-top: var(--uui-size-layout-1);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    state()
+], UmbTreePaginationElement.prototype, "_totalPages", void 0);
+__decorate([
+    state()
+], UmbTreePaginationElement.prototype, "_currentPage", void 0);
+UmbTreePaginationElement = __decorate([
+    customElement('umb-tree-pagination')
+], UmbTreePaginationElement);
+export { UmbTreePaginationElement };

package/dist-cms/packages/core/tree/components/tree-toolbar.element.d.ts

@@ -0,0 +1,17 @@
+import { UmbLitElement } from '../../lit-element/index.js';
+import './tree-action-bundle.element.js';
+import './tree-view-bundle.element.js';
+export declare class UmbTreeToolbarElement extends UmbLitElement {
+    /**
+     * When true the tree actions are shown.
+     * Defaults to false — tree actions are not shown unless explicitly opted in with show-tree-actions.
+     */
+    showTreeActions: boolean;
+    render(): import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-tree-toolbar': UmbTreeToolbarElement;
+    }
+}

package/dist-cms/packages/core/tree/components/tree-toolbar.element.js

@@ -0,0 +1,57 @@
+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 { UmbTextStyles } from '../../style/index.js';
+import { css, html, customElement, nothing, property } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+import './tree-action-bundle.element.js';
+import './tree-view-bundle.element.js';
+let UmbTreeToolbarElement = class UmbTreeToolbarElement extends UmbLitElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * When true the tree actions are shown.
+         * Defaults to false — tree actions are not shown unless explicitly opted in with show-tree-actions.
+         */
+        this.showTreeActions = false;
+    }
+    render() {
+        return html `
+			<div id="toolbar">
+				${this.showTreeActions ? html `<umb-tree-action-bundle></umb-tree-action-bundle>` : nothing}
+				<umb-tree-view-bundle></umb-tree-view-bundle>
+			</div>
+		`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				display: contents;
+			}
+
+			#toolbar {
+				display: flex;
+				align-items: center;
+				width: 100%;
+				padding: 0 0 var(--uui-size-layout-1) 0;
+				box-sizing: border-box;
+			}
+
+			umb-tree-view-bundle {
+				display: inline-block;
+				margin-left: auto;
+			}
+		`,
+    ]; }
+};
+__decorate([
+    property({ type: Boolean, attribute: 'show-tree-actions' })
+], UmbTreeToolbarElement.prototype, "showTreeActions", void 0);
+UmbTreeToolbarElement = __decorate([
+    customElement('umb-tree-toolbar')
+], UmbTreeToolbarElement);
+export { UmbTreeToolbarElement };

package/dist-cms/packages/core/tree/components/tree-view-bundle.element.d.ts

@@ -0,0 +1,16 @@
+import { nothing } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+export declare class UmbTreeViewBundleElement extends UmbLitElement {
+    #private;
+    private _views;
+    private _currentView?;
+    constructor();
+    private _popover?;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-tree-view-bundle': UmbTreeViewBundleElement;
+    }
+}

package/dist-cms/packages/core/tree/components/tree-view-bundle.element.js

@@ -0,0 +1,95 @@
+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_TREE_CONTEXT } from '../tree.context.token.js';
+import { UmbTextStyles } from '../../style/index.js';
+import { css, customElement, html, nothing, query, repeat, state } from '../../../../external/lit/index.js';
+import { UmbLitElement } from '../../lit-element/index.js';
+let UmbTreeViewBundleElement = class UmbTreeViewBundleElement extends UmbLitElement {
+    #treeContext;
+    constructor() {
+        super();
+        this._views = [];
+        this.consumeContext(UMB_TREE_CONTEXT, (context) => {
+            this.#treeContext = context;
+            this.#observeViews();
+        });
+    }
+    #observeViews() {
+        if (!this.#treeContext?.view)
+            return;
+        this.observe(this.#treeContext.view.views, (views) => {
+            this._views = views;
+        }, 'umbTreeViewsObserver');
+        this.observe(this.#treeContext.view.currentView, (currentView) => {
+            this._currentView = currentView;
+        }, 'umbTreeCurrentViewObserver');
+    }
+    #onClick(view) {
+        this.#treeContext?.view?.setCurrentView(view);
+        setTimeout(() => {
+            // TODO: This ignorer is just needed for JSON SCHEMA TO WORK, As its not updated with latest TS yet.
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this._popover?.hidePopover();
+        }, 100);
+    }
+    render() {
+        if (!this._currentView)
+            return nothing;
+        if (this._views.length <= 1)
+            return nothing;
+        return html `
+			<uui-button compact popovertarget="tree-view-bundle-popover" label=${this.localize.term('general_switchView')}>
+				<umb-icon name=${this._currentView.meta.icon}></umb-icon>
+			</uui-button>
+			<uui-popover-container id="tree-view-bundle-popover" placement="bottom-end">
+				<umb-popover-layout>
+					<div class="view-dropdown">
+						${repeat(this._views, (view) => view.alias, (view) => this.#renderItem(view))}
+					</div>
+				</umb-popover-layout>
+			</uui-popover-container>
+		`;
+    }
+    #renderItem(view) {
+        return html `
+			<uui-menu-item
+				label=${this.localize.string(view.meta.label)}
+				@click-label=${() => this.#onClick(view)}
+				?active=${view.alias === this._currentView?.alias}>
+				<umb-icon slot="icon" name=${view.meta.icon}></umb-icon>
+			</uui-menu-item>
+		`;
+    }
+    static { this.styles = [
+        UmbTextStyles,
+        css `
+			:host {
+				--uui-button-content-align: left;
+				--uui-menu-item-flat-structure: 1;
+				display: contents;
+			}
+
+			.view-dropdown {
+				padding: var(--uui-size-space-3);
+			}
+		`,
+    ]; }
+};
+__decorate([
+    state()
+], UmbTreeViewBundleElement.prototype, "_views", void 0);
+__decorate([
+    state()
+], UmbTreeViewBundleElement.prototype, "_currentView", void 0);
+__decorate([
+    query('#tree-view-bundle-popover')
+], UmbTreeViewBundleElement.prototype, "_popover", void 0);
+UmbTreeViewBundleElement = __decorate([
+    customElement('umb-tree-view-bundle')
+], UmbTreeViewBundleElement);
+export { UmbTreeViewBundleElement };

package/dist-cms/packages/core/tree/conditions/constants.d.ts

@@ -0,0 +1 @@
+export declare const UMB_TREE_ALIAS_CONDITION = "Umb.Condition.TreeAlias";

package/dist-cms/packages/core/tree/conditions/constants.js

@@ -0,0 +1 @@
+export const UMB_TREE_ALIAS_CONDITION = 'Umb.Condition.TreeAlias';

package/dist-cms/packages/core/tree/conditions/index.d.ts

@@ -0,0 +1,3 @@
+export { UmbTreeAliasCondition } from './tree-alias.condition.js';
+export { UMB_TREE_ALIAS_CONDITION } from './constants.js';
+export type { TreeAliasConditionConfig } from './types.js';

package/dist-cms/packages/core/tree/conditions/index.js

@@ -0,0 +1,2 @@
+export { UmbTreeAliasCondition } from './tree-alias.condition.js';
+export { UMB_TREE_ALIAS_CONDITION } from './constants.js';

package/dist-cms/packages/core/tree/conditions/manifests.d.ts

@@ -0,0 +1,2 @@
+import type { ManifestCondition } from '../../../../libs/extension-api/index.js';
+export declare const manifests: Array<ManifestCondition>;

package/dist-cms/packages/core/tree/conditions/manifests.js

@@ -0,0 +1,10 @@
+import { UmbTreeAliasCondition } from './tree-alias.condition.js';
+import { UMB_TREE_ALIAS_CONDITION } from './constants.js';
+export const manifests = [
+    {
+        type: 'condition',
+        name: 'Tree Alias Condition',
+        alias: UMB_TREE_ALIAS_CONDITION,
+        api: UmbTreeAliasCondition,
+    },
+];

package/dist-cms/packages/core/tree/conditions/tree-alias.condition.d.ts

@@ -0,0 +1,8 @@
+import type { TreeAliasConditionConfig } from './types.js';
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from '../../../../libs/extension-api/index.js';
+import { UmbConditionBase } from '../../extension-registry/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+export declare class UmbTreeAliasCondition extends UmbConditionBase<TreeAliasConditionConfig> implements UmbExtensionCondition {
+    constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<TreeAliasConditionConfig>);
+}
+export default UmbTreeAliasCondition;

package/dist-cms/packages/core/tree/conditions/tree-alias.condition.js

@@ -0,0 +1,11 @@
+import { UMB_TREE_CONTEXT } from '../tree.context.token.js';
+import { UmbConditionBase } from '../../extension-registry/index.js';
+export class UmbTreeAliasCondition extends UmbConditionBase {
+    constructor(host, args) {
+        super(host, args);
+        this.consumeContext(UMB_TREE_CONTEXT, (context) => {
+            this.permitted = context?.manifest?.alias === this.config.match;
+        });
+    }
+}
+export default UmbTreeAliasCondition;

package/dist-cms/packages/core/tree/conditions/types.d.ts

@@ -0,0 +1,15 @@
+import type { UMB_TREE_ALIAS_CONDITION } from './constants.js';
+import type { UmbConditionConfigBase } from '../../../../libs/extension-api/index.js';
+export type TreeAliasConditionConfig = UmbConditionConfigBase<typeof UMB_TREE_ALIAS_CONDITION> & {
+    /**
+     * The tree that this extension should be available in.
+     * @example
+     * "Umb.Tree.DocumentType"
+     */
+    match: string;
+};
+declare global {
+    interface UmbExtensionConditionConfigMap {
+        TreeAliasConditionConfig: TreeAliasConditionConfig;
+    }
+}

package/dist-cms/packages/core/tree/conditions/types.js

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

package/dist-cms/packages/core/tree/default/default-tree.context.d.ts

@@ -1,5 +1,6 @@
 import { UmbTreeItemActiveManager } from '../active-manager/tree-active-manager.js';
 import { UmbTreeExpansionManager } from '../expansion-manager/index.js';
+import { UmbTreeViewManager } from '../view/tree-view.manager.js';
 import type { ManifestTree } from '../extensions/types.js';
 import type { UmbTreeContext } from '../tree.context.interface.js';
 import type { UmbTreeExpansionModel } from '../expansion-manager/types.js';
@@ -8,6 +9,7 @@ import type { UmbTreeRepository } from '../data/index.js';
 import type { UmbTreeRootItemsRequestArgs } from '../data/types.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbSelectionManager } from '../../utils/index.js';
+import { UmbInteractionMemoryManager } from '../../interaction-memory/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel, TreeRootType extends UmbTreeRootModel, RequestArgsType extends UmbTreeRootItemsRequestArgs = UmbTreeRootItemsRequestArgs> extends UmbContextBase implements UmbTreeContext<TreeItemType, TreeRootType, RequestArgsType> {
     #private;
@@ -16,15 +18,22 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     filter?: (item: TreeItemType) => boolean;
     readonly selection: UmbSelectionManager<string | null>;
     readonly expansion: UmbTreeExpansionManager;
+    readonly interactionMemory: UmbInteractionMemoryManager;
+    readonly view: UmbTreeViewManager;
     readonly hideTreeRoot: import("rxjs").Observable<boolean>;
+    readonly hideTreeItemActions: import("rxjs").Observable<boolean>;
+    readonly selectOnly: import("rxjs").Observable<boolean | undefined>;
+    readonly isMenu: import("rxjs").Observable<boolean | undefined>;
     readonly expandTreeRoot: import("rxjs").Observable<boolean | undefined>;
     readonly rootItems: import("rxjs").Observable<TreeItemType[]>;
+    readonly currentPageItems: import("rxjs").Observable<TreeItemType[]>;
     readonly hasChildren: import("rxjs").Observable<boolean>;
     readonly pagination: import("../../utils/index.js").UmbPaginationManager;
-    readonly targetPagination: import("../../utils/index.js").UmbTargetPaginationManager<import("../../entity/types.js").UmbEntityModel>;
+    readonly targetPagination: import("../../utils/index.js").UmbTargetPaginationManager<import("../../entity/index.js").UmbEntityModel>;
     readonly startNode: import("rxjs").Observable<UmbTreeStartNode | undefined>;
     readonly foldersOnly: import("rxjs").Observable<boolean>;
     readonly additionalRequestArgs: import("rxjs").Observable<object | Partial<RequestArgsType>>;
+    readonly isLoading: import("rxjs").Observable<boolean>;
     readonly isLoadingPrevChildren: import("rxjs").Observable<boolean>;
     readonly isLoadingNextChildren: import("rxjs").Observable<boolean>;
     readonly activeManager: UmbTreeItemActiveManager;
@@ -44,6 +53,7 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
      */
     getManifest(): ManifestTree | undefined;
     getRepository(): UmbTreeRepository<TreeItemType, TreeRootType, UmbTreeRootItemsRequestArgs, import("../index.js").UmbTreeChildrenOfRequestArgs, import("../index.js").UmbTreeAncestorsOfRequestArgs> | undefined;
+    open(item: TreeItemType): void;
     /**
      * Loads the tree
      * @memberof UmbDefaultTreeContext
@@ -56,9 +66,11 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     reloadTree: import("../../utils/index.js").UmbDebouncedFunction<() => Promise<void>>;
     /**
      * Reloads the tree
+     * @param pageNumber
      * @memberof UmbDefaultTreeContext
      * @returns {Promise<void>}
      */
+    loadPage: (pageNumber: number) => Promise<void>;
     loadMore: () => Promise<void>;
     /**
      * Load previous items of the tree item
@@ -72,6 +84,12 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
      * @returns {Promise<void>}
      */
     loadNextItems: () => Promise<void>;
+    setHideTreeItemActions(value: boolean): void;
+    getHideTreeItemActions(): boolean;
+    setSelectOnly(value: boolean | undefined): void;
+    getSelectOnly(): boolean;
+    setIsMenu(value: boolean): void;
+    getIsMenu(): boolean;
     /**
      * Sets the hideTreeRoot config
      * @param {boolean} hideTreeRoot - Whether to hide the tree root

package/dist-cms/packages/core/tree/default/default-tree.context.js

@@ -1,16 +1,25 @@
+import { UmbTreeItemOpenEvent } from '../tree-item/events/tree-item-open.event.js';
 import { UmbTreeItemActiveManager } from '../active-manager/tree-active-manager.js';
 import { UmbTreeExpansionManager } from '../expansion-manager/index.js';
+import { UmbTreeViewManager } from '../view/tree-view.manager.js';
 import { UmbTreeItemChildrenManager } from '../tree-item/tree-item-children.manager.js';
 import { UmbTreeItemTargetExpansionManager } from '../tree-item/tree-item-expansion.manager.js';
 import { UMB_TREE_CONTEXT } from '../tree.context.token.js';
 import { UmbBooleanState, UmbObjectState } from '../../../../libs/observable-api/index.js';
 import { UmbContextBase } from '../../../../libs/class-api/index.js';
 import { UmbDeprecation, UmbSelectionManager, debounce } from '../../utils/index.js';
+import { UmbInteractionMemoryManager } from '../../interaction-memory/index.js';
 import { UmbExtensionApiInitializer } from '../../../../libs/extension-api/index.js';
 import { umbExtensionsRegistry } from '../../extension-registry/index.js';
+import { UmbEntityContext } from '../../entity/index.js';
 export class UmbDefaultTreeContext extends UmbContextBase {
     #treeRoot;
+    #entityContext;
     #hideTreeRoot;
+    #hideTreeItemActions;
+    #selectOnly;
+    #selectOnlyConfig;
+    #isMenu;
     #expandTreeRoot;
     #treeItemChildrenManager;
     #treeItemExpansionManager;
@@ -23,22 +32,33 @@ export class UmbDefaultTreeContext extends UmbContextBase {
         super(host, UMB_TREE_CONTEXT);
         this.#treeRoot = new UmbObjectState(undefined);
         this.treeRoot = this.#treeRoot.asObservable();
+        this.#entityContext = new UmbEntityContext(this);
         this.selectableFilter = () => true;
         this.filter = () => true;
         this.selection = new UmbSelectionManager(this);
         this.expansion = new UmbTreeExpansionManager(this);
+        this.interactionMemory = new UmbInteractionMemoryManager(this);
+        this.view = new UmbTreeViewManager(this, { interactionMemoryManager: this.interactionMemory });
         this.#hideTreeRoot = new UmbBooleanState(false);
         this.hideTreeRoot = this.#hideTreeRoot.asObservable();
+        this.#hideTreeItemActions = new UmbBooleanState(false);
+        this.hideTreeItemActions = this.#hideTreeItemActions.asObservable();
+        this.#selectOnly = new UmbBooleanState(undefined);
+        this.selectOnly = this.#selectOnly.asObservable();
+        this.#isMenu = new UmbBooleanState(undefined);
+        this.isMenu = this.#isMenu.asObservable();
         this.#expandTreeRoot = new UmbBooleanState(undefined);
         this.expandTreeRoot = this.#expandTreeRoot.asObservable();
         this.#treeItemChildrenManager = new UmbTreeItemChildrenManager(this);
         this.rootItems = this.#treeItemChildrenManager.children;
+        this.currentPageItems = this.#treeItemChildrenManager.currentPageChildren;
         this.hasChildren = this.#treeItemChildrenManager.hasChildren;
         this.pagination = this.#treeItemChildrenManager.offsetPagination;
         this.targetPagination = this.#treeItemChildrenManager.targetPagination;
         this.startNode = this.#treeItemChildrenManager.startNode;
         this.foldersOnly = this.#treeItemChildrenManager.foldersOnly;
         this.additionalRequestArgs = this.#treeItemChildrenManager.additionalRequestArgs;
+        this.isLoading = this.#treeItemChildrenManager.isLoading;
         this.isLoadingPrevChildren = this.#treeItemChildrenManager.isLoadingPrevChildren;
         this.isLoadingNextChildren = this.#treeItemChildrenManager.isLoadingNextChildren;
         this.#treeItemExpansionManager = new UmbTreeItemTargetExpansionManager(this, {
@@ -71,9 +91,11 @@ export class UmbDefaultTreeContext extends UmbContextBase {
         this.reloadTree = debounce(() => this.#debouncedLoadTree(true), 100);
         /**
          * Reloads the tree
+         * @param pageNumber
          * @memberof UmbDefaultTreeContext
          * @returns {Promise<void>}
          */
+        this.loadPage = (pageNumber) => this.#treeItemChildrenManager.loadPage(pageNumber);
         this.loadMore = () => this.#treeItemChildrenManager.loadNextChildren();
         /**
          * Load previous items of the tree item
@@ -88,8 +110,12 @@ export class UmbDefaultTreeContext extends UmbContextBase {
          */
         this.loadNextItems = () => this.#treeItemChildrenManager.loadNextChildren();
         this.#treeItemChildrenManager.setTakeSize(50);
-        // always load the tree root because we need the root entity to reload the entire tree
-        this.#loadTreeRoot();
+        // Auto-enable selectOnly when a selection exists and it was not explicitly set.
+        this.observe(this.selection.selection, (selection) => {
+            if (this.#selectOnlyConfig === undefined) {
+                this.#selectOnly.setValue((selection?.length ?? 0) > 0);
+            }
+        });
     }
     // TODO: find a generic way to do this
     #checkIfInitialized() {
@@ -107,6 +133,9 @@ export class UmbDefaultTreeContext extends UmbContextBase {
         if (this.#manifest === manifest)
             return;
         this.#manifest = manifest;
+        if (manifest?.alias) {
+            this.view.setTreeAlias(manifest.alias);
+        }
         this.#observeRepository(this.#manifest?.meta.repositoryAlias);
     }
     get manifest() {
@@ -129,11 +158,25 @@ export class UmbDefaultTreeContext extends UmbContextBase {
     getRepository() {
         return this.#repository;
     }
+    open(item) {
+        // The tree root has a null unique and is not a navigable target, so opening it is a no-op.
+        const unique = item.unique;
+        if (unique === null || unique === undefined)
+            return;
+        this.getHostElement().dispatchEvent(new UmbTreeItemOpenEvent({ unique, entityType: item.entityType }));
+    }
     async #debouncedLoadTree(reload = false) {
         await this.#init;
         const hasStartNode = this.getStartNode();
         const hideTreeRoot = this.getHideTreeRoot();
-        if (hasStartNode || hideTreeRoot) {
+        // Always load the tree root entity, even when the root node is hidden or we are drilled
+        // into a start node. The root entity is required to wire up the target/expansion handling
+        // at root level: the tree's expansion manager only starts observing once it has been given
+        // the root tree item, which is what lets a deep-link / breadcrumb target paginate the root.
+        this.#loadTreeRoot(reload);
+        // Load children when drilled into a node, when the root is hidden, or when
+        // the root is pre-expanded — all cases where children must be immediately visible.
+        if (hasStartNode || hideTreeRoot || this.getExpandTreeRoot()) {
             if (reload) {
                 this.#treeItemChildrenManager.reloadChildren();
             }
@@ -141,9 +184,6 @@ export class UmbDefaultTreeContext extends UmbContextBase {
                 this.#treeItemChildrenManager.loadChildren();
             }
         }
-        else {
-            this.#loadTreeRoot(reload);
-        }
     }
     async #loadTreeRoot(reload = false) {
         await this.#init;
@@ -152,6 +192,10 @@ export class UmbDefaultTreeContext extends UmbContextBase {
             this.#treeRoot.setValue(data);
             this.#treeItemChildrenManager.setTreeItem(data);
             this.#treeItemExpansionManager.setTreeItem(data);
+            if (!this.getStartNode()) {
+                this.#entityContext.setEntityType(data.entityType);
+                this.#entityContext.setUnique(data.unique);
+            }
             this.pagination.setTotalItems(1);
             if (!reload) {
                 if (this.getExpandTreeRoot()) {
@@ -160,6 +204,26 @@ export class UmbDefaultTreeContext extends UmbContextBase {
             }
         }
     }
+    setHideTreeItemActions(value) {
+        this.#hideTreeItemActions.setValue(value);
+    }
+    getHideTreeItemActions() {
+        return this.#hideTreeItemActions.getValue();
+    }
+    setSelectOnly(value) {
+        this.#selectOnlyConfig = value;
+        // If undefined (auto-detect), compute from current selection so re-renders don't reset the auto-detected state.
+        this.#selectOnly.setValue(value ?? (this.selection.getSelection()?.length ?? 0) > 0);
+    }
+    getSelectOnly() {
+        return this.#selectOnly.getValue() ?? false;
+    }
+    setIsMenu(value) {
+        this.#isMenu.setValue(value);
+    }
+    getIsMenu() {
+        return this.#isMenu.getValue() ?? false;
+    }
     /**
      * Sets the hideTreeRoot config
      * @param {boolean} hideTreeRoot - Whether to hide the tree root
@@ -186,6 +250,10 @@ export class UmbDefaultTreeContext extends UmbContextBase {
      */
     setStartNode(startNode) {
         this.#treeItemChildrenManager.setStartNode(startNode);
+        if (startNode) {
+            this.#entityContext.setEntityType(startNode.entityType);
+            this.#entityContext.setUnique(startNode.unique);
+        }
         // we need to reset the tree if this config changes
         this.#clearTree();
         this.loadTree();

package/dist-cms/packages/core/tree/default/default-tree.element.d.ts

@@ -3,6 +3,8 @@ import type { UmbTreeExpansionModel } from '../expansion-manager/types.js';
 import type { UmbDefaultTreeContext } from './default-tree.context.js';
 import { UmbLitElement } from '../../lit-element/index.js';
 import type { PropertyValueMap } from '../../../../external/lit/index.js';
+import type { UmbInteractionMemoryModel } from '../../interaction-memory/index.js';
+import '../components/tree-toolbar.element.js';
 export declare class UmbDefaultTreeElement extends UmbLitElement {
     #private;
     private _selectionConfiguration;
@@ -19,18 +21,18 @@ export declare class UmbDefaultTreeElement extends UmbLitElement {
     selectableFilter: (item: UmbTreeItemModelBase) => boolean;
     filter: (item: UmbTreeItemModelBase) => boolean;
     expansion: UmbTreeExpansionModel;
-    private _rootItems;
-    private _treeRoot?;
-    private _currentPage;
-    private _hasPreviousItems;
-    private _hasNextItems;
-    private _isLoadingPrevChildren;
-    private _isLoadingNextChildren;
+    showToolbar: boolean;
+    showTreeActions: boolean;
+    interactionMemories?: Array<UmbInteractionMemoryModel>;
+    private _viewElement?;
+    private _hasItems;
+    private _isLoading;
+    private _initialLoadDone;
     protected updated(_changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): Promise<void>;
     getSelection(): (string | null)[] | undefined;
     getExpansion(): UmbTreeExpansionModel | undefined;
     render(): import("lit-html").TemplateResult<1>;
-    static styles: import("lit").CSSResult;
+    static styles: import("lit").CSSResult[];
 }
 export default UmbDefaultTreeElement;
 declare global {