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

package/router.d.ts

@@ -1,6 +1,6 @@
-import { UmbContextToken } from './context-api';
-import { UmbControllerHostElement } from './controller';
-import { UmbModalRouteRegistration } from './modal';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbModalRouteRegistration } from '@umbraco-cms/backoffice/modal';
 
 interface IRouterSlot<D = any, P = any> extends HTMLElement {
     readonly route: IRoute<D> | null;
@@ -22,7 +22,6 @@ type IRoutingInfo<D = any, P = any> = {
 };
 type CustomResolver<D = any, P = any> = ((info: IRoutingInfo<D>) => boolean | void | Promise<boolean> | Promise<void>);
 type Guard<D = any, P = any> = ((info: IRoutingInfo<D, P>) => boolean | Promise<boolean>);
-type Cancel = (() => boolean);
 type PageComponent = HTMLElement | undefined;
 type ModuleResolver = Promise<{
     default: any;
@@ -99,10 +98,6 @@ type Query = {
     [key: string]: string;
 };
 type EventListenerSubscription = (() => void);
-/**
- * RouterSlot related events.
- */
-type RouterSlotEvent = "changestate";
 /**
  * History related events.
  */
@@ -355,13 +350,6 @@ declare function toQueryString(query: Query): string;
  */
 declare function ensureAnchorHistory(): void;
 
-interface UmbRouteLocation {
-    name?: string;
-    params: {
-        [key: string]: string;
-    };
-}
-
 declare class UmbRouteContext {
     #private;
     private _onGotModals;
@@ -377,4 +365,4 @@ declare function generateRoutePathBuilder(path: string): (params: {
     [key: string]: string | number;
 }) => string;
 
-export { Cancel, ChangeStateEvent, Class, Component, CustomResolver, EventListenerSubscription, GlobalRouterEvent, Guard, IComponentRoute, IPathFragments, IRedirectRoute, IResolverRoute, IRoute, IRouteBase, IRouteMatch, IRouterSlot, IRoutingInfo, ISlashOptions, ModuleResolver, NavigationCancelEvent, NavigationEndEvent, NavigationErrorEvent, NavigationStartEvent, NavigationSuccessEvent, PageComponent, Params, PathFragment, PathMatch, PushStateEvent, Query, ReplaceStateEvent, RouterSlotEvent, RouterTree, Setup, UMB_ROUTE_CONTEXT_TOKEN, IRoute as UmbRoute, UmbRouteContext, UmbRouteLocation, WillChangeStateEvent, addListener, attachCallback, basePath, constructAbsolutePath, constructPathWithBasePath, dispatchGlobalRouterEvent, dispatchRouteChangeEvent, ensureAnchorHistory, ensureHistoryEvents, ensureSlash, generateRoutePathBuilder, getFragments, handleRedirect, historyPatches, isPathActive, isRedirectRoute, isResolverRoute, matchRoute, matchRoutes, path, pathWithoutBasePath, query, queryParentRoots, queryParentRouterSlot, queryString, removeListeners, resolvePageComponent, saveNativeFunction, shouldNavigate, slashify, stripSlash, stripStart, toQuery, toQueryString, traverseRouterTree };
+export { Guard, IComponentRoute, IRedirectRoute, IResolverRoute, IRoutingInfo, PageComponent, Params, Query, UMB_ROUTE_CONTEXT_TOKEN, IRoute as UmbRoute, UmbRouteContext, addListener, attachCallback, basePath, constructAbsolutePath, constructPathWithBasePath, dispatchGlobalRouterEvent, dispatchRouteChangeEvent, ensureAnchorHistory, ensureHistoryEvents, ensureSlash, generateRoutePathBuilder, getFragments, handleRedirect, historyPatches, isPathActive, isRedirectRoute, isResolverRoute, matchRoute, matchRoutes, path, pathWithoutBasePath, query, queryParentRoots, queryParentRouterSlot, queryString, removeListeners, resolvePageComponent, saveNativeFunction, shouldNavigate, slashify, stripSlash, stripStart, toQuery, toQueryString, traverseRouterTree };

package/section.d.ts

@@ -0,0 +1,29 @@
+import * as rxjs from 'rxjs';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { ManifestSection } from '@umbraco-cms/backoffice/extensions-registry';
+
+declare class UmbSectionSidebarContext {
+    #private;
+    contextMenuIsOpen: rxjs.Observable<boolean>;
+    entityType: rxjs.Observable<string | undefined>;
+    unique: rxjs.Observable<string | null | undefined>;
+    headline: rxjs.Observable<string | undefined>;
+    constructor(host: UmbControllerHostElement);
+    toggleContextMenu(entityType: string, unique: string | null | undefined, headline: string): void;
+    openContextMenu(entityType: string, unique: string | null | undefined, headline: string): void;
+    closeContextMenu(): void;
+}
+declare const UMB_SECTION_SIDEBAR_CONTEXT_TOKEN: UmbContextToken<UmbSectionSidebarContext>;
+
+declare class UmbSectionContext {
+    #private;
+    readonly alias: rxjs.Observable<string | undefined>;
+    readonly pathname: rxjs.Observable<string | undefined>;
+    readonly label: rxjs.Observable<string | undefined>;
+    constructor(manifest: ManifestSection);
+    setManifest(manifest?: ManifestSection): void;
+}
+declare const UMB_SECTION_CONTEXT_TOKEN: UmbContextToken<UmbSectionContext>;
+
+export { UMB_SECTION_CONTEXT_TOKEN, UMB_SECTION_SIDEBAR_CONTEXT_TOKEN, UmbSectionContext, UmbSectionSidebarContext };

package/sorter.d.ts

@@ -0,0 +1,103 @@
+import { UmbControllerInterface, UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+
+type INTERNAL_UmbSorterConfig<T> = {
+    compareElementToModel: (el: HTMLElement, modelEntry: T) => boolean;
+    querySelectModelToElement: (container: HTMLElement, modelEntry: T) => HTMLElement | null;
+    identifier: string;
+    itemSelector: string;
+    disabledItemSelector?: string;
+    containerSelector: string;
+    ignorerSelector: string;
+    placeholderClass: string;
+    draggableSelector?: string;
+    boundarySelector?: string;
+    dataTransferResolver?: (dataTransfer: DataTransfer | null, currentItem: T) => void;
+    onStart?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onChange?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onContainerChange?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onEnd?: (argument: {
+        item: T;
+        element: HTMLElement;
+    }) => void;
+    onSync?: (argument: {
+        item: T;
+        fromController: UmbSorterController<T>;
+        toController: UmbSorterController<T>;
+    }) => void;
+    itemHasNestedContainersResolver?: (element: HTMLElement) => boolean;
+    onDisallowed?: () => void;
+    onAllowed?: () => void;
+    onRequestDrop?: (argument: {
+        item: T;
+    }) => boolean | void;
+    resolveVerticalDirection?: (argument: {
+        containerElement: Element;
+        containerRect: DOMRect;
+        item: T;
+        element: HTMLElement;
+        elementRect: DOMRect;
+        relatedElement: HTMLElement;
+        relatedRect: DOMRect;
+        placeholderIsInThisRow: boolean;
+        horizontalPlaceAfter: boolean;
+    }) => void;
+    performItemInsert?: (argument: {
+        item: T;
+        newIndex: number;
+    }) => Promise<boolean> | boolean;
+    performItemRemove?: (argument: {
+        item: T;
+    }) => Promise<boolean> | boolean;
+};
+type UmbSorterConfig<T> = Omit<INTERNAL_UmbSorterConfig<T>, 'placeholderClass' | 'ignorerSelector' | 'containerSelector'> & Partial<Pick<INTERNAL_UmbSorterConfig<T>, 'placeholderClass' | 'ignorerSelector' | 'containerSelector'>>;
+/**
+ * @export
+ * @class UmbSorterController
+ * @implements {UmbControllerInterface}
+ * @description This controller can make user able to sort items.
+ */
+declare class UmbSorterController<T> implements UmbControllerInterface {
+    #private;
+    private _lastIndicationContainerVM;
+    get unique(): string;
+    constructor(host: UmbControllerHostElement, config: UmbSorterConfig<T>);
+    setModel(model: Array<T>): void;
+    hostConnected(): void;
+    private _onFirstRender;
+    hostDisconnected(): void;
+    setupItem(element: HTMLElement): void;
+    destroyItem(element: HTMLElement): void;
+    handleDragStart: (event: DragEvent) => void;
+    handleDragEnd: () => Promise<void>;
+    handleDragMove: (event: DragEvent) => void;
+    moveCurrentElement: () => void;
+    move(orderedContainerElements: Array<Element>, newElIndex: number): void;
+    /** Management methods: */
+    getItemOfElement(element: HTMLElement): T | null | undefined;
+    removeItem(item: T): Promise<boolean | T | null>;
+    hasOtherItemsThan(item: T): boolean;
+    sync(element: HTMLElement, fromVm: UmbSorterController<T>): Promise<boolean>;
+    updateAllowIndication(contextVM: UmbSorterController<T>, item: T): boolean;
+    removeAllowIndication(): void;
+    private autoScrollX;
+    private autoScrollY;
+    private handleAutoScroll;
+    private _performAutoScroll;
+    private stopAutoScroll;
+    notifySync(data: any): void;
+    notifyDisallowed(): void;
+    notifyAllowed(): void;
+    notifyRequestDrop(data: any): boolean;
+    destroy(): void;
+}
+
+export { UmbSorterConfig, UmbSorterController };

package/store.d.ts

@@ -1,8 +1,9 @@
 import * as rxjs from 'rxjs';
 import { Observable } from 'rxjs';
-import { UmbControllerHostElement } from './controller';
-import { EntityTreeItemResponseModel, FileSystemTreeItemPresentationModel } from './backend-api';
-import { UmbStoreBase as UmbStoreBase$1, UmbTreeStore as UmbTreeStore$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;
@@ -38,39 +39,46 @@ interface UmbContentStore<T> extends UmbEntityDetailStore<T> {
     save(data: T[]): Promise<void>;
 }
 
-declare class UmbStoreBase {
-    protected _host: UmbControllerHostElement;
-    readonly storeAlias: string;
-    constructor(_host: UmbControllerHostElement, storeAlias: string);
+interface UmbStore<T> {
+    appendItems: (items: Array<T>) => void;
+    updateItem: (unique: string, item: Partial<T>) => void;
+    removeItem: (unique: string) => void;
 }
 
-/**
- * @export
- * @class UmbEntityTreeStore
- * @extends {UmbStoreBase}
- * @description - General Tree Data Store
- */
-declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<EntityTreeItemResponseModel> {
-    #private;
+declare class UmbStoreBase<StoreItemType = any> implements UmbStore<StoreItemType> {
+    protected _host: UmbControllerHostElement;
+    protected _data: UmbArrayState<StoreItemType>;
+    readonly storeAlias: string;
+    constructor(_host: UmbControllerHostElement, storeAlias: string, data: UmbArrayState<StoreItemType>);
     /**
      * Appends items to the store
-     * @param {Array<EntityTreeItemResponseModel>} items
+     * @param {Array<StoreItemType>} items
      * @memberof UmbEntityTreeStore
      */
-    appendItems(items: Array<EntityTreeItemResponseModel>): void;
+    appendItems(items: Array<StoreItemType>): void;
     /**
      * Updates an item in the store
      * @param {string} id
-     * @param {Partial<EntityTreeItemResponseModel>} data
+     * @param {Partial<StoreItemType>} data
      * @memberof UmbEntityTreeStore
      */
-    updateItem(id: string, data: Partial<EntityTreeItemResponseModel>): void;
+    updateItem(unique: string, data: Partial<StoreItemType>): void;
     /**
      * Removes an item from the store
      * @param {string} id
      * @memberof UmbEntityTreeStore
      */
-    removeItem(id: string): void;
+    removeItem(unique: string): void;
+}
+
+/**
+ * @export
+ * @class UmbEntityTreeStore
+ * @extends {UmbStoreBase}
+ * @description - Entity Tree Store
+ */
+declare class UmbEntityTreeStore extends UmbStoreBase$1<EntityTreeItemResponseModel> implements UmbTreeStore$1<EntityTreeItemResponseModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
      * An observable to observe the root items
      * @memberof UmbEntityTreeStore
@@ -89,36 +97,17 @@ declare class UmbEntityTreeStore extends UmbStoreBase$1 implements UmbTreeStore$
      * @return {*}
      * @memberof UmbEntityTreeStore
      */
-    items(ids: Array<string>): rxjs.Observable<EntityTreeItemResponseModel[]>;
+    items(ids: Array<string | null>): rxjs.Observable<EntityTreeItemResponseModel[]>;
 }
 
 /**
  * @export
  * @class UmbFileSystemTreeStore
  * @extends {UmbStoreBase}
- * @description - General Tree Data Store
+ * @description - File System Tree Store
  */
-declare class UmbFileSystemTreeStore extends UmbStoreBase$1 implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
-    #private;
-    /**
-     * Appends items to the store
-     * @param {Array<FileSystemTreeItemPresentationModel>} items
-     * @memberof UmbFileSystemTreeStore
-     */
-    appendItems(items: Array<FileSystemTreeItemPresentationModel>): void;
-    /**
-     * Updates an item in the store
-     * @param {string} path
-     * @param {Partial<FileSystemTreeItemPresentationModel>} data
-     * @memberof UmbFileSystemTreeStore
-     */
-    updateItem(path: string, data: Partial<FileSystemTreeItemPresentationModel>): void;
-    /**
-     * Removes an item from the store
-     * @param {string} path
-     * @memberof UmbFileSystemTreeStore
-     */
-    removeItem(path: string): void;
+declare class UmbFileSystemTreeStore extends UmbStoreBase$1<FileSystemTreeItemPresentationModel> implements UmbTreeStore$1<FileSystemTreeItemPresentationModel> {
+    constructor(host: UmbControllerHostElement, storeAlias: string);
     /**
      * An observable to observe the root items
      * @memberof UmbFileSystemTreeStore
@@ -147,13 +136,19 @@ type TreeItemPresentationModel = {
     hasChildren?: boolean;
 };
 
-interface UmbTreeStore<T extends TreeItemPresentationModel = any> {
-    appendItems: (items: Array<T>) => void;
-    updateItem: (unique: string, item: Partial<T>) => void;
-    removeItem: (unique: string) => void;
+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>>;
 }
 
-export { UmbContentStore, UmbDataStore, UmbDataStoreIdentifiers, UmbEntityDetailStore, UmbEntityTreeStore, UmbFileSystemTreeStore, UmbStoreBase, UmbTreeStore };
+interface UmbItemStore<T extends ItemResponseModelBaseModel = any> extends UmbStore<T> {
+    items: (uniques: Array<string>) => Observable<Array<T>>;
+}
+
+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 };