@umbraco-cms/backoffice 1.0.0-next.48e903f7 → 1.0.0-next.49f05cfb

package/collection.d.ts

@@ -0,0 +1,38 @@
+import * as rxjs from 'rxjs';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbObserverController } from '@umbraco-cms/backoffice/observable-api';
+import { UmbCollectionRepository } from '@umbraco-cms/backoffice/repository';
+import { UmbCollectionFilterModel as UmbCollectionFilterModel$1 } from '@umbraco-cms/backoffice/collection';
+
+declare class UmbCollectionContext<ItemType, FilterModelType extends UmbCollectionFilterModel$1> {
+    #private;
+    private _host;
+    private _entityType;
+    protected _dataObserver?: UmbObserverController<ItemType[]>;
+    readonly items: rxjs.Observable<ItemType[]>;
+    readonly total: rxjs.Observable<number>;
+    readonly selection: rxjs.Observable<string[]>;
+    readonly filter: rxjs.Observable<object | FilterModelType>;
+    repository?: UmbCollectionRepository;
+    constructor(host: UmbControllerHostElement, entityType: string | null, repositoryAlias: string);
+    isSelected(id: string): boolean;
+    setSelection(value: Array<string>): void;
+    clearSelection(): void;
+    select(id: string): void;
+    deselect(id: string): void;
+    destroy(): void;
+    getEntityType(): string | null;
+    protected _onRepositoryReady(): Promise<void>;
+    requestCollection(): Promise<void>;
+    setFilter(filter: Partial<FilterModelType>): void;
+}
+declare const UMB_COLLECTION_CONTEXT_TOKEN: UmbContextToken<UmbCollectionContext<any, any>>;
+
+interface UmbCollectionFilterModel {
+    skip?: number;
+    take?: number;
+    filter?: string;
+}
+
+export { UMB_COLLECTION_CONTEXT_TOKEN, UmbCollectionContext, UmbCollectionFilterModel };

package/content-type.d.ts

