@umbraco-cms/backoffice 1.0.0-next.37dcc47c → 1.0.0-next.3bcfb12e

package/store.d.ts

@@ -1,8 +1,9 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import { UmbControllerHostInterface } from './controller';
-import { EntityTreeItemResponseModel } from './backend-api';
-import { UmbStoreBase as UmbStoreBase$1 } from './store';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbArrayState } from '@umbraco-cms/backoffice/observable-api';
+import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from '@umbraco-cms/backoffice/backend-api';
+import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$1 } from '@umbraco-cms/backoffice/store';
 
 interface UmbDataStoreIdentifiers {
     key?: string;
@@ -11,24 +12,6 @@ interface UmbDataStoreIdentifiers {
 interface UmbDataStore {
     readonly storeAlias: string;
 }
-interface UmbTreeStore<T> extends UmbDataStore {
-    getTreeRoot(): Observable<Array<T>>;
-    getTreeItemChildren(key: string): Observable<Array<T>>;
-    /**
-     * @description - Trash data.
-     * @param {string[]} keys
-     * @return {*}  {(Promise<void>)}
-     * @memberof UmbTreeStore
-     */
-    trash(keys: string[]): Promise<void>;
-    /**
-     * @description - Move data.
-     * @param {string[]} keys
-     * @return {*}  {(Promise<void>)}
-     * @memberof UmbTreeStore
-     */
-    move(keys: string[], destination: string): Promise<void>;
-}
 interface UmbEntityDetailStore<T> extends UmbDataStore {
     /**
      * @description - Request scaffold data by entityType and . The data is added to the store and is returned as an Observable.
@@ -36,7 +19,7 @@ interface UmbEntityDetailStore<T> extends UmbDataStore {
      * @return {*}  {T}
      * @memberof UmbEntityDetailStore
      */
-    getScaffold: (entityType: string, parentKey: string | null) => T;
+    getScaffold: (entityType: string, parentId: string | null) => T;
     /**
      * @description - Request data by key. The data is added to the store and is returned as an Observable.
      * @param {string} key
@@ -56,58 +39,116 @@ interface UmbContentStore<T> extends UmbEntityDetailStore<T> {
     save(data: T[]): Promise<void>;
 }
 
-declare class UmbStoreBase {
-    protected _host: UmbControllerHostInterface;
+interface UmbStore<T> {
+    appendItems: (items: Array<T>) => void;
+    updateItem: (unique: string, item: Partial<T>) => void;
+    removeItem: (unique: string) => void;
+}
+
+declare class UmbStoreBase<StoreItemType = any> implements UmbStore<StoreItemType> {
+    protected _host: UmbControllerHostElement;
+    protected _data: UmbArrayState<StoreItemType>;
     readonly storeAlias: string;
-    constructor(_host: UmbControllerHostInterface, storeAlias: string);
+    constructor(_host: UmbControllerHostElement, storeAlias: string, data: UmbArrayState<StoreItemType>);
+    /**
+     * Appends items to the store
+     * @param {Array<StoreItemType>} items
+     * @memberof UmbEntityTreeStore
+     */
+    appendItems(items: Array<StoreItemType>): void;
+    /**
+     * Updates an item in the store
+     * @param {string} id
+     * @param {Partial<StoreItemType>} data
+     * @memberof UmbEntityTreeStore
+     */
+    updateItem(unique: string, data: Partial<StoreItemType>): void;
+    /**
+     * Removes an item from the store
+     * @param {string} id
+     * @memberof UmbEntityTreeStore
+     */
+    removeItem(unique: string): void;
 }
 
 /**
  * @export
- * @class UmbTreeStoreBase
+ * @class UmbEntityTreeStore
  * @extends {UmbStoreBase}
- * @description - General Tree Data Store
+ * @description - Entity Tree Store
  */
-declare class UmbTreeStoreBase extends UmbStoreBase$1 {
-    #private;
+declare class UmbEntityTreeStore extends UmbStoreBase$1<EntityTreeItemResponseModel> implements UmbTreeStore$1<EntityTreeItemResponseModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
-     * Appends items to the store
-     * @param {Array<EntityTreeItemModel>} items
-     * @memberof UmbTreeStoreBase
+     * An observable to observe the root items
+     * @memberof UmbEntityTreeStore
      */
-    appendItems(items: Array<EntityTreeItemResponseModel>): void;
+    rootItems: rxjs.Observable<EntityTreeItemResponseModel[]>;
     /**
-     * Updates an item in the store
-     * @param {string} key
-     * @param {Partial<EntityTreeItemModel>} data
-     * @memberof UmbTreeStoreBase
+     * Returns an observable to observe the children of a given parent
+     * @param {(string | null)} parentId
+     * @return {*}
+     * @memberof UmbEntityTreeStore
      */
-    updateItem(key: string, data: Partial<EntityTreeItemResponseModel>): void;
+    childrenOf(parentId: string | null): rxjs.Observable<EntityTreeItemResponseModel[]>;
     /**
-     * Removes an item from the store
-     * @param {string} key
-     * @memberof UmbTreeStoreBase
+     * Returns an observable to observe the items with the given ids
+     * @param {Array<string>} ids
+     * @return {*}
+     * @memberof UmbEntityTreeStore
      */
-    removeItem(key: string): void;
+    items(ids: Array<string | null>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+}
+
+/**
+ * @export
+ * @class UmbFileSystemTreeStore
+ * @extends {UmbStoreBase}
+ * @description - File System Tree Store
+ */
+declare class UmbFileSystemTreeStore extends UmbStoreBase$1<FileSystemTreeItemPresentationModel> implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
      * An observable to observe the root items
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbFileSystemTreeStore
      */
-    rootItems: rxjs.Observable<EntityTreeItemResponseModel[]>;
+    rootItems: rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
     /**
      * Returns an observable to observe the children of a given parent
-     * @param {(string | null)} parentKey
+     * @param {(string | null)} parentPath
      * @return {*}
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbFileSystemTreeStore
      */
-    childrenOf(parentKey: string | null): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    childrenOf(parentPath: string | null): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
     /**
-     * Returns an observable to observe the items with the given keys
-     * @param {Array<string>} keys
+     * Returns an observable to observe the items with the given ids
+     * @param {Array<string>} paths
      * @return {*}
-     * @memberof UmbTreeStoreBase
+     * @memberof UmbFileSystemTreeStore
      */
-    items(keys: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    items(paths: Array<string>): rxjs.Observable<FileSystemTreeItemPresentationModel[]>;
+}
+
+type TreeItemPresentationModel = {
+    name?: string;
+    type?: string;
+    icon?: string;
+    hasChildren?: boolean;
+};
+
+type ItemResponseModelBaseModel = {
+    name?: string;
+    id?: string;
+};
+
+interface UmbTreeStore<T extends TreeItemPresentationModel = any> extends UmbStore<T> {
+    rootItems: Observable<Array<T>>;
+    childrenOf: (parentUnique: string | null) => Observable<Array<T>>;
+    items: (uniques: Array<string>) => Observable<Array<T>>;
+}
+
+interface UmbItemStore<T extends ItemResponseModelBaseModel = any> extends UmbStore<T> {
+    items: (uniques: Array<string>) => Observable<Array<T>>;
 }
 
-export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbStoreBase, UmbTreeStore, UmbTreeStoreBase };
+export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbItemStore, UmbStoreBase, UmbTreeStore };

package/tree.d.ts

@@ -0,0 +1,136 @@
+import * as _umbraco_cms_backoffice_backend_api from '@umbraco-cms/backoffice/backend-api';
+import { TreeItemPresentationModel, ProblemDetailsModel } from '@umbraco-cms/backoffice/backend-api';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbPagedData as UmbPagedData$1, UmbTreeRepository } from '@umbraco-cms/backoffice/repository';
+import { UmbTreeContextBase as UmbTreeContextBase$1 } from '@umbraco-cms/backoffice/tree';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+
+interface UmbTreeContext<TreeItemType extends TreeItemPresentationModel> {
+    readonly selectable: Observable<boolean>;
+    readonly selection: Observable<Array<string | null>>;
+    setSelectable(value: boolean): void;
+    getSelectable(): boolean;
+    setMultiple(value: boolean): void;
+    getMultiple(): boolean;
+    setSelection(value: Array<string | null>): void;
+    getSelection(): Array<string | null>;
+    select(unique: string | null): void;
+    deselect(unique: string | null): void;
+    requestChildrenOf: (parentUnique: string | null) => Promise<{
+        data?: UmbPagedData$1<TreeItemType>;
+        error?: ProblemDetailsModel;
+        asObservable?: () => Observable<TreeItemType[]>;
+    }>;
+}
+declare class UmbTreeContextBase<TreeItemType extends TreeItemPresentationModel> implements UmbTreeContext<TreeItemType> {
+    #private;
+    host: UmbControllerHostElement;
+    readonly selectable: Observable<boolean>;
+    readonly multiple: Observable<boolean>;
+    readonly selection: Observable<(string | null)[]>;
+    repository?: UmbTreeRepository<TreeItemType>;
+    selectableFilter?: (item: TreeItemType) => boolean;
+    constructor(host: UmbControllerHostElement);
+    setTreeAlias(treeAlias?: string): Promise<void>;
+    getTreeAlias(): string | undefined;
+    setSelectable(value: boolean): void;
+    getSelectable(): boolean;
+    setMultiple(value: boolean): void;
+    getMultiple(): boolean;
+    setSelection(value: Array<string | null>): void;
+    getSelection(): (string | null)[];
+    select(unique: string | null): void;
+    deselect(unique: string | null): void;
+    requestTreeRoot(): Promise<{
+        data?: UmbTreeRootEntityModel | undefined;
+        error?: ProblemDetailsModel | undefined;
+    }>;
+    requestRootItems(): Promise<{
+        data?: UmbPagedData$1<TreeItemType> | undefined;
+        error?: ProblemDetailsModel | undefined;
+        asObservable?: (() => Observable<TreeItemType[]>) | undefined;
+    }>;
+    requestChildrenOf(parentUnique: string | null): Promise<{
+        data?: UmbPagedData$1<TreeItemType> | undefined;
+        error?: ProblemDetailsModel | undefined;
+        asObservable?: (() => Observable<TreeItemType[]>) | undefined;
+    }>;
+    rootItems(): Promise<Observable<TreeItemType[]>>;
+    childrenOf(parentUnique: string | null): Promise<Observable<TreeItemType[]>>;
+}
+
+interface UmbPagedData<T> {
+    total: number;
+    items: Array<T>;
+}
+
+interface UmbTreeItemContext<TreeItemType extends TreeItemPresentationModel> {
+    host: UmbControllerHostElement;
+    unique?: string | null;
+    type?: string;
+    treeItem: Observable<TreeItemType | undefined>;
+    hasChildren: Observable<boolean>;
+    isLoading: Observable<boolean>;
+    isSelectable: Observable<boolean>;
+    isSelected: Observable<boolean>;
+    isActive: Observable<boolean>;
+    hasActions: Observable<boolean>;
+    path: Observable<string>;
+    setTreeItem(treeItem: TreeItemType | undefined): void;
+    requestChildren(): Promise<{
+        data?: UmbPagedData$1<TreeItemType> | undefined;
+        error?: ProblemDetailsModel | undefined;
+        asObservable?: () => Observable<TreeItemType[]>;
+    }>;
+    toggleContextMenu(): void;
+    select(): void;
+    deselect(): void;
+    constructPath(pathname: string, entityType: string, unique: string): string;
+}
+
+type UmbTreeItemUniqueFunction<TreeItemType extends TreeItemPresentationModel> = (x: TreeItemType) => string | null | undefined;
+declare class UmbTreeItemContextBase<TreeItemType extends TreeItemPresentationModel> implements UmbTreeItemContext<TreeItemType> {
+    #private;
+    host: UmbControllerHostElement;
+    unique?: string | null;
+    type?: string;
+    treeItem: rxjs.Observable<TreeItemType | undefined>;
+    hasChildren: rxjs.Observable<boolean>;
+    isLoading: rxjs.Observable<boolean>;
+    isSelectable: rxjs.Observable<boolean>;
+    isSelected: rxjs.Observable<boolean>;
+    isActive: rxjs.Observable<boolean>;
+    hasActions: rxjs.Observable<boolean>;
+    path: rxjs.Observable<string>;
+    treeContext?: UmbTreeContextBase$1<TreeItemType>;
+    constructor(host: UmbControllerHostElement, getUniqueFunction: UmbTreeItemUniqueFunction<TreeItemType>);
+    setTreeItem(treeItem: TreeItemType | undefined): void;
+    requestChildren(): Promise<{
+        data?: UmbPagedData<TreeItemType> | undefined;
+        error?: _umbraco_cms_backoffice_backend_api.ProblemDetailsModel | undefined;
+        asObservable?: (() => rxjs.Observable<TreeItemType[]>) | undefined;
+    }>;
+    toggleContextMenu(): void;
+    select(): void;
+    deselect(): void;
+    getTreeItem(): TreeItemType | undefined;
+    constructPath(pathname: string, entityType: string, unique: string | null): string;
+}
+declare const UMB_TREE_ITEM_CONTEXT_TOKEN: UmbContextToken<UmbTreeItemContext<any>>;
+
+interface UmbTreeRootModel {
+    type: string;
+    name: string;
+    hasChildren: boolean;
+    icon?: string;
+}
+interface UmbTreeRootEntityModel extends UmbTreeRootModel {
+    id: string | null;
+}
+interface UmbTreeRootFileSystemModel extends UmbTreeRootModel {
+    path: string | null;
+}
+
+export { UMB_TREE_ITEM_CONTEXT_TOKEN, UmbTreeContext, UmbTreeContextBase, UmbTreeItemContext, UmbTreeItemContextBase, UmbTreeItemUniqueFunction, UmbTreeRootEntityModel, UmbTreeRootFileSystemModel, UmbTreeRootModel };