@umbraco-cms/backoffice 14.0.0-e0d20272 → 14.0.0-e7aa9547

package/dist-cms/libs/context-api/debug/context-data.function.js

@@ -86,4 +86,3 @@ function getClassMethodNames(klass) {
     const allMethods = typeof klass.prototype === 'undefined' ? distinctDeepFunctions(klass) : Object.getOwnPropertyNames(klass.prototype);
     return allMethods.filter((name) => name !== 'constructor' && !name.startsWith('_'));
 }
-//# sourceMappingURL=context-data.function.js.map

package/dist-cms/libs/context-api/index.js

@@ -7,4 +7,3 @@ export * from './provide/context-provide.event.js';
 export * from './provide/context-provider.element.js';
 export * from './token/index.js';
 export * from './debug/context-data.function.js';
-//# sourceMappingURL=index.js.map

package/dist-cms/libs/context-api/provide/context-provide.event.js

@@ -14,4 +14,3 @@ export class UmbContextProvideEventImplementation extends Event {
 export const isUmbContextProvideEventType = (event) => {
     return event.type === umbContextProvideEventType;
 };
-//# sourceMappingURL=context-provide.event.js.map

package/dist-cms/libs/context-api/provide/context-provider.controller.d.ts

@@ -1,8 +1,9 @@
 import { UmbContextToken } from '../token/context-token.js';
 import { UmbContextProvider } from './context-provider.js';
-import type { UmbControllerHostElement, UmbControllerInterface } from '../../controller-api/index.js';
-export declare class UmbContextProviderController<T = unknown> extends UmbContextProvider<UmbControllerHostElement> implements UmbControllerInterface {
-    get unique(): string;
-    constructor(host: UmbControllerHostElement, contextAlias: string | UmbContextToken<T>, instance: T);
+import type { UmbControllerHost, UmbController } from '../../controller-api/index.js';
+export declare class UmbContextProviderController<T = unknown> extends UmbContextProvider implements UmbController {
+    #private;
+    get controllerAlias(): string;
+    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<T>, instance: T);
     destroy(): void;
 }

package/dist-cms/libs/context-api/provide/context-provider.controller.js

@@ -1,16 +1,18 @@
 import { UmbContextProvider } from './context-provider.js';
 export class UmbContextProviderController extends UmbContextProvider {
-    get unique() {
+    #host;
+    get controllerAlias() {
         return this._contextAlias.toString();
     }
     constructor(host, contextAlias, instance) {
-        super(host, contextAlias, instance);
+        super(host.getHostElement(), contextAlias, instance);
+        this.#host = host;
         // If this API is already provided with this alias? Then we do not want to register this controller:
-        const existingControllers = host.getControllers((x) => x.unique === this.unique);
+        const existingControllers = host.getControllers((x) => x.controllerAlias === this.controllerAlias);
         if (existingControllers.length > 0 &&
             existingControllers[0].providerInstance?.() === instance) {
             // Back out, this instance is already provided, by another controller.
-            throw new Error(`Context API: The context of '${this.unique}' is already provided with the same API by another Context Provider Controller.`);
+            throw new Error(`Context API: The context of '${this.controllerAlias}' is already provided with the same API by another Context Provider Controller.`);
         }
         else {
             host.addController(this);
@@ -18,9 +20,8 @@ export class UmbContextProviderController extends UmbContextProvider {
     }
     destroy() {
         super.destroy();
-        if (this.host) {
-            this.host.removeController(this);
+        if (this.#host) {
+            this.#host.removeController(this);
         }
     }
 }
-//# sourceMappingURL=context-provider.controller.js.map

package/dist-cms/libs/context-api/provide/context-provider.d.ts

@@ -3,9 +3,9 @@ import { UmbContextToken } from '../token/context-token.js';
  * @export
  * @class UmbContextProvider
  */
-export declare class UmbContextProvider<HostType extends EventTarget = EventTarget> {
+export declare class UmbContextProvider {
     #private;
-    protected host: HostType;
+    protected hostElement: EventTarget;
     protected _contextAlias: string;
     /**
      * Method to enable comparing the context providers by the instance they provide.
@@ -20,7 +20,7 @@ export declare class UmbContextProvider<HostType extends EventTarget = EventTarg
      * @param {*} instance
      * @memberof UmbContextProvider
      */
-    constructor(host: HostType, contextAlias: string | UmbContextToken, instance: unknown);
+    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken, instance: unknown);
     /**
      * @memberof UmbContextProvider
      */

package/dist-cms/libs/context-api/provide/context-provider.element.d.ts

@@ -1,6 +1,6 @@
 import { UmbControllerHostElement } from '../../controller-api/index.js';
 import { UmbContextToken } from '../index.js';
-declare const UmbContextProviderElement_base: (new (...args: any[]) => UmbControllerHostElement) & {
+declare const UmbContextProviderElement_base: import("../../extension-api/index.js").HTMLElementConstructor<UmbControllerHostElement> & {
     new (): HTMLElement;
     prototype: HTMLElement;
 };

package/dist-cms/libs/context-api/provide/context-provider.element.js

@@ -1,4 +1,4 @@
-import { UmbControllerHostMixin } from '../../controller-api/index.js';
+import { UmbControllerHostElementMixin } from '../../controller-api/index.js';
 import { UmbContextProviderController } from '../index.js';
 /**
  * Provides a value to the context down the DOM tree.
@@ -8,7 +8,7 @@ import { UmbContextProviderController } from '../index.js';
  * @throws {Error} If the key property is not set.
  * @throws {Error} If the value property is not set.
  */
-export class UmbContextProviderElement extends UmbControllerHostMixin(HTMLElement) {
+export class UmbContextProviderElement extends UmbControllerHostElementMixin(HTMLElement) {
     static get observedAttributes() {
         return ['value', 'key'];
     }
@@ -39,4 +39,3 @@ export class UmbContextProviderElement extends UmbControllerHostMixin(HTMLElemen
     }
 }
 customElements.define('umb-context-provider', UmbContextProviderElement);
-//# sourceMappingURL=context-provider.element.js.map

package/dist-cms/libs/context-api/provide/context-provider.js

@@ -21,7 +21,7 @@ export class UmbContextProvider {
      * @param {*} instance
      * @memberof UmbContextProvider
      */
-    constructor(host, contextAlias, instance) {
+    constructor(hostElement, contextAlias, instance) {
         /**
          * @private
          * @param {UmbContextRequestEvent} event
@@ -47,7 +47,7 @@ export class UmbContextProvider {
                 event.instances.set(this._contextAlias, this.#instance);
             }
         };
-        this.host = host;
+        this.hostElement = hostElement;
         this._contextAlias = contextAlias.toString();
         this.#instance = instance;
     }
@@ -55,16 +55,16 @@ export class UmbContextProvider {
      * @memberof UmbContextProvider
      */
     hostConnected() {
-        this.host.addEventListener(umbContextRequestEventType, this._handleContextRequest);
-        this.host.dispatchEvent(new UmbContextProvideEventImplementation(this._contextAlias));
+        this.hostElement.addEventListener(umbContextRequestEventType, this._handleContextRequest);
+        this.hostElement.dispatchEvent(new UmbContextProvideEventImplementation(this._contextAlias));
         // Listen to our debug event 'umb:debug-contexts'
-        this.host.addEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
+        this.hostElement.addEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
     }
     /**
      * @memberof UmbContextProvider
      */
     hostDisconnected() {
-        this.host.removeEventListener(umbContextRequestEventType, this._handleContextRequest);
+        this.hostElement.removeEventListener(umbContextRequestEventType, this._handleContextRequest);
         // TODO: fire unprovided event.
     }
     destroy() {
@@ -72,4 +72,3 @@ export class UmbContextProvider {
         this.#instance?.destroy?.();
     }
 }
-//# sourceMappingURL=context-provider.js.map

package/dist-cms/libs/context-api/token/context-token.js

@@ -29,4 +29,3 @@ export class UmbContextToken {
         return this.alias;
     }
 }
-//# sourceMappingURL=context-token.js.map

package/dist-cms/libs/context-api/token/index.js

@@ -1,2 +1 @@
 export * from './context-token.js';
-//# sourceMappingURL=index.js.map

package/dist-cms/libs/controller-api/controller-alias.type.d.ts

@@ -0,0 +1 @@
+export type UmbControllerAlias = string | symbol | undefined;

package/dist-cms/libs/controller-api/controller-alias.type.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/libs/controller-api/controller-host-base.mixin.d.ts

@@ -0,0 +1,22 @@
+import { ClassConstructor } from '../extension-api/types.js';
+import { UmbControllerHost } from './controller-host.interface.js';
+import type { UmbController } from './controller.interface.js';
+declare class UmbControllerHostBaseDeclaration implements Omit<UmbControllerHost, 'getHostElement'> {
+    hasController(controller: UmbController): boolean;
+    getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
+    addController(controller: UmbController): void;
+    removeControllerByAlias(unique: UmbController['controllerAlias']): void;
+    removeController(controller: UmbController): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    destroy(): void;
+}
+/**
+ * This mixin enables a class to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ * @param {Object} superClass - superclass to be extended.
+ * @mixin
+ */
+export declare const UmbControllerHostBaseMixin: <T extends ClassConstructor<any>>(superClass: T) => ClassConstructor<UmbControllerHostBaseDeclaration> & T;
+export {};

package/dist-cms/libs/controller-api/controller-host-base.mixin.js

@@ -0,0 +1,86 @@
+/**
+ * This mixin enables a class to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ * @param {Object} superClass - superclass to be extended.
+ * @mixin
+ */
+export const UmbControllerHostBaseMixin = (superClass) => {
+    class UmbControllerHostBaseClass extends superClass {
+        #controllers = [];
+        #attached = false;
+        /**
+         * Tests if a controller is assigned to this element.
+         * @param {UmbController} ctrl
+         */
+        hasController(ctrl) {
+            return this.#controllers.indexOf(ctrl) !== -1;
+        }
+        /**
+         * Retrieve controllers matching a filter of this element.
+         * @param {method} filterMethod
+         */
+        getControllers(filterMethod) {
+            return this.#controllers.filter(filterMethod);
+        }
+        /**
+         * Append a controller to this element.
+         * @param {UmbController} ctrl
+         */
+        addController(ctrl) {
+            // If this specific class is already added, then skip out.
+            if (this.#controllers.indexOf(ctrl) !== -1) {
+                return;
+            }
+            // Check if there is one already with same unique
+            this.removeControllerByAlias(ctrl.controllerAlias);
+            this.#controllers.push(ctrl);
+            if (this.#attached) {
+                // If a controller is created on a already attached element, then it will be added directly. This might not be optimal. As the controller it self has not finished its constructor method jet. therefor i postpone the call:
+                Promise.resolve().then(() => ctrl.hostConnected());
+                //ctrl.hostConnected();
+            }
+        }
+        /**
+         * Remove a controller from this element.
+         * Notice this will also destroy the controller.
+         * @param {UmbController} ctrl
+         */
+        removeController(ctrl) {
+            const index = this.#controllers.indexOf(ctrl);
+            if (index !== -1) {
+                this.#controllers.splice(index, 1);
+                if (this.#attached) {
+                    ctrl.hostDisconnected();
+                }
+                ctrl.destroy();
+            }
+        }
+        /**
+         * Remove a controller from this element by its alias.
+         * Notice this will also destroy the controller.
+         * @param {string | symbol} controllerAlias
+         */
+        removeControllerByAlias(controllerAlias) {
+            if (controllerAlias) {
+                this.#controllers.forEach((x) => {
+                    if (x.controllerAlias === controllerAlias) {
+                        this.removeController(x);
+                    }
+                });
+            }
+        }
+        hostConnected() {
+            this.#attached = true;
+            this.#controllers.forEach((ctrl) => ctrl.hostConnected());
+        }
+        hostDisconnected() {
+            this.#attached = false;
+            this.#controllers.forEach((ctrl) => ctrl.hostDisconnected());
+        }
+        destroy() {
+            this.#controllers.forEach((ctrl) => ctrl.destroy());
+        }
+    }
+    return UmbControllerHostBaseClass;
+};

package/dist-cms/libs/controller-api/controller-host-element.mixin.d.ts

@@ -0,0 +1,26 @@
+import { HTMLElementConstructor } from '../extension-api/types.js';
+import { UmbControllerAlias } from './controller-alias.type.js';
+import { UmbControllerHost } from './controller-host.interface.js';
+import type { UmbController } from './controller.interface.js';
+export declare class UmbControllerHostElement extends HTMLElement implements UmbControllerHost {
+    hasController(controller: UmbController): boolean;
+    getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
+    addController(controller: UmbController): void;
+    removeControllerByAlias(alias: UmbControllerAlias): void;
+    removeController(controller: UmbController): void;
+    getHostElement(): EventTarget;
+}
+/**
+ * This mixin enables a web-component to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ * @param {Object} superClass - superclass to be extended.
+ * @mixin
+ */
+export declare const UmbControllerHostElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbControllerHostElement> & T;
+declare global {
+    interface HTMLElement {
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+    }
+}

package/dist-cms/libs/controller-api/controller-host-element.mixin.js

@@ -0,0 +1,24 @@
+import { UmbControllerHostBaseMixin } from './controller-host-base.mixin.js';
+/**
+ * This mixin enables a web-component to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ * @param {Object} superClass - superclass to be extended.
+ * @mixin
+ */
+export const UmbControllerHostElementMixin = (superClass) => {
+    class UmbControllerHostElementClass extends UmbControllerHostBaseMixin(superClass) {
+        getHostElement() {
+            return this;
+        }
+        connectedCallback() {
+            super.connectedCallback?.();
+            this.hostConnected();
+        }
+        disconnectedCallback() {
+            super.disconnectedCallback?.();
+            this.hostDisconnected();
+        }
+    }
+    return UmbControllerHostElementClass;
+};

package/dist-cms/libs/controller-api/controller-host-initializer.element.d.ts

@@ -1,5 +1,5 @@
-import { UmbControllerHostElement } from './controller-host.mixin.js';
-declare const UmbControllerHostInitializerElement_base: (new (...args: any[]) => UmbControllerHostElement) & {
+import { UmbControllerHostElement } from './controller-host-element.mixin.js';
+declare const UmbControllerHostInitializerElement_base: import("../extension-api/types.js").HTMLElementConstructor<UmbControllerHostElement> & {
     new (): HTMLElement;
     prototype: HTMLElement;
 };

package/dist-cms/libs/controller-api/controller-host-initializer.element.js

@@ -1,5 +1,5 @@
-import { UmbControllerHostMixin } from './controller-host.mixin.js';
-export class UmbControllerHostInitializerElement extends UmbControllerHostMixin(HTMLElement) {
+import { UmbControllerHostElementMixin } from './controller-host-element.mixin.js';
+export class UmbControllerHostInitializerElement extends UmbControllerHostElementMixin(HTMLElement) {
     constructor() {
         super();
         this.attachShadow({ mode: 'open' });
@@ -14,4 +14,3 @@ export class UmbControllerHostInitializerElement extends UmbControllerHostMixin(
     }
 }
 customElements.define('umb-controller-host-initializer', UmbControllerHostInitializerElement);
-//# sourceMappingURL=controller-host-initializer.element.js.map

package/dist-cms/libs/controller-api/controller-host.interface.d.ts

@@ -0,0 +1,9 @@
+import type { UmbController } from './controller.interface.js';
+export declare class UmbControllerHost {
+    hasController(controller: UmbController): boolean;
+    getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
+    addController(controller: UmbController): void;
+    removeControllerByAlias(unique: UmbController['controllerAlias']): void;
+    removeController(controller: UmbController): void;
+    getHostElement(): EventTarget;
+}

package/dist-cms/libs/controller-api/controller-host.interface.js

@@ -0,0 +1 @@
+export {};

package/dist-cms/libs/controller-api/controller.class.d.ts

@@ -1,11 +1,47 @@
-import { UmbControllerHostElement } from './controller-host.mixin.js';
-import type { UmbControllerInterface } from './controller.interface.js';
-export declare abstract class UmbController implements UmbControllerInterface {
-    protected host?: UmbControllerHostElement;
-    private _alias?;
-    get unique(): string | undefined;
-    constructor(host: UmbControllerHostElement, alias?: string);
-    abstract hostConnected(): void;
-    abstract hostDisconnected(): void;
+import { UmbControllerHost } from './controller-host.interface.js';
+import { UmbController } from './controller.interface.js';
+declare const UmbBaseController_base: (new (host: UmbControllerHost, controllerAlias: import("./controller-alias.type.js").UmbControllerAlias) => {
+    _host: UmbControllerHost;
+    observe<T>(source: import("rxjs").Observable<T> | {
+        asObservable: () => import("rxjs").Observable<T>;
+    }, callback: (_value: T) => void, controllerAlias?: import("./controller-alias.type.js").UmbControllerAlias): import("../observable-api/observer.controller.js").UmbObserverController<T>;
+    provideContext<R = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R>, instance: R): import("../context-api/index.js").UmbContextProviderController<R>;
+    consumeContext<R_1 = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R_1>, callback: import("../context-api/index.js").UmbContextCallback<R_1>): import("../context-api/index.js").UmbContextConsumerController<R_1>;
+    hasController(controller: UmbController): boolean;
+    getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
+    addController(controller: UmbController): void;
+    removeControllerByAlias(controllerAlias: import("./controller-alias.type.js").UmbControllerAlias): void;
+    removeController(controller: UmbController): void;
+    getHostElement(): EventTarget;
+    readonly controllerAlias: import("./controller-alias.type.js").UmbControllerAlias;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    destroy(): void;
+}) & {
+    _host: UmbControllerHost;
+    observe<T>(source: import("rxjs").Observable<T> | {
+        asObservable: () => import("rxjs").Observable<T>;
+    }, callback: (_value: T) => void, controllerAlias?: import("./controller-alias.type.js").UmbControllerAlias): import("../observable-api/observer.controller.js").UmbObserverController<T>;
+    provideContext<R = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R>, instance: R): import("../context-api/index.js").UmbContextProviderController<R>;
+    consumeContext<R_1 = unknown>(alias: string | import("../context-api/index.js").UmbContextToken<R_1>, callback: import("../context-api/index.js").UmbContextCallback<R_1>): import("../context-api/index.js").UmbContextConsumerController<R_1>;
+    hasController(controller: UmbController): boolean;
+    getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
+    addController(controller: UmbController): void;
+    removeControllerByAlias(controllerAlias: import("./controller-alias.type.js").UmbControllerAlias): void;
+    removeController(controller: UmbController): void;
+    getHostElement(): EventTarget;
+    readonly controllerAlias: import("./controller-alias.type.js").UmbControllerAlias;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    destroy(): void;
+};
+/**
+ * This mixin enables a web-component to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ */
+export declare abstract class UmbBaseController extends UmbBaseController_base implements UmbController {
+    constructor(host: UmbControllerHost, controllerAlias?: UmbController['controllerAlias']);
     destroy(): void;
 }
+export {};

package/dist-cms/libs/controller-api/controller.class.js

@@ -1,17 +1,20 @@
-export class UmbController {
-    get unique() {
-        return this._alias;
-    }
-    constructor(host, alias) {
-        this.host = host;
-        this._alias = alias;
-        this.host.addController(this);
+import { UmbClassMixin } from '../class-api/index.js';
+/**
+ * This mixin enables a web-component to host controllers.
+ * This enables controllers to be added to the life cycle of this element.
+ *
+ */
+export class UmbBaseController extends UmbClassMixin(class {
+}) {
+    constructor(host, controllerAlias) {
+        super(host, controllerAlias);
+        this._host.addController(this);
     }
     destroy() {
-        if (this.host) {
-            this.host.removeController(this);
+        if (this._host) {
+            this._host.removeController(this);
         }
-        delete this.host;
+        //delete this.host;
+        super.destroy();
     }
 }
-//# sourceMappingURL=controller.class.js.map

package/dist-cms/libs/controller-api/controller.interface.d.ts

@@ -1,5 +1,6 @@
-export interface UmbControllerInterface {
-    get unique(): string | undefined;
+import type { UmbControllerAlias } from './controller-alias.type.js';
+export interface UmbController {
+    get controllerAlias(): UmbControllerAlias;
     hostConnected(): void;
     hostDisconnected(): void;
     destroy(): void;

package/dist-cms/libs/controller-api/controller.interface.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=controller.interface.js.map

package/dist-cms/libs/controller-api/index.d.ts

@@ -1,3 +1,6 @@
-export * from './controller-host.mixin.js';
+export * from './controller-host-base.mixin.js';
+export * from './controller-host.interface.js';
+export * from './controller-host-element.mixin.js';
 export * from './controller.class.js';
 export * from './controller.interface.js';
+export * from './controller-alias.type.js';

package/dist-cms/libs/controller-api/index.js

@@ -1,4 +1,6 @@
-export * from './controller-host.mixin.js';
+export * from './controller-host-base.mixin.js';
+export * from './controller-host.interface.js';
+export * from './controller-host-element.mixin.js';
 export * from './controller.class.js';
 export * from './controller.interface.js';
-//# sourceMappingURL=index.js.map
+export * from './controller-alias.type.js';

package/dist-cms/libs/element-api/element.mixin.d.ts

@@ -3,16 +3,11 @@ import type { HTMLElementConstructor } from '../extension-api/index.js';
 import type { UmbControllerHostElement } from '../controller-api/index.js';
 import { UmbContextToken, UmbContextCallback, UmbContextConsumerController, UmbContextProviderController } from '../context-api/index.js';
 import { UmbObserverController } from '../observable-api/index.js';
-interface ResolvedContexts {
-    [key: string]: any;
-}
-export declare class UmbElementMixinInterface extends UmbControllerHostElement {
+export declare class UmbElement extends UmbControllerHostElement {
     observe<T>(source: Observable<T> | {
         asObservable: () => Observable<T>;
     }, callback: (_value: T) => void, unique?: string): UmbObserverController<T>;
     provideContext<R = unknown>(alias: string | UmbContextToken<R>, instance: R): UmbContextProviderController<R>;
     consumeContext<R = unknown>(alias: string | UmbContextToken<R>, callback: UmbContextCallback<R>): UmbContextConsumerController<R>;
-    consumeAllContexts(contextAliases: string[], callback: (_instances: ResolvedContexts) => void): void;
 }
-export declare const UmbElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbElementMixinInterface> & T;
-export {};
+export declare const UmbElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbElement> & T;

package/dist-cms/libs/element-api/element.mixin.js

@@ -1,8 +1,8 @@
-import { UmbControllerHostMixin } from '../controller-api/index.js';
+import { UmbControllerHostElementMixin } from '../controller-api/index.js';
 import { UmbContextConsumerController, UmbContextProviderController, } from '../context-api/index.js';
 import { UmbObserverController } from '../observable-api/index.js';
 export const UmbElementMixin = (superClass) => {
-    class UmbElementMixinClass extends UmbControllerHostMixin(superClass) {
+    class UmbElementMixinClass extends UmbControllerHostElementMixin(superClass) {
         /**
          * @description Observe a RxJS source of choice.
          * @param {Observable<T>} source RxJS source
@@ -33,27 +33,6 @@ export const UmbElementMixin = (superClass) => {
         consumeContext(alias, callback) {
             return new UmbContextConsumerController(this, alias, callback);
         }
-        /**
-         * @description Setup a subscription for multiple contexts. The callback is called when all contexts are resolved.
-         * @param {string} aliases
-         * @param {method} callback Callback method called when all contexts are resolved.
-         * @memberof UmbElementMixin
-         * @deprecated it should not be necessary to consume multiple contexts at once, use consumeContext instead with an UmbContextToken
-         */
-        consumeAllContexts(_contextAliases, callback) {
-            let resolvedAmount = 0;
-            const controllers = _contextAliases.map((alias) => new UmbContextConsumerController(this, alias, () => {
-                resolvedAmount++;
-                if (resolvedAmount === _contextAliases.length) {
-                    const result = {};
-                    controllers.forEach((contextCtrl) => {
-                        result[contextCtrl.consumerAlias?.toString()] = contextCtrl.instance;
-                    });
-                    callback(result);
-                }
-            }));
-        }
     }
     return UmbElementMixinClass;
 };
-//# sourceMappingURL=element.mixin.js.map

package/dist-cms/libs/element-api/index.js

@@ -1,2 +1 @@
 export * from './element.mixin.js';
-//# sourceMappingURL=index.js.map

package/dist-cms/libs/extension-api/bundle-extension-initializer.d.ts

@@ -5,4 +5,5 @@ export declare class UmbBundleExtensionInitializer {
     #private;
     constructor(host: UmbControllerHostElement, extensionRegistry: UmbExtensionRegistry<ManifestBundle>);
     instantiateBundle(manifest: ManifestBundle): Promise<void>;
+    unregisterBundle(manifest: ManifestBundle): Promise<void>;
 }

package/dist-cms/libs/extension-api/bundle-extension-initializer.js

@@ -1,17 +1,22 @@
 import { loadExtension } from './load-extension.function.js';
 export class UmbBundleExtensionInitializer {
-    #host;
     #extensionRegistry;
     #bundleMap = new Map();
     constructor(host, extensionRegistry) {
-        this.#host = host;
         this.#extensionRegistry = extensionRegistry;
         extensionRegistry.extensionsOfType('bundle').subscribe((bundles) => {
+            // Unregister removed bundles:
+            this.#bundleMap.forEach((existingBundle) => {
+                if (!bundles.find((b) => b.alias === existingBundle.alias)) {
+                    this.unregisterBundle(existingBundle);
+                    this.#bundleMap.delete(existingBundle.alias);
+                }
+            });
+            // Register new bundles:
             bundles.forEach((bundle) => {
                 if (this.#bundleMap.has(bundle.alias))
                     return;
                 this.#bundleMap.set(bundle.alias, bundle);
-                // TODO: Should we unInit a entry point if is removed?
                 this.instantiateBundle(bundle);
             });
         });
@@ -30,5 +35,18 @@ export class UmbBundleExtensionInitializer {
             });
         }
     }
+    async unregisterBundle(manifest) {
+        const js = await loadExtension(manifest);
+        if (js) {
+            Object.keys(js).forEach((key) => {
+                const value = js[key];
+                if (Array.isArray(value)) {
+                    this.#extensionRegistry.unregisterMany(value.map((v) => v.alias));
+                }
+                else if (typeof value === 'object') {
+                    this.#extensionRegistry.unregister(value.alias);
+                }
+            });
+        }
+    }
 }
-//# sourceMappingURL=bundle-extension-initializer.js.map

package/dist-cms/libs/extension-api/create-extension-class.function.js

@@ -17,4 +17,3 @@ export async function createExtensionClass(manifest, constructorArguments) {
     console.error('-- Extension did not succeed creating an class instance, missing a default export or `class` in the manifest.', manifest);
     return undefined;
 }
-//# sourceMappingURL=create-extension-class.function.js.map

package/dist-cms/libs/extension-api/create-extension-element-or-fallback.function.js

@@ -6,4 +6,3 @@ export async function createExtensionElementOrFallback(manifest, fallbackElement
     }
     return Promise.resolve(document.createElement(fallbackElementName));
 }
-//# sourceMappingURL=create-extension-element-or-fallback.function.js.map