@@ -0,0 +1,127 @@
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ProblemDetailsModel, DocumentTypeResponseModel, PropertyTypeContainerResponseModelBaseModel, PropertyTypeResponseModelBaseModel, DocumentTypePropertyTypeResponseModel } from '@umbraco-cms/backoffice/backend-api';
+import { UmbControllerHostElement } from '@umbraco-cms/backoffice/controller';
+import { MappingFunction } from '@umbraco-cms/backoffice/observable-api';
+
+interface UmbRepositoryErrorResponse {
+    error?: ProblemDetailsModel;
+}
+interface UmbRepositoryResponse<T> extends UmbRepositoryErrorResponse {
+    data?: T;
+}
+interface UmbDetailRepository<CreateRequestType = any, CreateResponseType = any, UpdateRequestType = any, ResponseType = any> {
+    createScaffold(parentId: string | null): Promise<UmbRepositoryResponse<CreateRequestType>>;
+    requestById(id: string): Promise<UmbRepositoryResponse<ResponseType>>;
+    byId(id: string): Promise<Observable<ResponseType>>;
+    create(data: CreateRequestType): Promise<UmbRepositoryResponse<CreateResponseType>>;
+    save(id: string, data: UpdateRequestType): Promise<UmbRepositoryErrorResponse>;
+    delete(id: string): Promise<UmbRepositoryErrorResponse>;
+}
+
+type PropertyContainerTypes = 'Group' | 'Tab';
+type T = DocumentTypeResponseModel;
+declare class UmbContentTypePropertyStructureManager<R extends UmbDetailRepository<T> = UmbDetailRepository<T>> {
+    #private;
+    readonly documentTypes: rxjs.Observable<DocumentTypeResponseModel[]>;
+    private readonly _documentTypeContainers;
+    constructor(host: UmbControllerHostElement, typeRepository: R);
+    /**
+     * loadType will load the node type and all inherited and composed types.
+     * This will give us all the structure for properties and containers.
+     */
+    loadType(id?: string): Promise<{
+        data?: undefined;
+    } | {
+        data: any;
+    }>;
+    createScaffold(parentId: string): Promise<{
+        data?: undefined;
+    } | {
+        data: DocumentTypeResponseModel;
+    }>;
+    private _ensureType;
+    private _loadType;
+    _observeDocumentType(data: T): Promise<void>;
+    private _loadDocumentTypeCompositions;
+    /** Public methods for consuming structure: */
+    rootDocumentType(): rxjs.Observable<DocumentTypeResponseModel | undefined>;
+    getRootDocumentType(): DocumentTypeResponseModel | undefined;
+    updateRootDocumentType(entry: T): void;
+    createContainer(contentTypeId: string | null, parentId?: string | null, type?: PropertyContainerTypes, sortOrder?: number): Promise<PropertyTypeContainerResponseModelBaseModel>;
+    updateContainer(documentTypeId: string | null, groupKey: string, partialUpdate: Partial<PropertyTypeContainerResponseModelBaseModel>): Promise<void>;
+    removeContainer(documentTypeKey: string | null, containerId?: string | null): Promise<void>;
+    createProperty(documentTypeId: string | null, containerId?: string | null, sortOrder?: number): Promise<PropertyTypeResponseModelBaseModel>;
+    insertProperty(documentTypeId: string | null, property: PropertyTypeResponseModelBaseModel): Promise<void>;
+    removeProperty(documentTypeId: string | null, propertyId: string): Promise<void>;
+    updateProperty(documentTypeId: string | null, propertyId: string, partialUpdate: Partial<PropertyTypeResponseModelBaseModel>): Promise<void>;
+    rootDocumentTypeObservablePart<PartResult>(mappingFunction: MappingFunction<T, PartResult>): rxjs.Observable<PartResult | undefined>;
+    hasPropertyStructuresOf(containerId: string | null): rxjs.Observable<boolean>;
+    rootPropertyStructures(): rxjs.Observable<PropertyTypeResponseModelBaseModel[]>;
+    propertyStructuresOf(containerId: string | null): rxjs.Observable<PropertyTypeResponseModelBaseModel[]>;
+    rootContainers(containerType: PropertyContainerTypes): rxjs.Observable<PropertyTypeContainerResponseModelBaseModel[]>;
+    hasRootContainers(containerType: PropertyContainerTypes): rxjs.Observable<boolean>;
+    containersOfParentKey(parentId: PropertyTypeContainerResponseModelBaseModel['parentId'], containerType: PropertyContainerTypes): rxjs.Observable<PropertyTypeContainerResponseModelBaseModel[]>;
+    containersByNameAndType(name: string, containerType: PropertyContainerTypes): rxjs.Observable<PropertyTypeContainerResponseModelBaseModel[]>;
+    private _reset;
+    destroy(): void;
+}
+
+declare class UmbContentTypeContainerStructureHelper {
+    #private;
+    private _ownerType?;
+    private _childType?;
+    private _isRoot;
+    private _ownerName?;
+    private _ownerKey?;
+    private _ownerContainers;
+    readonly containers: rxjs.Observable<PropertyTypeContainerResponseModelBaseModel[]>;
+    readonly hasProperties: rxjs.Observable<boolean>;
+    constructor(host: UmbControllerHostElement);
+    setStructureManager(structure: UmbContentTypePropertyStructureManager): void;
+    setType(value?: PropertyContainerTypes): void;
+    getType(): PropertyContainerTypes | undefined;
+    setContainerChildType(value?: PropertyContainerTypes): void;
+    getContainerChildType(): PropertyContainerTypes | undefined;
+    setName(value?: string): void;
+    getName(): string | undefined;
+    setIsRoot(value: boolean): void;
+    getIsRoot(): boolean;
+    private _observeOwnerContainers;
+    private _observeOwnerProperties;
+    private _observeChildContainers;
+    private _observeRootContainers;
+    private _insertGroupContainers;
+    /**
+     * Returns true if the container is an owner container.
+     */
+    isOwnerContainer(groupId?: string): boolean | undefined;
+    /** Manipulate methods: */
+    addContainer(ownerId?: string, sortOrder?: number): Promise<void>;
+    partialUpdateContainer(groupId?: string, partialUpdate?: Partial<PropertyTypeContainerResponseModelBaseModel>): Promise<void>;
+}
+
+declare class UmbContentTypePropertyStructureHelper {
+    #private;
+    private _containerType?;
+    private _isRoot?;
+    private _containerName?;
+    readonly propertyStructure: rxjs.Observable<PropertyTypeResponseModelBaseModel[]>;
+    constructor(host: UmbControllerHostElement);
+    setStructureManager(structure: UmbContentTypePropertyStructureManager): void;
+    setContainerType(value?: PropertyContainerTypes): void;
+    getContainerType(): PropertyContainerTypes | undefined;
+    setContainerName(value?: string): void;
+    getContainerName(): string | undefined;
+    setIsRoot(value: boolean): void;
+    getIsRoot(): boolean | undefined;
+    private _observeGroupContainers;
+    private _observePropertyStructureOf;
+    /** Manipulate methods: */
+    addProperty(ownerId?: string, sortOrder?: number): Promise<PropertyTypeResponseModelBaseModel | undefined>;
+    insertProperty(property: PropertyTypeResponseModelBaseModel, sortOrder?: number): Promise<boolean>;
+    removeProperty(propertyId: string): Promise<boolean>;
+    partialUpdateProperty(propertyKey?: string, partialUpdate?: Partial<DocumentTypePropertyTypeResponseModel>): Promise<void>;
+}
+
+export { PropertyContainerTypes, UmbContentTypeContainerStructureHelper, UmbContentTypePropertyStructureHelper, UmbContentTypePropertyStructureManager };

