@umbraco-cms/backoffice 14.0.0-e72b5840 → 14.0.0-ef334a6d

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

@@ -8,5 +8,5 @@ export interface UmbClassMixinInterface extends UmbControllerHost, UmbController
         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>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
 }

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

@@ -10,8 +10,8 @@ declare class UmbClassMixinDeclaration implements UmbClassMixinInterface {
     observe<T>(source: Observable<T> | {
         asObservable: () => Observable<T>;
     }, callback: (_value: T) => void, controllerAlias?: UmbControllerAlias): 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>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType>(alias: string | UmbContextToken<BaseType, ResultType>, instance: InstanceType): UmbContextProviderController<BaseType, ResultType, InstanceType>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

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

@@ -22,7 +22,7 @@ export const UmbClassMixin = (superClass) => {
          * @memberof UmbElementMixin
          */
         observe(source, callback, controllerAlias) {
-            return new UmbObserverController(this, source.asObservable ? source.asObservable() : source, callback, controllerAlias);
+            return new UmbObserverController(this, source, callback, controllerAlias);
         }
         /**
          * @description Provide a context API for this or child elements.

package/dist-cms/libs/context-api/consume/context-consumer.controller.d.ts

@@ -2,9 +2,9 @@ import { UmbContextToken } from '../token/context-token.js';
 import { UmbContextConsumer } from './context-consumer.js';
 import { UmbContextCallback } from './context-request.event.js';
 import type { UmbControllerHost, UmbController } from '../../controller-api/index.js';
-export declare class UmbContextConsumerController<T = unknown> extends UmbContextConsumer<T> implements UmbController {
+export declare class UmbContextConsumerController<BaseType = unknown, ResultType extends BaseType = BaseType> extends UmbContextConsumer<BaseType, ResultType> implements UmbController {
     #private;
     get controllerAlias(): symbol;
-    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
+    constructor(host: UmbControllerHost, contextAlias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>);
     destroy(): void;
 }

package/dist-cms/libs/context-api/consume/context-consumer.controller.js

@@ -12,8 +12,6 @@ export class UmbContextConsumerController extends UmbContextConsumer {
     }
     destroy() {
         super.destroy();
-        if (this.#host) {
-            this.#host.removeController(this);
-        }
+        this.#host.removeController(this);
     }
 }

package/dist-cms/libs/context-api/consume/context-consumer.d.ts

@@ -4,26 +4,26 @@ import { UmbContextCallback } from './context-request.event.js';
  * @export
  * @class UmbContextConsumer
  */
-export declare class UmbContextConsumer<T = unknown> {
+export declare class UmbContextConsumer<BaseType = unknown, ResultType extends BaseType = BaseType> {
     #private;
     protected hostElement: EventTarget;
-    get instance(): T | undefined;
+    get instance(): ResultType | undefined;
     /**
      * Creates an instance of UmbContextConsumer.
      * @param {EventTarget} hostElement
      * @param {string} contextAlias
-     * @param {UmbContextCallback} _callback
+     * @param {UmbContextCallback} callback
      * @memberof UmbContextConsumer
      */
-    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<T>, callback?: UmbContextCallback<T>);
-    protected _onResponse: (instance: T) => void;
-    asPromise(): Promise<T>;
+    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<BaseType, ResultType>, callback?: UmbContextCallback<ResultType>);
+    protected _onResponse: (instance: BaseType) => void;
+    protected setInstance(instance: ResultType): void;
+    asPromise(): Promise<ResultType>;
     /**
      * @memberof UmbContextConsumer
      */
     request(): void;
     hostConnected(): void;
     hostDisconnected(): void;
-    private _handleNewProvider;
     destroy(): void;
 }

package/dist-cms/libs/context-api/consume/context-consumer.js

@@ -1,4 +1,8 @@
-import { isUmbContextProvideEventType, umbContextProvideEventType } from '../provide/context-provide.event.js';
+import { isUmbContextProvideEventType, 
+//isUmbContextUnprovidedEventType,
+umbContextProvideEventType,
+//umbContextUnprovidedEventType,
+ } from '../provide/context-provide.event.js';
 import { UmbContextRequestEventImplementation } from './context-request.event.js';
 /**
  * @export
@@ -13,24 +17,37 @@ export class UmbContextConsumer {
         return this.#instance;
     }
     #contextAlias;
+    #discriminator;
     /**
      * Creates an instance of UmbContextConsumer.
      * @param {EventTarget} hostElement
      * @param {string} contextAlias
-     * @param {UmbContextCallback} _callback
+     * @param {UmbContextCallback} callback
      * @memberof UmbContextConsumer
      */
     constructor(hostElement, contextAlias, callback) {
         this.hostElement = hostElement;
+        /* Idea: Niels: If we need to filter for specific contexts, we could make the response method return true/false. If false, the event should then then not be stopped. Alternatively parse the event it self on to the response-callback.
+        This will enable the event to continue to bubble up finding a context that matches.
+        The reason for such would be to have some who are more specific than others. For example, some might just need the current workspace-context, others might need the closest handling a certain entityType.
+        As I'm writing this is not relevant, but I wanted to keep the idea as we have had some circumstance that might be solved with this approach.
+        */
         this._onResponse = (instance) => {
             if (this.#instance === instance) {
                 return;
             }
-            this.#instance = instance;
-            this.#callback?.(instance);
-            this.#promiseResolver?.(instance);
+            if (this.#discriminator) {
+                // Notice if discriminator returns false, we do not want to setInstance.
+                if (this.#discriminator(instance)) {
+                    this.setInstance(instance);
+                }
+            }
+            else {
+                this.setInstance(instance);
+            }
         };
-        this._handleNewProvider = (event) => {
+        this.#handleNewProvider = (event) => {
+            // Does seem a bit unnecessary, we could just assume the type via type casting...
             if (!isUmbContextProvideEventType(event))
                 return;
             if (this.#contextAlias === event.contextAlias) {
@@ -39,9 +56,18 @@ export class UmbContextConsumer {
         };
         this.#contextAlias = contextAlias.toString();
         this.#callback = callback;
+        this.#discriminator = contextAlias.getDiscriminator?.();
+    }
+    setInstance(instance) {
+        this.#instance = instance;
+        this.#callback?.(instance);
+        if (instance !== undefined) {
+            this.#promiseResolver?.(instance);
+            this.#promise = undefined;
+        }
     }
     asPromise() {
-        return (this.#promise ||
+        return (this.#promise ??
             (this.#promise = new Promise((resolve) => {
                 this.#instance ? resolve(this.#instance) : (this.#promiseResolver = resolve);
             })));
@@ -55,13 +81,34 @@ export class UmbContextConsumer {
     }
     hostConnected() {
         // TODO: We need to use closets application element. We need this in order to have separate Backoffice running within or next to each other.
-        window.addEventListener(umbContextProvideEventType, this._handleNewProvider);
+        window.addEventListener(umbContextProvideEventType, this.#handleNewProvider);
+        //window.addEventListener(umbContextUnprovidedEventType, this.#handleRemovedProvider);
         this.request();
     }
     hostDisconnected() {
         // TODO: We need to use closets application element. We need this in order to have separate Backoffice running within or next to each other.
-        window.removeEventListener(umbContextProvideEventType, this._handleNewProvider);
+        window.removeEventListener(umbContextProvideEventType, this.#handleNewProvider);
+        //window.removeEventListener(umbContextUnprovidedEventType, this.#handleRemovedProvider);
+    }
+    #handleNewProvider;
+    //Niels: I'm keeping this code around as it might be relevant, but I wanted to try to see if leaving this feature out for now could work for us.
+    /*
+    #handleRemovedProvider = (event: Event) => {
+        // Does seem a bit unnecessary, we could just assume the type via type casting...
+        if (!isUmbContextUnprovidedEventType(event)) return;
+
+        if (this.#contextAlias === event.contextAlias && event.instance === this.#instance) {
+            this.#unProvide();
+        }
+    };
+
+    #unProvide() {
+        if (this.#instance !== undefined) {
+            this.#instance = undefined;
+            this.#callback?.(undefined);
+        }
     }
+    */
     // TODO: Test destroy scenarios:
     destroy() {
         this.hostDisconnected();

package/dist-cms/libs/context-api/consume/context-request.event.d.ts

@@ -6,9 +6,9 @@ export type UmbContextCallback<T> = (instance: T) => void;
  * @export
  * @interface UmbContextRequestEvent
  */
-export interface UmbContextRequestEvent<T = unknown> extends Event {
-    readonly contextAlias: string | UmbContextToken<T>;
-    readonly callback: UmbContextCallback<T>;
+export interface UmbContextRequestEvent<ResultType = unknown> extends Event {
+    readonly contextAlias: string | UmbContextToken<unknown, ResultType>;
+    readonly callback: UmbContextCallback<ResultType>;
 }
 /**
  * @export
@@ -16,10 +16,10 @@ export interface UmbContextRequestEvent<T = unknown> extends Event {
  * @extends {Event}
  * @implements {UmbContextRequestEvent}
  */
-export declare class UmbContextRequestEventImplementation<T = unknown> extends Event implements UmbContextRequestEvent<T> {
-    readonly contextAlias: string | UmbContextToken<T>;
-    readonly callback: UmbContextCallback<T>;
-    constructor(contextAlias: string | UmbContextToken<T>, callback: UmbContextCallback<T>);
+export declare class UmbContextRequestEventImplementation<ResultType = unknown> extends Event implements UmbContextRequestEvent<ResultType> {
+    readonly contextAlias: string | UmbContextToken<any, ResultType>;
+    readonly callback: UmbContextCallback<ResultType>;
+    constructor(contextAlias: string | UmbContextToken<any, ResultType>, callback: UmbContextCallback<ResultType>);
 }
 export declare const isUmbContextRequestEvent: (event: Event) => event is UmbContextRequestEventImplementation<unknown>;
 export declare class UmbContextDebugRequest extends Event {

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

@@ -18,3 +18,24 @@ export declare class UmbContextProvideEventImplementation extends Event implemen
     constructor(contextAlias: string | UmbContextToken);
 }
 export declare const isUmbContextProvideEventType: (event: Event) => event is UmbContextProvideEventImplementation;
+export declare const umbContextUnprovidedEventType = "umb:context-unprovided";
+/**
+ * @export
+ * @interface UmbContextProvideEvent
+ */
+export interface UmbContextUnprovidedEvent extends Event {
+    readonly contextAlias: string | UmbContextToken;
+    readonly instance: unknown;
+}
+/**
+ * @export
+ * @class UmbContextUnprovidedEventImplementation
+ * @extends {Event}
+ * @implements {UmbContextUnprovidedEvent}
+ */
+export declare class UmbContextUnprovidedEventImplementation extends Event implements UmbContextUnprovidedEvent {
+    readonly contextAlias: string | UmbContextToken;
+    readonly instance: unknown;
+    constructor(contextAlias: string | UmbContextToken, instance: unknown);
+}
+export declare const isUmbContextUnprovidedEventType: (event: Event) => event is UmbContextUnprovidedEventImplementation;

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

@@ -14,3 +14,20 @@ export class UmbContextProvideEventImplementation extends Event {
 export const isUmbContextProvideEventType = (event) => {
     return event.type === umbContextProvideEventType;
 };
+export const umbContextUnprovidedEventType = 'umb:context-unprovided';
+/**
+ * @export
+ * @class UmbContextUnprovidedEventImplementation
+ * @extends {Event}
+ * @implements {UmbContextUnprovidedEvent}
+ */
+export class UmbContextUnprovidedEventImplementation extends Event {
+    constructor(contextAlias, instance) {
+        super(umbContextUnprovidedEventType, { bubbles: true, composed: true });
+        this.contextAlias = contextAlias;
+        this.instance = instance;
+    }
+}
+export const isUmbContextUnprovidedEventType = (event) => {
+    return event.type === umbContextUnprovidedEventType;
+};

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

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

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

@@ -19,9 +19,9 @@ export class UmbContextProviderController extends UmbContextProvider {
         }
     }
     destroy() {
-        super.destroy();
         if (this.#host) {
             this.#host.removeController(this);
         }
+        super.destroy();
     }
 }

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

@@ -3,7 +3,7 @@ import { UmbContextToken } from '../token/context-token.js';
  * @export
  * @class UmbContextProvider
  */
-export declare class UmbContextProvider {
+export declare class UmbContextProvider<BaseType = unknown, ResultType extends BaseType = BaseType> {
     #private;
     protected hostElement: EventTarget;
     protected _contextAlias: string;
@@ -20,7 +20,7 @@ export declare class UmbContextProvider {
      * @param {*} instance
      * @memberof UmbContextProvider
      */
-    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken, instance: unknown);
+    constructor(hostElement: EventTarget, contextAlias: string | UmbContextToken<BaseType, ResultType>, instance: ResultType);
     /**
      * @memberof UmbContextProvider
      */
@@ -29,12 +29,6 @@ export declare class UmbContextProvider {
      * @memberof UmbContextProvider
      */
     hostDisconnected(): void;
-    /**
-     * @private
-     * @param {UmbContextRequestEvent} event
-     * @memberof UmbContextProvider
-     */
-    private _handleContextRequest;
     private _handleDebugContextRequest;
     destroy(): void;
 }

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

@@ -1,5 +1,7 @@
 import { umbContextRequestEventType, isUmbContextRequestEvent, umbDebugContextEventType, } from '../consume/context-request.event.js';
-import { UmbContextProvideEventImplementation } from './context-provide.event.js';
+import { UmbContextProvideEventImplementation,
+//UmbContextUnprovidedEventImplementation,
+ } from './context-provide.event.js';
 /**
  * @export
  * @class UmbContextProvider
@@ -27,7 +29,7 @@ export class UmbContextProvider {
          * @param {UmbContextRequestEvent} event
          * @memberof UmbContextProvider
          */
-        this._handleContextRequest = (event) => {
+        this.#handleContextRequest = (event) => {
             if (!isUmbContextRequestEvent(event))
                 return;
             if (event.contextAlias !== this._contextAlias)
@@ -51,11 +53,17 @@ export class UmbContextProvider {
         this._contextAlias = contextAlias.toString();
         this.#instance = instance;
     }
+    /**
+     * @private
+     * @param {UmbContextRequestEvent} event
+     * @memberof UmbContextProvider
+     */
+    #handleContextRequest;
     /**
      * @memberof UmbContextProvider
      */
     hostConnected() {
-        this.hostElement.addEventListener(umbContextRequestEventType, this._handleContextRequest);
+        this.hostElement.addEventListener(umbContextRequestEventType, this.#handleContextRequest);
         this.hostElement.dispatchEvent(new UmbContextProvideEventImplementation(this._contextAlias));
         // Listen to our debug event 'umb:debug-contexts'
         this.hostElement.addEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
@@ -64,11 +72,15 @@ export class UmbContextProvider {
      * @memberof UmbContextProvider
      */
     hostDisconnected() {
-        this.hostElement.removeEventListener(umbContextRequestEventType, this._handleContextRequest);
-        // TODO: fire unprovided event.
+        this.hostElement.removeEventListener(umbContextRequestEventType, this.#handleContextRequest);
+        // Out-commented for now, but kept if we like to reintroduce this:
+        //window.dispatchEvent(new UmbContextUnprovidedEventImplementation(this._contextAlias, this.#instance));
+        // Stop listen to our debug event 'umb:debug-contexts'
+        this.hostElement.removeEventListener(umbDebugContextEventType, this._handleDebugContextRequest);
     }
     destroy() {
-        // I want to make sure to call this, but for now it was too overwhelming to require the destroy method on context instances.
+        // We want to call a destroy method on the instance, if it has one.
         this.#instance?.destroy?.();
+        this.#instance = undefined;
     }
 }

package/dist-cms/libs/context-api/token/context-token.d.ts

@@ -1,6 +1,7 @@
-export declare class UmbContextToken<T = unknown> {
+export type UmbContextDiscriminator<BaseType, DiscriminatorResult extends BaseType> = (instance: BaseType) => instance is DiscriminatorResult;
+export declare class UmbContextToken<BaseType = unknown, ResultType extends BaseType = BaseType> {
+    #private;
     protected alias: string;
-    protected _desc?: string | undefined;
     /**
      * Get the type of the token
      *
@@ -10,14 +11,12 @@ export declare class UmbContextToken<T = unknown> {
      * @example   `typeof MyToken.TYPE`
      * @returns   undefined
      */
-    readonly TYPE: T;
+    readonly TYPE: ResultType;
     /**
-     * @param alias   Unique identifier for the token,
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
+     * @param alias   Unique identifier for the token
      */
-    constructor(alias: string, _desc?: string | undefined);
+    constructor(alias: string, discriminator?: UmbContextDiscriminator<BaseType, ResultType>);
+    getDiscriminator(): UmbContextDiscriminator<BaseType, ResultType> | undefined;
     /**
      * This method must always return the unique alias of the token since that
      * will be used to look up the token in the injector.

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

@@ -1,13 +1,10 @@
 export class UmbContextToken {
+    #discriminator;
     /**
-     * @param alias   Unique identifier for the token,
-     * @param _desc   Description for the token,
-     *                used only for debugging purposes,
-     *                it should but does not need to be unique
+     * @param alias   Unique identifier for the token
      */
-    constructor(alias, _desc) {
+    constructor(alias, discriminator) {
         this.alias = alias;
-        this._desc = _desc;
         /**
          * Get the type of the token
          *
@@ -18,6 +15,10 @@ export class UmbContextToken {
          * @returns   undefined
          */
         this.TYPE = undefined;
+        this.#discriminator = discriminator;
+    }
+    getDiscriminator() {
+        return this.#discriminator;
     }
     /**
      * This method must always return the unique alias of the token since that

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

@@ -80,6 +80,7 @@ export const UmbControllerHostBaseMixin = (superClass) => {
         }
         destroy() {
             this.#controllers.forEach((ctrl) => ctrl.destroy());
+            this.#controllers.length = 0;
         }
     }
     return UmbControllerHostBaseClass;

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

@@ -1,8 +1,14 @@
-import { HTMLElementConstructor } from '../extension-api/types.js';
-import { UmbControllerAlias } from './controller-alias.type.js';
-import { UmbControllerHost } from './controller-host.interface.js';
+import type { HTMLElementConstructor } from '../extension-api/types.js';
+import type { UmbControllerAlias } from './controller-alias.type.js';
+import type { UmbControllerHost } from './controller-host.interface.js';
 import type { UmbController } from './controller.interface.js';
+import type { UmbLocalizeController } from '../localization-api/index.js';
 export declare class UmbControllerHostElement extends HTMLElement implements UmbControllerHost {
+    /**
+     * Use the UmbLocalizeController to localize your element.
+     * @see UmbLocalizeController
+     */
+    localize: UmbLocalizeController;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

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

@@ -5,8 +5,8 @@ declare const UmbBaseController_base: (new (host: UmbControllerHost, controllerA
     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>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType_1 extends ResultType = ResultType>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType, ResultType>, instance: InstanceType_1): import("../context-api/index.js").UmbContextProviderController<BaseType, ResultType, InstanceType_1>;
+    consumeContext<BaseType_1 = unknown, ResultType_1 extends BaseType_1 = BaseType_1>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType_1, ResultType_1>, callback: import("../context-api/index.js").UmbContextCallback<ResultType_1>): import("../context-api/index.js").UmbContextConsumerController<BaseType_1, ResultType_1>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;
@@ -22,8 +22,8 @@ declare const UmbBaseController_base: (new (host: UmbControllerHost, controllerA
     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>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType_1 extends ResultType = ResultType>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType, ResultType>, instance: InstanceType_1): import("../context-api/index.js").UmbContextProviderController<BaseType, ResultType, InstanceType_1>;
+    consumeContext<BaseType_1 = unknown, ResultType_1 extends BaseType_1 = BaseType_1>(alias: string | import("../context-api/index.js").UmbContextToken<BaseType_1, ResultType_1>, callback: import("../context-api/index.js").UmbContextCallback<ResultType_1>): import("../context-api/index.js").UmbContextConsumerController<BaseType_1, ResultType_1>;
     hasController(controller: UmbController): boolean;
     getControllers(filterMethod: (ctrl: UmbController) => boolean): UmbController[];
     addController(controller: UmbController): void;

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

@@ -2,12 +2,19 @@ import type { Observable } from '../../external/rxjs/index.js';
 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';
+import { ObserverCallback, UmbObserverController } from '../observable-api/index.js';
 export declare class UmbElement extends UmbControllerHostElement {
+    /**
+     * @description Observe a RxJS source of choice.
+     * @param {Observable<T>} source RxJS source
+     * @param {method} callback Callback method called when data is changed.
+     * @return {UmbObserverController} Reference to a Observer Controller instance
+     * @memberof UmbElementMixin
+     */
     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>;
+    }, callback: ObserverCallback<T>, unique?: string): UmbObserverController<T>;
+    provideContext<BaseType = unknown, ResultType extends BaseType = BaseType, InstanceType extends ResultType = ResultType>(alias: string | UmbContextToken<BaseType, ResultType>, instance: InstanceType): UmbContextProviderController<BaseType, ResultType, InstanceType>;
+    consumeContext<BaseType = unknown, ResultType extends BaseType = BaseType>(alias: string | UmbContextToken<BaseType, ResultType>, callback: UmbContextCallback<ResultType>): UmbContextConsumerController<BaseType, ResultType>;
 }
 export declare const UmbElementMixin: <T extends HTMLElementConstructor>(superClass: T) => HTMLElementConstructor<UmbElement> & T;

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

@@ -1,8 +1,13 @@
+import { UmbLocalizeController } from '../localization-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 UmbControllerHostElementMixin(superClass) {
+        constructor() {
+            super(...arguments);
+            this.localize = new UmbLocalizeController(this);
+        }
         /**
          * @description Observe a RxJS source of choice.
          * @param {Observable<T>} source RxJS source
@@ -11,7 +16,7 @@ export const UmbElementMixin = (superClass) => {
          * @memberof UmbElementMixin
          */
         observe(source, callback, unique) {
-            return new UmbObserverController(this, source.asObservable ? source.asObservable() : source, callback, unique);
+            return new UmbObserverController(this, source, callback, unique);
         }
         /**
          * @description Provide a context API for this or child elements.

package/dist-cms/libs/extension-api/condition/condition-controller-arguments.type.d.ts

@@ -0,0 +1,7 @@
+import type { UmbConditionConfigBase } from '../types.js';
+import type { UmbControllerHost } from '../../controller-api/index.js';
+export type UmbConditionControllerArguments<ConditionConfigType extends UmbConditionConfigBase = UmbConditionConfigBase> = {
+    host: UmbControllerHost;
+    config: ConditionConfigType;
+    onChange: () => void;
+};

package/dist-cms/libs/extension-api/condition/condition-controller-arguments.type.js

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

package/dist-cms/libs/extension-api/condition/extension-condition.interface.d.ts

@@ -0,0 +1,6 @@
+import type { UmbConditionConfigBase } from '../types.js';
+import { UmbController } from '../../controller-api/index.js';
+export interface UmbExtensionCondition extends UmbController {
+    readonly permitted: boolean;
+    readonly config: UmbConditionConfigBase;
+}

package/dist-cms/libs/extension-api/condition/extension-condition.interface.js

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

package/dist-cms/libs/extension-api/condition/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extension-condition.interface.js';
+export * from './condition-controller-arguments.type.js';

package/dist-cms/libs/extension-api/condition/index.js

@@ -0,0 +1,2 @@
+export * from './extension-condition.interface.js';
+export * from './condition-controller-arguments.type.js';

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

@@ -0,0 +1,19 @@
+import { UmbBaseController, type UmbControllerHost } from '../../controller-api/index.js';
+import { type ManifestCondition, type ManifestWithDynamicConditions, type UmbExtensionRegistry } from '../index.js';
+export declare abstract class UmbBaseExtensionController<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, SubClassType = never> extends UmbBaseController {
+    #private;
+    protected _positive?: boolean;
+    get weight(): number;
+    get permitted(): boolean;
+    get manifest(): ManifestType | undefined;
+    get alias(): string;
+    get overwrites(): string[];
+    hasConditions: () => Promise<boolean>;
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: SubClassType) => void);
+    protected _init(): void;
+    asPromise(): Promise<void>;
+    protected abstract _conditionsAreGood(): Promise<boolean>;
+    protected abstract _conditionsAreBad(): Promise<void>;
+    equal(otherClass: UmbBaseExtensionController | undefined): boolean;
+    destroy(): void;
+}