@umbraco-cms/backoffice 14.0.0--preview004-9b30fd08 → 14.0.0--preview004-a38abfe4

package/dist-cms/packages/settings/relation-types/entities.d.ts

@@ -0,0 +1,2 @@
+export declare const UMB_RELATION_TYPE_ROOT_ENTITY_TYPE = "relation-type-root";
+export declare const UMB_RELATION_TYPE_ENTITY_TYPE = "relation-type";

package/dist-cms/packages/settings/relation-types/entities.js

@@ -0,0 +1,2 @@
+export const UMB_RELATION_TYPE_ROOT_ENTITY_TYPE = 'relation-type-root';
+export const UMB_RELATION_TYPE_ENTITY_TYPE = 'relation-type';

package/dist-cms/packages/settings/relation-types/menu-item/manifests.js

@@ -1,3 +1,4 @@
+import { UMB_RELATION_TYPE_TREE_ALIAS } from '../tree/index.js';
 const menuItem = {
     type: 'menuItem',
     kind: 'tree',
@@ -5,7 +6,7 @@ const menuItem = {
     name: 'Relation Types Menu Item',
     weight: 500,
     meta: {
-        treeAlias: 'Umb.Tree.RelationTypes',
+        treeAlias: UMB_RELATION_TYPE_TREE_ALIAS,
         label: 'Relation Types',
         icon: 'icon-folder',
         menus: ['Umb.Menu.Settings'],

package/dist-cms/packages/settings/relation-types/repository/manifests.d.ts

@@ -1,5 +1,4 @@
-import { ManifestStore, ManifestTreeStore, ManifestRepository } from '../../../core/extension-registry/index.js';
+import { ManifestStore, ManifestRepository } from '../../../core/extension-registry/index.js';
 export declare const RELATION_TYPE_REPOSITORY_ALIAS = "Umb.Repository.RelationType";
 export declare const RELATION_TYPE_STORE_ALIAS = "Umb.Store.RelationType";
-export declare const RELATION_TYPE_TREE_STORE_ALIAS = "Umb.Store.RelationTypeTree";
-export declare const manifests: (ManifestStore | ManifestTreeStore | ManifestRepository<import("../../../../libs/extension-api/types.js").UmbApi>)[];
+export declare const manifests: (ManifestStore | ManifestRepository<import("../../../../libs/extension-api/types.js").UmbApi>)[];

package/dist-cms/packages/settings/relation-types/repository/manifests.js

@@ -1,6 +1,5 @@
 import { UmbRelationTypeRepository } from '../repository/relation-type.repository.js';
 import { UmbRelationTypeStore } from './relation-type.store.js';
-import { UmbRelationTypeTreeStore } from './relation-type.tree.store.js';
 export const RELATION_TYPE_REPOSITORY_ALIAS = 'Umb.Repository.RelationType';
 const repository = {
     type: 'repository',
@@ -9,17 +8,10 @@ const repository = {
     api: UmbRelationTypeRepository,
 };
 export const RELATION_TYPE_STORE_ALIAS = 'Umb.Store.RelationType';
-export const RELATION_TYPE_TREE_STORE_ALIAS = 'Umb.Store.RelationTypeTree';
 const store = {
     type: 'store',
     alias: RELATION_TYPE_STORE_ALIAS,
     name: 'Relation Type Store',
     api: UmbRelationTypeStore,
 };
-const treeStore = {
-    type: 'treeStore',
-    alias: RELATION_TYPE_TREE_STORE_ALIAS,
-    name: 'Relation Type Tree Store',
-    api: UmbRelationTypeTreeStore,
-};
-export const manifests = [repository, store, treeStore];
+export const manifests = [repository, store];

package/dist-cms/packages/settings/relation-types/repository/relation-type.repository.d.ts

@@ -1,40 +1,10 @@
 import { UmbBaseController, type UmbControllerHost } from '../../../../libs/controller-api/index.js';
 import { CreateRelationTypeRequestModel, RelationTypeResponseModel, UpdateRelationTypeRequestModel } from '../../../../external/backend-api/index.js';
 import { UmbDetailRepository } from '../../../core/repository/index.js';
-import { UmbTreeRepository } from '../../../core/tree/index.js';
 import { UmbApi } from '../../../../libs/extension-api/index.js';
-export declare class UmbRelationTypeRepository extends UmbBaseController implements UmbTreeRepository<any>, UmbDetailRepository<CreateRelationTypeRequestModel, any, UpdateRelationTypeRequestModel, RelationTypeResponseModel>, UmbApi {
+export declare class UmbRelationTypeRepository extends UmbBaseController implements UmbDetailRepository<CreateRelationTypeRequestModel, any, UpdateRelationTypeRequestModel, RelationTypeResponseModel>, UmbApi {
     #private;
     constructor(host: UmbControllerHost);
-    requestTreeRoot(): Promise<{
-        data: {
-            id: null;
-            type: string;
-            name: string;
-            icon: string;
-            hasChildren: boolean;
-        };
-    }>;
-    requestRootTreeItems(): Promise<{
-        data: import("../../../../external/backend-api/index.js").PagedEntityTreeItemResponseModel | undefined;
-        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>;
-    }>;
-    requestTreeItemsOf(parentId: string | null): Promise<{
-        data: undefined;
-        error: {
-            title: string;
-            message: string;
-        };
-    }>;
-    requestItemsLegacy(ids: Array<string>): Promise<{
-        data: import("../../../../external/backend-api/index.js").ItemResponseModelBaseModel[] | undefined;
-        error: import("../../../../external/backend-api/index.js").ApiError | import("../../../../external/backend-api/index.js").CancelError | undefined;
-        asObservable: () => import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>;
-    }>;
-    rootTreeItems(): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
-    treeItemsOf(parentId: string | null): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
-    itemsLegacy(ids: Array<string>): Promise<import("rxjs").Observable<import("../../../../external/backend-api/index.js").EntityTreeItemResponseModel[]>>;
     createScaffold(parentId: string | null): Promise<{
         data: RelationTypeResponseModel;
     }>;

package/dist-cms/packages/settings/relation-types/repository/relation-type.repository.js

@@ -1,12 +1,10 @@
-import { UMB_RELATION_TYPE_TREE_STORE_CONTEXT_TOKEN } from './relation-type.tree.store.js';
+import { UMB_RELATION_TYPE_TREE_STORE_CONTEXT } from '../tree/index.js';
 import { UmbRelationTypeServerDataSource } from './sources/relation-type.server.data.js';
 import { UMB_RELATION_TYPE_STORE_CONTEXT_TOKEN } from './relation-type.store.js';
-import { UmbRelationTypeTreeServerDataSource } from './sources/relation-type.tree.server.data.js';
 import { UmbBaseController } from '../../../../libs/controller-api/index.js';
 import { UMB_NOTIFICATION_CONTEXT_TOKEN } from '../../../core/notification/index.js';
 export class UmbRelationTypeRepository extends UmbBaseController {
     #init;
-    #treeSource;
     #treeStore;
     #detailDataSource;
     #detailStore;
@@ -14,10 +12,9 @@ export class UmbRelationTypeRepository extends UmbBaseController {
     constructor(host) {
         super(host);
         // TODO: figure out how spin up get the correct data source
-        this.#treeSource = new UmbRelationTypeTreeServerDataSource(this._host);
         this.#detailDataSource = new UmbRelationTypeServerDataSource(this._host);
         this.#init = Promise.all([
-            this.consumeContext(UMB_RELATION_TYPE_TREE_STORE_CONTEXT_TOKEN, (instance) => {
+            this.consumeContext(UMB_RELATION_TYPE_TREE_STORE_CONTEXT, (instance) => {
                 this.#treeStore = instance;
             }).asPromise(),
             this.consumeContext(UMB_RELATION_TYPE_STORE_CONTEXT_TOKEN, (instance) => {
@@ -30,49 +27,6 @@ export class UmbRelationTypeRepository extends UmbBaseController {
     }
     // TODO: Trash
     // TODO: Move
-    // TREE:
-    async requestTreeRoot() {
-        await this.#init;
-        const data = {
-            id: null,
-            type: 'relation-type-root',
-            name: 'Relation Types',
-            icon: 'icon-folder',
-            hasChildren: true,
-        };
-        return { data };
-    }
-    async requestRootTreeItems() {
-        await this.#init;
-        const { data, error } = await this.#treeSource.getRootItems();
-        if (data) {
-            this.#treeStore?.appendItems(data.items);
-        }
-        return { data, error, asObservable: () => this.#treeStore.rootItems };
-    }
-    //TODO RelationTypes can't have children. But this method is required by the tree interface.
-    async requestTreeItemsOf(parentId) {
-        return { data: undefined, error: { title: 'Not implemented', message: 'Not implemented' } };
-    }
-    async requestItemsLegacy(ids) {
-        if (!ids)
-            throw new Error('Ids are missing');
-        await this.#init;
-        const { data, error } = await this.#treeSource.getItems(ids);
-        return { data, error, asObservable: () => this.#treeStore.items(ids) };
-    }
-    async rootTreeItems() {
-        await this.#init;
-        return this.#treeStore.rootItems;
-    }
-    async treeItemsOf(parentId) {
-        await this.#init;
-        return this.#treeStore.childrenOf(parentId);
-    }
-    async itemsLegacy(ids) {
-        await this.#init;
-        return this.#treeStore.items(ids);
-    }
     // DETAILS:
     async createScaffold(parentId) {
         if (parentId === undefined)

package/dist-cms/packages/settings/relation-types/tree/index.d.ts

@@ -0,0 +1,5 @@
+export { UmbRelationTypeTreeRepository } from './relation-type-tree.repository.js';
+export { UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS, UMB_RELATION_TYPE_TREE_STORE_ALIAS, UMB_RELATION_TYPE_TREE_ALIAS, } from './manifests.js';
+export { UMB_RELATION_TYPE_TREE_STORE_CONTEXT } from './relation-type-tree.store.js';
+export { type UmbRelationTypeTreeStore } from './relation-type-tree.store.js';
+export * from './types.js';

package/dist-cms/packages/settings/relation-types/tree/index.js

@@ -0,0 +1,4 @@
+export { UmbRelationTypeTreeRepository } from './relation-type-tree.repository.js';
+export { UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS, UMB_RELATION_TYPE_TREE_STORE_ALIAS, UMB_RELATION_TYPE_TREE_ALIAS, } from './manifests.js';
+export { UMB_RELATION_TYPE_TREE_STORE_CONTEXT } from './relation-type-tree.store.js';
+export * from './types.js';

package/dist-cms/packages/settings/relation-types/tree/manifests.d.ts

@@ -1,2 +1,5 @@
-import type { ManifestTree, ManifestTreeItem } from '../../../core/extension-registry/index.js';
-export declare const manifests: (ManifestTree | ManifestTreeItem)[];
+import type { ManifestRepository, ManifestTree, ManifestTreeItem, ManifestTreeStore } from '../../../core/extension-registry/index.js';
+export declare const UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS = "Umb.Repository.RelationType.Tree";
+export declare const UMB_RELATION_TYPE_TREE_STORE_ALIAS = "Umb.Store.RelationType.Tree";
+export declare const UMB_RELATION_TYPE_TREE_ALIAS = "Umb.Tree.RelationType";
+export declare const manifests: (ManifestTree | ManifestTreeItem | ManifestTreeStore | ManifestRepository<import("../../../../libs/extension-api/types.js").UmbApi>)[];

package/dist-cms/packages/settings/relation-types/tree/manifests.js

@@ -1,19 +1,36 @@
-import { RELATION_TYPE_REPOSITORY_ALIAS } from '../repository/manifests.js';
+import { UMB_RELATION_TYPE_ENTITY_TYPE, UMB_RELATION_TYPE_ROOT_ENTITY_TYPE } from '../entities.js';
+import { UmbRelationTypeTreeRepository } from './relation-type-tree.repository.js';
+import { UmbRelationTypeTreeStore } from './relation-type-tree.store.js';
+export const UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS = 'Umb.Repository.RelationType.Tree';
+export const UMB_RELATION_TYPE_TREE_STORE_ALIAS = 'Umb.Store.RelationType.Tree';
+export const UMB_RELATION_TYPE_TREE_ALIAS = 'Umb.Tree.RelationType';
+const treeRepository = {
+    type: 'repository',
+    alias: UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS,
+    name: 'Relation Type Tree Repository',
+    api: UmbRelationTypeTreeRepository,
+};
+const treeStore = {
+    type: 'treeStore',
+    alias: UMB_RELATION_TYPE_TREE_STORE_ALIAS,
+    name: 'Relation Type Tree Store',
+    api: UmbRelationTypeTreeStore,
+};
 const tree = {
     type: 'tree',
-    alias: 'Umb.Tree.RelationTypes',
-    name: 'Relation Types Tree',
+    alias: UMB_RELATION_TYPE_TREE_ALIAS,
+    name: 'Relation Type Tree',
     meta: {
-        repositoryAlias: RELATION_TYPE_REPOSITORY_ALIAS,
+        repositoryAlias: UMB_RELATION_TYPE_TREE_REPOSITORY_ALIAS,
     },
 };
 const treeItem = {
     type: 'treeItem',
     kind: 'entity',
     alias: 'Umb.TreeItem.RelationType',
-    name: 'Relation Type Tree Item',
+    name: 'RelationType Tree Item',
     meta: {
-        entityTypes: ['relation-type-root', 'relation-type'],
+        entityTypes: [UMB_RELATION_TYPE_ROOT_ENTITY_TYPE, UMB_RELATION_TYPE_ENTITY_TYPE],
     },
 };
-export const manifests = [tree, treeItem];
+export const manifests = [treeRepository, treeStore, tree, treeItem];

package/dist-cms/packages/settings/relation-types/tree/relation-type-tree.repository.d.ts

@@ -0,0 +1,16 @@
+import { UmbRelationTypeTreeItemModel, UmbRelationTypeTreeRootModel } from './types.js';
+import { UmbTreeRepositoryBase } from '../../../core/tree/index.js';
+import { type UmbControllerHost } from '../../../../libs/controller-api/index.js';
+import { UmbApi } from '../../../../libs/extension-api/index.js';
+export declare class UmbRelationTypeTreeRepository extends UmbTreeRepositoryBase<UmbRelationTypeTreeItemModel, UmbRelationTypeTreeRootModel> implements UmbApi {
+    constructor(host: UmbControllerHost);
+    requestTreeRoot(): Promise<{
+        data: {
+            id: null;
+            type: string;
+            name: string;
+            icon: string;
+            hasChildren: boolean;
+        };
+    }>;
+}

package/dist-cms/packages/settings/relation-types/tree/relation-type-tree.repository.js

@@ -0,0 +1,19 @@
+import { UMB_RELATION_TYPE_ROOT_ENTITY_TYPE } from '../entities.js';
+import { UmbRelationTypeTreeServerDataSource } from './relation-type-tree.server.data-source.js';
+import { UMB_RELATION_TYPE_TREE_STORE_CONTEXT } from './relation-type-tree.store.js';
+import { UmbTreeRepositoryBase } from '../../../core/tree/index.js';
+export class UmbRelationTypeTreeRepository extends UmbTreeRepositoryBase {
+    constructor(host) {
+        super(host, UmbRelationTypeTreeServerDataSource, UMB_RELATION_TYPE_TREE_STORE_CONTEXT);
+    }
+    async requestTreeRoot() {
+        const data = {
+            id: null,
+            type: UMB_RELATION_TYPE_ROOT_ENTITY_TYPE,
+            name: 'Relation Types',
+            icon: 'icon-trash',
+            hasChildren: true,
+        };
+        return { data };
+    }
+}

package/dist-cms/packages/settings/relation-types/tree/relation-type-tree.server.data-source.d.ts

@@ -0,0 +1,32 @@
+import type { UmbTreeDataSource } from '../../../core/tree/index.js';
+import { EntityTreeItemResponseModel } from '../../../../external/backend-api/index.js';
+import type { UmbControllerHost } from '../../../../libs/controller-api/index.js';
+/**
+ * A data source for the Relation Type tree that fetches data from the server
+ * @export
+ * @class UmbRelationTypeTreeServerDataSource
+ * @implements {UmbTreeDataSource}
+ */
+export declare class UmbRelationTypeTreeServerDataSource implements UmbTreeDataSource<EntityTreeItemResponseModel> {
+    #private;
+    /**
+     * Creates an instance of UmbRelationTypeTreeServerDataSource.
+     * @param {UmbControllerHost} host
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    constructor(host: UmbControllerHost);
+    /**
+     * Fetches the root items for the tree from the server
+     * @return {*}
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    getRootItems(): Promise<import("../../../core/repository/index.js").DataSourceResponse<import("../../../../external/backend-api/index.js").PagedEntityTreeItemResponseModel>>;
+    /**
+     * Fetches the children of a given parent id from the server
+     * @param {(string)} parentId
+     * @return {*}
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    getChildrenOf(parentId: string | null): Promise<any>;
+    getItems(unique: Array<string>): Promise<any>;
+}

package/dist-cms/packages/settings/relation-types/tree/relation-type-tree.server.data-source.js

@@ -0,0 +1,47 @@
+import { RelationTypeResource } from '../../../../external/backend-api/index.js';
+import { tryExecuteAndNotify } from '../../../../shared/resources/index.js';
+/**
+ * A data source for the Relation Type tree that fetches data from the server
+ * @export
+ * @class UmbRelationTypeTreeServerDataSource
+ * @implements {UmbTreeDataSource}
+ */
+export class UmbRelationTypeTreeServerDataSource {
+    #host;
+    /**
+     * Creates an instance of UmbRelationTypeTreeServerDataSource.
+     * @param {UmbControllerHost} host
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    constructor(host) {
+        this.#host = host;
+    }
+    /**
+     * Fetches the root items for the tree from the server
+     * @return {*}
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    async getRootItems() {
+        return tryExecuteAndNotify(this.#host, RelationTypeResource.getTreeRelationTypeRoot({}));
+    }
+    /**
+     * Fetches the children of a given parent id from the server
+     * @param {(string)} parentId
+     * @return {*}
+     * @memberof UmbRelationTypeTreeServerDataSource
+     */
+    async getChildrenOf(parentId) {
+        /* TODO: should we make getRootItems() internal
+        so it only is a server concern that there are two endpoints? */
+        if (parentId === null) {
+            return this.getRootItems();
+        }
+        else {
+            throw new Error('Not supported for the relation type tree');
+        }
+    }
+    // TODO: remove when interface is cleaned up
+    async getItems(unique) {
+        throw new Error('Dot not use this method. Use the item source instead');
+    }
+}

package/dist-cms/packages/settings/relation-types/{repository/relation-type.tree.store.d.ts → tree/relation-type-tree.store.d.ts}

@@ -5,7 +5,7 @@ import { UmbEntityTreeStore } from '../../../core/tree/index.js';
  * @export
  * @class UmbRelationTypeTreeStore
  * @extends {UmbStoreBase}
- * @description - Tree Data Store for relation-types
+ * @description - Tree Data Store for Relation Type Items
  */
 export declare class UmbRelationTypeTreeStore extends UmbEntityTreeStore {
     /**
@@ -15,4 +15,4 @@ export declare class UmbRelationTypeTreeStore extends UmbEntityTreeStore {
      */
     constructor(host: UmbControllerHostElement);
 }
-export declare const UMB_RELATION_TYPE_TREE_STORE_CONTEXT_TOKEN: UmbContextToken<UmbRelationTypeTreeStore, UmbRelationTypeTreeStore>;
+export declare const UMB_RELATION_TYPE_TREE_STORE_CONTEXT: UmbContextToken<UmbRelationTypeTreeStore, UmbRelationTypeTreeStore>;

package/dist-cms/packages/settings/relation-types/{repository/relation-type.tree.store.js → tree/relation-type-tree.store.js}

@@ -4,9 +4,8 @@ import { UmbEntityTreeStore } from '../../../core/tree/index.js';
  * @export
  * @class UmbRelationTypeTreeStore
  * @extends {UmbStoreBase}
- * @description - Tree Data Store for relation-types
+ * @description - Tree Data Store for Relation Type Items
  */
-// TODO: consider if tree store could be turned into a general EntityTreeStore class?
 export class UmbRelationTypeTreeStore extends UmbEntityTreeStore {
     /**
      * Creates an instance of UmbRelationTypeTreeStore.
@@ -14,7 +13,7 @@ export class UmbRelationTypeTreeStore extends UmbEntityTreeStore {
      * @memberof UmbRelationTypeTreeStore
      */
     constructor(host) {
-        super(host, UMB_RELATION_TYPE_TREE_STORE_CONTEXT_TOKEN.toString());
+        super(host, UMB_RELATION_TYPE_TREE_STORE_CONTEXT.toString());
     }
 }
-export const UMB_RELATION_TYPE_TREE_STORE_CONTEXT_TOKEN = new UmbContextToken('UmbRelationTypeTreeStore');
+export const UMB_RELATION_TYPE_TREE_STORE_CONTEXT = new UmbContextToken('UmbRelationTypeTreeStore');

package/dist-cms/packages/settings/relation-types/tree/types.d.ts

@@ -0,0 +1,4 @@
+import { EntityTreeItemResponseModel } from '../../../../external/backend-api/index.js';
+import type { UmbEntityTreeItemModel, UmbEntityTreeRootModel } from '../../../core/tree/index.js';
+export type UmbRelationTypeTreeItemModel = EntityTreeItemResponseModel & UmbEntityTreeItemModel;
+export type UmbRelationTypeTreeRootModel = EntityTreeItemResponseModel & UmbEntityTreeRootModel;