package/context-api.d.ts

@@ -1,4 +1,7 @@
-import { UmbControllerHostInterface, UmbControllerInterface } from './controller';
+import { UmbControllerHostElement, UmbControllerInterface } from '@umbraco-cms/backoffice/controller';
+import { UmbContextToken as UmbContextToken$1 } from '@umbraco-cms/backoffice/context-api';
+import { UmbWorkspaceContextInterface } from '@umbraco-cms/backoffice/workspace';
+import { UmbEntityBase } from '@umbraco-cms/backoffice/models';
 
 declare class UmbContextToken<T = unknown> {
     protected alias: string;
@@ -90,9 +93,9 @@ declare class UmbContextConsumer<HostType extends EventTarget = EventTarget, T =
     destroy(): void;
 }
 
-declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<UmbControllerHostInterface, T> implements UmbControllerInterface {
+declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<UmbControllerHostElement, T> implements UmbControllerInterface {
     get unique(): undefined;
-    constructor(host: UmbControllerHostInterface, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
+    constructor(host: UmbControllerHostElement, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
     destroy(): void;
 }
 
@@ -136,9 +139,9 @@ declare class UmbContextProvider<HostType extends EventTarget = EventTarget> {
     destroy(): void;
 }
 
-declare class UmbContextProviderController<T = unknown> extends UmbContextProvider<UmbControllerHostInterface> implements UmbControllerInterface {
+declare class UmbContextProviderController<T = unknown> extends UmbContextProvider<UmbControllerHostElement> implements UmbControllerInterface {
     get unique(): string;
-    constructor(host: UmbControllerHostInterface, contextAlias: string | UmbContextToken<T>, instance: T);
+    constructor(host: UmbControllerHostElement, contextAlias: string | UmbContextToken<T>, instance: T);
     destroy(): void;
 }
 
@@ -162,4 +165,113 @@ declare class UmbContextProvideEventImplementation extends Event implements UmbC
 }
 declare const isUmbContextProvideEventType: (event: Event) => event is UmbContextProvideEventImplementation;
 
-export { UmbContextCallback, UmbContextConsumer, UmbContextConsumerController, UmbContextDebugRequest, UmbContextProvideEvent, UmbContextProvideEventImplementation, UmbContextProvider, UmbContextProviderController, UmbContextRequestEvent, UmbContextRequestEventImplementation, UmbContextToken, isUmbContextProvideEventType, isUmbContextRequestEvent, umbContextProvideEventType, umbContextRequestEventType, umbDebugContextEventType };
+type HTMLElementConstructor<T = HTMLElement> = new (...args: any[]) => T;
+
+declare const UmbContextProviderElement_base: HTMLElementConstructor<UmbControllerHostElement> & {
+    new (): HTMLElement;
+    prototype: HTMLElement;
+};
+/**
+ * Provides a value to the context down the DOM tree.
+ *
+ * @remarks This element is a wrapper around the `provideContext` function.
+ * @slot - The context will be available to all descendants given in the default slot.
+ * @throws {Error} If the key property is not set.
+ * @throws {Error} If the value property is not set.
+ */
+declare class UmbContextProviderElement extends UmbContextProviderElement_base {
+    /**
+     * The value to provide to the context.
+     * @optional
+     */
+    create?: (host: UmbControllerHostElement) => unknown;
+    /**
+     * The value to provide to the context.
+     * @required
+     */
+    value: unknown;
+    /**
+     * The key to provide to the context.
+     * @required
+     */
+    key: string | UmbContextToken$1;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string | UmbContextToken$1, newValue: string | UmbContextToken$1): void;
+    constructor();
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'umb-context-provider': UmbContextProviderElement;
+    }
+}
+
+interface UmbEntityWorkspaceContextInterface<EntityType = unknown> extends UmbWorkspaceContextInterface<EntityType> {
+    getEntityId(): string | undefined;
+    getEntityType(): string;
+    save(): Promise<void>;
+}
+
+declare const UMB_ENTITY_WORKSPACE_CONTEXT: UmbContextToken<UmbEntityWorkspaceContextInterface<UmbEntityBase>>;
+
+/**
+ * Change the collection of Contexts into a simplified array of data
+ *
+ * @param contexts This is a map of the collected contexts from umb-debug
+ * @returns An array of simplified context data
+ */
+declare function contextData(contexts: Map<any, any>): Array<DebugContextData>;
+interface DebugContextData {
+    /**
+     * The alias of the context
+     *
+     * @type {string}
+     * @memberof DebugContextData
+     */
+    alias: string;
+    /**
+     * The type of the context such as object or string
+     *
+     * @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
+     * @memberof DebugContextData
+     */
+    type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    /**
+     * Data about the context that includes method and property names
+     *
+     * @type {DebugContextItemData}
+     * @memberof DebugContextData
+     */
+    data: DebugContextItemData;
+}
+interface DebugContextItemData {
+    type: string;
+    methods?: Array<unknown>;
+    properties?: Array<DebugContextItemPropertyData>;
+    value?: unknown;
+}
+interface DebugContextItemPropertyData {
+    /**
+     * The name of the property
+     *
+     * @type {string}
+     * @memberof DebugContextItemPropertyData
+     */
+    key: string;
+    /**
+     * The type of the property's value such as string or number
+     *
+     * @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
+     * @memberof DebugContextItemPropertyData
+     */
+    type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+    /**
+    * Simple types such as string or number can have their value displayed stored inside the property
+    *
+    * @type {("string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function")}
+    * @memberof DebugContextItemPropertyData
+    */
+    value?: unknown;
+}
+
+export { DebugContextData, DebugContextItemData, DebugContextItemPropertyData, UMB_ENTITY_WORKSPACE_CONTEXT, UmbContextCallback, UmbContextConsumer, UmbContextConsumerController, UmbContextDebugRequest, UmbContextProvideEvent, UmbContextProvideEventImplementation, UmbContextProvider, UmbContextProviderController, UmbContextProviderElement, UmbContextRequestEvent, UmbContextRequestEventImplementation, UmbContextToken, contextData, isUmbContextProvideEventType, isUmbContextRequestEvent, umbContextProvideEventType, umbContextRequestEventType, umbDebugContextEventType };

package/controller.d.ts

@@ -1,4 +1,4 @@
-import { HTMLElementConstructor } from './models';
+import { HTMLElementConstructor } from '@umbraco-cms/backoffice/models';
 
 interface UmbControllerInterface {
     get unique(): string | undefined;
@@ -7,10 +7,11 @@ interface UmbControllerInterface {
     destroy(): void;
 }
 
-declare class UmbControllerHostInterface extends HTMLElement {
+declare class UmbControllerHostElement extends HTMLElement {
     hasController(controller: UmbControllerInterface): boolean;
     getControllers(filterMethod: (ctrl: UmbControllerInterface) => boolean): UmbControllerInterface[];
     addController(controller: UmbControllerInterface): void;
+    removeControllerByUnique(unique: UmbControllerInterface['unique']): void;
     removeController(controller: UmbControllerInterface): void;
 }
 /**
@@ -20,7 +21,7 @@ declare class UmbControllerHostInterface extends HTMLElement {
  * @param {Object} superClass - superclass to be extended.
  * @mixin
  */
-declare const UmbControllerHostMixin: <T extends HTMLElementConstructor<HTMLElement>>(superClass: T) => HTMLElementConstructor<UmbControllerHostInterface> & T;
+declare const UmbControllerHostMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbControllerHostElement> & T;
 declare global {
     interface HTMLElement {
         connectedCallback(): void;
@@ -29,13 +30,13 @@ declare global {
 }
 
 declare abstract class UmbController implements UmbControllerInterface {
-    protected host?: UmbControllerHostInterface;
+    protected host?: UmbControllerHostElement;
     private _alias?;
     get unique(): string | undefined;
-    constructor(host: UmbControllerHostInterface, alias?: string);
+    constructor(host: UmbControllerHostElement, alias?: string);
     abstract hostConnected(): void;
     abstract hostDisconnected(): void;
     destroy(): void;
 }
 
-export { UmbController, UmbControllerHostInterface, UmbControllerHostMixin, UmbControllerInterface };
+export { UmbController, UmbControllerHostElement, UmbControllerHostMixin, UmbControllerInterface };