@umbraco-cms/backoffice 17.6.2 → 17.7.0-rc

package/dist-cms/packages/core/tree/active-manager/tree-active-manager.js

@@ -1,7 +1,9 @@
 import { UmbControllerBase } from '../../../../libs/class-api/index.js';
-import { UmbArrayState } from '../../../../libs/observable-api/index.js';
+import { mergeObservables, UmbArrayState, UmbStringState, } from '../../../../libs/observable-api/index.js';
+import { ensureSlash } from '../../router/index.js';
+import { debounce, UmbDeprecation } from '../../utils/index.js';
 /**
- * Manages the expansion state of a tree
+ * Manages which tree entity is currently being viewed, and the trail of entities leading to it
  * @exports
  * @class UmbTreeItemActiveManager
  * @augments {UmbControllerBase}
@@ -10,9 +12,54 @@ export class UmbTreeItemActiveManager extends UmbControllerBase {
     constructor() {
         super(...arguments);
         this.#active = new UmbArrayState([], (x) => x.entityType + x.unique);
-        this.active = this.#active.asObservable();
+        /**
+         * The trail of entities from the tree root down to the entity currently being viewed.
+         */
+        this.activeTrail = this.#active.asObservable();
+        this.#currentLocation = new UmbStringState(window.location.pathname);
+        // One listener per tree rather than one per tree item: every item asks the same question of the
+        // same answer, and a tree scoped source is released together with the items observing it.
+        this.#onNavigationEnd = debounce(() => this.#currentLocation.setValue(window.location.pathname), 100);
     }
     #active;
+    /**
+     * @returns {Observable<Array<UmbEntityModel>>} The active trail
+     * @deprecated Deprecated since v17. Use `activeTrail` instead. Will be removed in v19.
+     */
+    get active() {
+        new UmbDeprecation({
+            deprecated: 'UmbTreeItemActiveManager.active',
+            removeInVersion: '19.0.0',
+            solution: 'Use activeTrail instead.',
+        }).warn();
+        return this.activeTrail;
+    }
+    #currentLocation;
+    // One listener per tree rather than one per tree item: every item asks the same question of the
+    // same answer, and a tree scoped source is released together with the items observing it.
+    #onNavigationEnd;
+    hostConnected() {
+        super.hostConnected();
+        window.addEventListener('navigationend', this.#onNavigationEnd);
+        this.#currentLocation.setValue(window.location.pathname);
+    }
+    hostDisconnected() {
+        super.hostDisconnected();
+        window.removeEventListener('navigationend', this.#onNavigationEnd);
+        this.#onNavigationEnd.cancel();
+    }
+    /**
+     * Checks if a path is the one currently open in the browser
+     * @param {Observable<string>} path The path to check, as it may change while the item is alive
+     * @returns {Observable<boolean>} True while the browser location points at the path
+     * @memberof UmbTreeItemActiveManager
+     */
+    isCurrentLocation(path) {
+        return mergeObservables([this.#currentLocation.asObservable(), path], 
+        // Compare with trailing slashes so /path-1 does not match /path-1-2, and allow anything
+        // beyond the item path itself, such as the workspace view segment.
+        ([currentLocation, itemPath]) => !!itemPath && ensureSlash(currentLocation).includes(ensureSlash(itemPath)));
+    }
     /**
      * Checks if an entity is active
      * @param {UmbEntityModel} entity The entity to check
@@ -47,30 +94,42 @@ export class UmbTreeItemActiveManager extends UmbControllerBase {
         return this.#active.getValue().some((e) => e.entityType === entity.entityType && e.unique === entity.unique);
     }
     /**
-     * Sets the active chain state
-     * @param {Array<UmbEntityModel>} activeChain The active entries.
+     * Sets the trail of entities from the tree root down to the entity currently being viewed
+     * @param {Array<UmbEntityModel>} activeTrail The active entries, root first.
      * @memberof UmbTreeItemActiveManager
      * @returns {void}
      */
-    setActive(activeChain) {
-        this.#active.setValue(activeChain);
+    setActiveTrail(activeTrail) {
+        this.#active.setValue(activeTrail);
     }
     /**
-     * Sets the active chain state
      * @param {Array<UmbEntityModel>} activeChain The active entries.
+     * @deprecated Deprecated since v17. Use `setActiveTrail()` instead. Will be removed in v19.
+     */
+    setActive(activeChain) {
+        new UmbDeprecation({
+            deprecated: 'UmbTreeItemActiveManager.setActive()',
+            removeInVersion: '19.0.0',
+            solution: 'Use setActiveTrail() instead.',
+        }).warn();
+        this.setActiveTrail(activeChain);
+    }
+    /**
+     * Clears the active trail, but only when it matches the given trail
+     * @param {Array<UmbEntityModel>} activeTrail The trail that must match for the state to be cleared.
      * @memberof UmbTreeItemActiveManager
      * @returns {void}
      */
-    removeActiveIfMatch(activeChain) {
-        const currentChain = this.#active.getValue();
-        // test if new chain and current chain matches:
+    removeActiveTrailIfMatch(activeTrail) {
+        const currentTrail = this.#active.getValue();
+        // test if new trail and current trail matches:
         // Test length for a start:
-        if (activeChain.length !== currentChain.length)
+        if (activeTrail.length !== currentTrail.length)
             return;
         // test content next:
-        for (let i = 0; i < activeChain.length; i++) {
-            if (activeChain[i].entityType !== currentChain[i].entityType ||
-                activeChain[i].unique !== currentChain[i].unique) {
+        for (let i = 0; i < activeTrail.length; i++) {
+            if (activeTrail[i].entityType !== currentTrail[i].entityType ||
+                activeTrail[i].unique !== currentTrail[i].unique) {
                 return;
             }
         }
@@ -79,11 +138,35 @@ export class UmbTreeItemActiveManager extends UmbControllerBase {
         this.#active.setValue([]);
     }
     /**
-     * Gets the expansion state
+     * @param {Array<UmbEntityModel>} activeChain The active entries.
+     * @deprecated Deprecated since v17. Use `removeActiveTrailIfMatch()` instead. Will be removed in v19.
+     */
+    removeActiveIfMatch(activeChain) {
+        new UmbDeprecation({
+            deprecated: 'UmbTreeItemActiveManager.removeActiveIfMatch()',
+            removeInVersion: '19.0.0',
+            solution: 'Use removeActiveTrailIfMatch() instead.',
+        }).warn();
+        this.removeActiveTrailIfMatch(activeChain);
+    }
+    /**
+     * Gets the trail of entities from the tree root down to the entity currently being viewed
      * @memberof UmbTreeItemActiveManager
-     * @returns {Array<UmbEntityModel>} The expansion state
+     * @returns {Array<UmbEntityModel>} The active trail, root first
      */
-    getActive() {
+    getActiveTrail() {
         return this.#active.getValue();
     }
+    /**
+     * @returns {Array<UmbEntityModel>} The active trail
+     * @deprecated Deprecated since v17. Use `getActiveTrail()` instead. Will be removed in v19.
+     */
+    getActive() {
+        new UmbDeprecation({
+            deprecated: 'UmbTreeItemActiveManager.getActive()',
+            removeInVersion: '19.0.0',
+            solution: 'Use getActiveTrail() instead.',
+        }).warn();
+        return this.getActiveTrail();
+    }
 }

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

@@ -3,5 +3,5 @@ export { UmbTreeRepositoryBase } from './tree-repository-base.js';
 export type { UmbTreeDataSource } from './tree-data-source.interface.js';
 export type { UmbTreeRepository } from './tree-repository.interface.js';
 export type { UmbTreeStore } from './tree-store.interface.js';
-export type { UmbTreeRootItemsRequestArgs, UmbTreeChildrenOfRequestArgs, UmbTreeAncestorsOfRequestArgs, } from './types.js';
+export type { UmbCreateTreeItemDataResolverArgs, UmbTreeItemDataResolver, UmbTreeRootItemsRequestArgs, UmbTreeChildrenOfRequestArgs, UmbTreeAncestorsOfRequestArgs, } from './types.js';
 export { UmbUniqueTreeStore } from './unique-tree-store.js';

package/dist-cms/packages/core/tree/data/tree-data-source.interface.d.ts

@@ -18,13 +18,13 @@ export interface UmbTreeDataSourceConstructor<TreeItemType extends UmbTreeItemMo
 export interface UmbTreeDataSource<TreeItemType extends UmbTreeItemModel, TreeRootItemsRequestArgsType extends UmbTreeRootItemsRequestArgs = UmbTreeRootItemsRequestArgs, TreeChildrenOfRequestArgsType extends UmbTreeChildrenOfRequestArgs = UmbTreeChildrenOfRequestArgs, TreeAncestorsOfRequestArgsType extends UmbTreeAncestorsOfRequestArgs = UmbTreeAncestorsOfRequestArgs> {
     /**
      * Gets the root items of the tree.
-     * @returns {*}  {Promise<UmbDataSourceResponse<UmbPagedModel<TreeItemType>>>}
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<TreeItemType>>>} The root items of the tree.
      * @memberof UmbTreeDataSource
      */
     getRootItems(args: TreeRootItemsRequestArgsType): Promise<UmbDataSourceResponse<UmbTargetPagedModel<TreeItemType>>>;
     /**
      * Gets the children of the given parent item.
-     * @returns {Promise<UmbDataSourceResponse<UmbPagedModel<TreeItemType>>>}
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<TreeItemType>>>}
      * @memberof UmbTreeDataSource
      */
     getChildrenOf(args: TreeChildrenOfRequestArgsType): Promise<UmbDataSourceResponse<UmbTargetPagedModel<TreeItemType>>>;

package/dist-cms/packages/core/tree/data/tree-repository-base.d.ts

@@ -3,10 +3,11 @@ import type { UmbTreeStore } from './tree-store.interface.js';
 import type { UmbTreeRepository } from './tree-repository.interface.js';
 import type { UmbTreeDataSource, UmbTreeDataSourceConstructor } from './tree-data-source.interface.js';
 import type { UmbTreeAncestorsOfRequestArgs, UmbTreeChildrenOfRequestArgs, UmbTreeRootItemsRequestArgs } from './types.js';
-import { UmbRepositoryBase, type UmbRepositoryResponse } from '../../repository/index.js';
+import { UmbRepositoryBase, type UmbRepositoryResponse, type UmbRepositoryResponseWithAsObservable, type UmbTargetPagedModel } from '../../repository/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import type { UmbApi } from '../../../../libs/extension-api/index.js';
 import type { UmbContextToken } from '../../../../libs/context-api/index.js';
+import { type Observable } from '../../../../external/rxjs/index.js';
 /**
  * Base class for a tree repository.
  * @abstract
@@ -31,37 +32,28 @@ export declare abstract class UmbTreeRepositoryBase<TreeItemType extends UmbTree
     constructor(host: UmbControllerHost, treeSourceConstructor: UmbTreeDataSourceConstructor<TreeItemType>, treeStoreContextAlias?: string | UmbContextToken<any, any>);
     /**
      * Request the tree root item
-     * @returns {*}
+     * @returns {Promise<UmbRepositoryResponse<TreeRootType>>}
      * @memberof UmbTreeRepositoryBase
      */
     abstract requestTreeRoot(): Promise<UmbRepositoryResponse<TreeRootType>>;
     /**
      * Requests root items of a tree
-     * @param args
-     * @returns {*}
+     * @param {TreeRootItemsRequestArgsType} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>} The root items of the tree
      * @memberof UmbTreeRepositoryBase
      */
-    requestTreeRootItems(args: TreeRootItemsRequestArgsType): Promise<{
-        data: import("../../repository/index.js").UmbTargetPagedModel<TreeItemType> | undefined;
-        error: Error | import("../../resources/umb-error.js").UmbError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbApiError | undefined;
-        asObservable: () => import("rxjs").Observable<TreeItemType[]> | undefined;
-    }>;
+    requestTreeRootItems(args: TreeRootItemsRequestArgsType): Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>;
     /**
      * Requests tree items of a given parent
-     * @param {(string | null)} parentUnique
-     * @param args
-     * @returns {*}
+     * @param {TreeChildrenOfRequestArgsType} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>} The tree items of the given parent
      * @memberof UmbTreeRepositoryBase
      */
-    requestTreeItemsOf(args: TreeChildrenOfRequestArgsType): Promise<{
-        data: import("../../repository/index.js").UmbTargetPagedModel<TreeItemType> | undefined;
-        error: Error | import("../../resources/umb-error.js").UmbError | import("../../resources/umb-error.js").UmbCancelError | import("../../resources/umb-error.js").UmbApiError | undefined;
-        asObservable: () => import("rxjs").Observable<TreeItemType[]> | undefined;
-    }>;
+    requestTreeItemsOf(args: TreeChildrenOfRequestArgsType): Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>;
     /**
      * Requests ancestors of a given item
-     * @param {UmbTreeAncestorsOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeAncestorsOfRequestArgs} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponse<Array<TreeItemType>>>} The ancestors of the given item
      * @memberof UmbTreeRepositoryBase
      */
     requestTreeItemAncestors(args: TreeAncestorsOfRequestArgsType): Promise<{
@@ -70,17 +62,17 @@ export declare abstract class UmbTreeRepositoryBase<TreeItemType extends UmbTree
     }>;
     /**
      * Returns a promise with an observable of tree root items
-     * @returns {*}
+     * @returns {Promise<Observable<Array<TreeItemType>>>} An observable of tree root items
      * @memberof UmbTreeRepositoryBase
      * @deprecated Use `requestTreeRootItems` instead. This method requires the tree store to be available, which is not always the case. It will be removed in Umbraco 18.
      */
-    rootTreeItems(): Promise<import("rxjs").Observable<TreeItemType[]>>;
+    rootTreeItems(): Promise<Observable<Array<TreeItemType>>>;
     /**
      * Returns a promise with an observable of children items of a given parent
-     * @param {(string | null)} parentUnique
-     * @returns {*}
+     * @param {(string | null)} parentUnique - The unique identifier of the parent
+     * @returns {Promise<Observable<Array<TreeItemType>>>} An observable of children items of the given parent
      * @memberof UmbTreeRepositoryBase
      * @deprecated Use `requestTreeItemsOf` instead. This method requires the tree store to be available, which is not always the case. It will be removed in Umbraco 18.
      */
-    treeItemsOf(parentUnique: string | null): Promise<import("rxjs").Observable<TreeItemType[]>>;
+    treeItemsOf(parentUnique: string | null): Promise<Observable<Array<TreeItemType>>>;
 }

package/dist-cms/packages/core/tree/data/tree-repository-base.js

@@ -1,4 +1,4 @@
-import { UmbRepositoryBase } from '../../repository/index.js';
+import { UmbRepositoryBase, } from '../../repository/index.js';
 import { of } from '../../../../external/rxjs/index.js';
 import { UmbDeprecation } from '../../utils/index.js';
 /**
@@ -44,8 +44,8 @@ export class UmbTreeRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Requests root items of a tree
-     * @param args
-     * @returns {*}
+     * @param {TreeRootItemsRequestArgsType} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>} The root items of the tree
      * @memberof UmbTreeRepositoryBase
      */
     async requestTreeRootItems(args) {
@@ -67,9 +67,8 @@ export class UmbTreeRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Requests tree items of a given parent
-     * @param {(string | null)} parentUnique
-     * @param args
-     * @returns {*}
+     * @param {TreeChildrenOfRequestArgsType} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponseWithAsObservable<UmbTargetPagedModel<TreeItemType>, Array<TreeItemType>>>} The tree items of the given parent
      * @memberof UmbTreeRepositoryBase
      */
     async requestTreeItemsOf(args) {
@@ -97,8 +96,8 @@ export class UmbTreeRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Requests ancestors of a given item
-     * @param {UmbTreeAncestorsOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeAncestorsOfRequestArgs} args - The request arguments
+     * @returns {Promise<UmbRepositoryResponse<Array<TreeItemType>>>} The ancestors of the given item
      * @memberof UmbTreeRepositoryBase
      */
     async requestTreeItemAncestors(args) {
@@ -112,7 +111,7 @@ export class UmbTreeRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Returns a promise with an observable of tree root items
-     * @returns {*}
+     * @returns {Promise<Observable<Array<TreeItemType>>>} An observable of tree root items
      * @memberof UmbTreeRepositoryBase
      * @deprecated Use `requestTreeRootItems` instead. This method requires the tree store to be available, which is not always the case. It will be removed in Umbraco 18.
      */
@@ -122,8 +121,8 @@ export class UmbTreeRepositoryBase extends UmbRepositoryBase {
     }
     /**
      * Returns a promise with an observable of children items of a given parent
-     * @param {(string | null)} parentUnique
-     * @returns {*}
+     * @param {(string | null)} parentUnique - The unique identifier of the parent
+     * @returns {Promise<Observable<Array<TreeItemType>>>} An observable of children items of the given parent
      * @memberof UmbTreeRepositoryBase
      * @deprecated Use `requestTreeItemsOf` instead. This method requires the tree store to be available, which is not always the case. It will be removed in Umbraco 18.
      */

package/dist-cms/packages/core/tree/data/tree-repository.interface.d.ts

@@ -1,8 +1,9 @@
 import type { UmbTreeItemModel, UmbTreeRootModel } from '../types.js';
-import type { UmbTreeChildrenOfRequestArgs, UmbTreeAncestorsOfRequestArgs, UmbTreeRootItemsRequestArgs } from './types.js';
+import type { UmbCreateTreeItemDataResolverArgs, UmbTreeChildrenOfRequestArgs, UmbTreeAncestorsOfRequestArgs, UmbTreeItemDataResolver, UmbTreeRootItemsRequestArgs } from './types.js';
 import type { Observable } from '../../../../external/rxjs/index.js';
 import type { UmbApi } from '../../../../libs/extension-api/index.js';
 import type { UmbRepositoryResponse, UmbRepositoryResponseWithAsObservable, UmbTargetPagedModel } from '../../repository/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 /**
  * Interface for a tree repository.
  * @interface UmbTreeRepository
@@ -16,6 +17,15 @@ export interface UmbTreeRepository<TreeItemType extends UmbTreeItemModel = UmbTr
      * @memberof UmbTreeRepository
      */
     requestTreeRoot: () => Promise<UmbRepositoryResponse<TreeRootType>>;
+    /**
+     * Creates an item data resolver for a tree item. Implement this to resolve names and icons that cannot be
+     * read directly off the tree item, such as variant aware document names.
+     * @param {UmbControllerHost} host - The controller host of the consumer.
+     * @param {UmbCreateTreeItemDataResolverArgs} [args] - Optional arguments for selecting the resolver.
+     * @returns {UmbTreeItemDataResolver | undefined} A resolver for the item, if one is available.
+     * @memberof UmbTreeRepository
+     */
+    createTreeItemDataResolver?: (host: UmbControllerHost, args?: UmbCreateTreeItemDataResolverArgs) => UmbTreeItemDataResolver<TreeItemType> | undefined;
     /**
      * Requests the root items of the tree.
      * @param {UmbTreeRootItemsRequestArgs} args

package/dist-cms/packages/core/tree/data/tree-server-data-source-base.d.ts

@@ -24,14 +24,14 @@ export declare abstract class UmbTreeServerDataSourceBase<ServerTreeItemType ext
     /**
      * Creates an instance of UmbTreeServerDataSourceBase.
      * @param {UmbControllerHost} host - The controller host for this controller to be appended to
-     * @param args
+     * @param {UmbTreeServerDataSourceBaseArgs} args - The arguments for the data source
      * @memberof UmbTreeServerDataSourceBase
      */
     constructor(host: UmbControllerHost, args: UmbTreeServerDataSourceBaseArgs<ServerTreeItemType, ClientTreeItemType, TreeRootItemsRequestArgsType, TreeChildrenOfRequestArgsType, TreeAncestorsOfRequestArgsType>);
     /**
      * Fetches the root items for the tree from the server
-     * @param {UmbTreeRootItemsRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeRootItemsRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<ClientTreeItemType>>>} The mapped root items
      * @memberof UmbTreeServerDataSourceBase
      */
     getRootItems(args: TreeRootItemsRequestArgsType): Promise<{
@@ -43,13 +43,13 @@ export declare abstract class UmbTreeServerDataSourceBase<ServerTreeItemType ext
         };
         error?: undefined;
     } | {
-        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
+        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
         data?: undefined;
     }>;
     /**
      * Fetches the children of a given parent unique from the server
-     * @param {UmbTreeChildrenOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeChildrenOfRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<ClientTreeItemType>>>} The mapped child items
      * @memberof UmbTreeServerDataSourceBase
      */
     getChildrenOf(args: TreeChildrenOfRequestArgsType): Promise<{
@@ -61,20 +61,20 @@ export declare abstract class UmbTreeServerDataSourceBase<ServerTreeItemType ext
         };
         error?: undefined;
     } | {
-        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
+        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
         data?: undefined;
     }>;
     /**
      * Fetches the ancestors of a given item from the server
-     * @param {UmbTreeAncestorsOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeAncestorsOfRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<Array<ClientTreeItemType>>>} The mapped ancestor items
      * @memberof UmbTreeServerDataSourceBase
      */
     getAncestorsOf(args: TreeAncestorsOfRequestArgsType): Promise<{
         data: ClientTreeItemType[];
         error?: undefined;
     } | {
-        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
+        error: ((Error | import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError) & (import("../../resources/index.js").UmbError | import("../../resources/index.js").UmbCancelError | import("../../resources/index.js").UmbApiError)) | undefined;
         data?: undefined;
     }>;
 }

package/dist-cms/packages/core/tree/data/tree-server-data-source-base.js

@@ -13,7 +13,7 @@ export class UmbTreeServerDataSourceBase extends UmbControllerBase {
     /**
      * Creates an instance of UmbTreeServerDataSourceBase.
      * @param {UmbControllerHost} host - The controller host for this controller to be appended to
-     * @param args
+     * @param {UmbTreeServerDataSourceBaseArgs} args - The arguments for the data source
      * @memberof UmbTreeServerDataSourceBase
      */
     constructor(host, args) {
@@ -25,8 +25,8 @@ export class UmbTreeServerDataSourceBase extends UmbControllerBase {
     }
     /**
      * Fetches the root items for the tree from the server
-     * @param {UmbTreeRootItemsRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeRootItemsRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<ClientTreeItemType>>>} The mapped root items
      * @memberof UmbTreeServerDataSourceBase
      */
     async getRootItems(args) {
@@ -46,8 +46,8 @@ export class UmbTreeServerDataSourceBase extends UmbControllerBase {
     }
     /**
      * Fetches the children of a given parent unique from the server
-     * @param {UmbTreeChildrenOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeChildrenOfRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<UmbTargetPagedModel<ClientTreeItemType>>>} The mapped child items
      * @memberof UmbTreeServerDataSourceBase
      */
     async getChildrenOf(args) {
@@ -69,8 +69,8 @@ export class UmbTreeServerDataSourceBase extends UmbControllerBase {
     }
     /**
      * Fetches the ancestors of a given item from the server
-     * @param {UmbTreeAncestorsOfRequestArgs} args
-     * @returns {*}
+     * @param {UmbTreeAncestorsOfRequestArgs} args - The arguments for the request
+     * @returns {Promise<UmbDataSourceResponse<Array<ClientTreeItemType>>>} The mapped ancestor items
      * @memberof UmbTreeServerDataSourceBase
      */
     async getAncestorsOf(args) {

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

@@ -1,4 +1,6 @@
+import type { UmbTreeItemModel } from '../types.js';
 import type { UmbEntityModel } from '../../entity/index.js';
+import type { UmbItemDataResolver } from '../../entity-item/index.js';
 import type { UmbOffsetPaginationRequestModel, UmbTargetPaginationRequestModel } from '../../utils/index.js';
 export interface UmbTreeRootItemsRequestArgs {
     foldersOnly?: boolean;
@@ -39,3 +41,8 @@ export interface UmbTreeAncestorsOfRequestArgs {
         entityType: string;
     };
 }
+export interface UmbCreateTreeItemDataResolverArgs {
+    entityType: string;
+}
+export interface UmbTreeItemDataResolver<TreeItemType extends UmbTreeItemModel = UmbTreeItemModel> extends UmbItemDataResolver<TreeItemType> {
+}

package/dist-cms/packages/core/tree/data/unique-tree-store.d.ts

@@ -1,6 +1,7 @@
 import type { UmbTreeItemModel } from '../types.js';
 import type { UmbTreeStore } from './tree-store.interface.js';
 import { UmbStoreBase } from '../../store/index.js';
+import type { Observable } from '../../../../libs/observable-api/index.js';
 import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import type { UmbContextToken } from '../../../../libs/context-api/index.js';
 /**
@@ -14,12 +15,12 @@ export declare class UmbUniqueTreeStore extends UmbStoreBase<UmbTreeItemModel> i
      * An observable to observe the root items
      * @memberof UmbUniqueTreeStore
      */
-    rootItems: import("rxjs").Observable<UmbTreeItemModel[]>;
+    rootItems: Observable<UmbTreeItemModel[]>;
     /**
      * Returns an observable to observe the children of a given parent
-     * @param {(string | null)} parentUnique
-     * @returns {*}
+     * @param {(string | null)} parentUnique - The unique of the parent
+     * @returns {Observable<Array<UmbTreeItemModel>>} An observable of the children
      * @memberof UmbUniqueTreeStore
      */
-    childrenOf(parentUnique: string | null): import("rxjs").Observable<UmbTreeItemModel[]>;
+    childrenOf(parentUnique: string | null): Observable<Array<UmbTreeItemModel>>;
 }

package/dist-cms/packages/core/tree/data/unique-tree-store.js

@@ -17,8 +17,8 @@ export class UmbUniqueTreeStore extends UmbStoreBase {
     }
     /**
      * Returns an observable to observe the children of a given parent
-     * @param {(string | null)} parentUnique
-     * @returns {*}
+     * @param {(string | null)} parentUnique - The unique of the parent
+     * @returns {Observable<Array<UmbTreeItemModel>>} An observable of the children
      * @memberof UmbUniqueTreeStore
      */
     childrenOf(parentUnique) {

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

@@ -24,6 +24,14 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     readonly hideTreeItemActions: import("rxjs").Observable<boolean>;
     readonly selectOnly: import("rxjs").Observable<boolean | undefined>;
     readonly isMenu: import("rxjs").Observable<boolean | undefined>;
+    /**
+     * Whether opening an item takes the user into it. A property of the host, so it is the same for every item in the
+     * tree.
+     *
+     * Off unless the host declares otherwise: a tree that can do no more than expand and collapse is the common case,
+     * and the one where offering to drill into an item would strand everything below it.
+     */
+    readonly drillable: import("rxjs").Observable<boolean>;
     readonly expandTreeRoot: import("rxjs").Observable<boolean | undefined>;
     readonly rootItems: import("rxjs").Observable<TreeItemType[]>;
     readonly currentPageItems: import("rxjs").Observable<TreeItemType[]>;
@@ -40,14 +48,14 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     constructor(host: UmbControllerHost);
     /**
      * Sets the manifest
-     * @param {ManifestTree} manifest
+     * @param {ManifestTree} manifest - The tree manifest
      * @memberof UmbDefaultTreeContext
      */
     set manifest(manifest: ManifestTree | undefined);
     get manifest(): ManifestTree | undefined;
     /**
      * Returns the manifest.
-     * @returns {ManifestTree}
+     * @returns {ManifestTree} The tree manifest
      * @memberof UmbDefaultTreeContext
      * @deprecated Use the `.manifest` property instead.
      */
@@ -66,7 +74,7 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     reloadTree: import("../../utils/index.js").UmbDebouncedFunction<() => Promise<void>>;
     /**
      * Reloads the tree
-     * @param pageNumber
+     * @param {number} pageNumber - The page number to load
      * @memberof UmbDefaultTreeContext
      * @returns {Promise<void>}
      */
@@ -74,13 +82,13 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     loadMore: () => Promise<void>;
     /**
      * Load previous items of the tree item
-     * @memberof UmbTreeItemContextBase
+     * @memberof UmbDefaultTreeContext
      * @returns {Promise<void>}
      */
     loadPrevItems: () => Promise<void>;
     /**
      * Load next items of the tree item
-     * @memberof UmbTreeItemContextBase
+     * @memberof UmbDefaultTreeContext
      * @returns {Promise<void>}
      */
     loadNextItems: () => Promise<void>;
@@ -90,6 +98,18 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     getSelectOnly(): boolean;
     setIsMenu(value: boolean): void;
     getIsMenu(): boolean;
+    /**
+     * Sets whether opening an item takes the user into it.
+     * @param {boolean} value - True when the host acts on `UmbTreeItemOpenEvent`.
+     * @memberof UmbDefaultTreeContext
+     */
+    setDrillable(value: boolean): void;
+    /**
+     * Returns whether opening an item takes the user into it.
+     * @returns {boolean} True when the host acts on `UmbTreeItemOpenEvent`.
+     * @memberof UmbDefaultTreeContext
+     */
+    getDrillable(): boolean;
     /**
      * Sets the hideTreeRoot config
      * @param {boolean} hideTreeRoot - Whether to hide the tree root
@@ -98,13 +118,13 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     setHideTreeRoot(hideTreeRoot: boolean): void;
     /**
      * Gets the hideTreeRoot config
-     * @returns {boolean}
+     * @returns {boolean} - Whether the tree root is hidden
      * @memberof UmbDefaultTreeContext
      */
     getHideTreeRoot(): boolean;
     /**
      * Sets the startNode config
-     * @param {UmbTreeStartNode} startNode
+     * @param {UmbTreeStartNode} startNode - The start node
      * @memberof UmbDefaultTreeContext
      */
     setStartNode(startNode: UmbTreeStartNode | undefined): void;
@@ -128,7 +148,7 @@ export declare class UmbDefaultTreeContext<TreeItemType extends UmbTreeItemModel
     getFoldersOnly(): boolean;
     /**
      * Updates the requestArgs config and reloads the tree.
-     * @param args
+     * @param {Partial<RequestArgsType>} args - The request args to merge in
      */
     updateAdditionalRequestArgs(args: Partial<RequestArgsType>): void;
     getAdditionalRequestArgs(): Partial<RequestArgsType> | undefined;