@umbraco-cms/backoffice 18.1.0 → 18.2.0-rc

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

@@ -14,6 +14,13 @@ import { UmbContextConsumerController } from './context-consumer.controller.js';
  *
  * This decorator supports both modern "standard" decorators (Stage 3 TC39 proposal) and
  * legacy TypeScript experimental decorators for backward compatibility.
+ *
+ * The consumer is registered directly via `addUmbController`, relying on the
+ * host's own lifecycle to fire `hostConnected` before first render. No Lit
+ * `ReactiveController` wrapper is needed — `UmbControllerHostMixin` lazy-inits
+ * its controllers list, so `addUmbController` is safe during `addInitializer`.
+ * @template BaseType
+ * @template {BaseType} ResultType
  * @param {UmbConsumeOptions} options Configuration object containing context, callback, and subscribe options
  * @example
  * ```ts
@@ -44,23 +51,42 @@ export function consumeContext(options) {
     });
 }
 /**
- * Sets up a standard decorator (Stage 3 TC39 proposal) for auto-accessors.
- * This branch is used when decorating with the 'accessor' keyword.
- * Example: @consumeContext({context: TOKEN}) accessor myProp?: Type;
- *
- * The decorator receives a ClassAccessorDecoratorContext object which provides
- * addInitializer() to run code during class construction.
- *
- * This is the modern, standardized decorator API that will be the standard
- * when Lit 4.x is released.
+ * Internal helper that registers an UmbContextConsumerController on the host.
  *
- * Note: Standard decorators currently don't work with @state()/@property()
- * decorators, which is why we still need the legacy branch.
- * @param protoOrTarget
- * @param decoratorContext
- * @param context
- * @param callback
- * @param subscribe
+ * Subscribing mode keeps the controller listening for context changes. Non-subscribing
+ * mode resolves once via `asPromise()` — that promise may reject (no provider
+ * resolves before the RAF timeout, or the host disconnects); the rejection is
+ * intentionally swallowed and the property is left unset.
+ * @param {UmbControllerHost} host The UmbControllerHost to attach the consumer to.
+ * @param {string | UmbContextToken<BaseType, ResultType>} context Context alias or token to request.
+ * @param {(value: ResultType | undefined) => void} assign Callback that writes the resolved value into the decorated field.
+ * @param {UmbContextCallback<ResultType> | undefined} callback Optional user callback forwarded to the consumer.
+ * @param {boolean} subscribe When true, subscribe to context changes; when false, resolve once.
+ */
+function setupConsumer(host, context, assign, callback, subscribe) {
+    if (subscribe) {
+        new UmbContextConsumerController(host, context, (value) => {
+            assign(value);
+            callback?.(value);
+        });
+        return;
+    }
+    const controller = new UmbContextConsumerController(host, context, callback);
+    controller
+        .asPromise()
+        .then((value) => assign(value))
+        .catch(() => {
+        // Expected when no provider resolves before timeout or the host disconnects.
+        // Leave the property as-is.
+    });
+}
+/**
+ * Standard decorator (Stage 3 TC39) path for `accessor` fields.
+ * @param {ClassAccessorDecoratorTarget<Interface<ReactiveEntity>, ResultType>} protoOrTarget The class prototype or target being decorated.
+ * @param {ClassAccessorDecoratorContext<Interface<ReactiveEntity>, ResultType>} decoratorContext The standard decorator context.
+ * @param {string | UmbContextToken<BaseType, ResultType>} context Context alias or token to request.
+ * @param {UmbContextCallback<ResultType> | undefined} callback Optional user callback forwarded to the consumer.
+ * @param {boolean} subscribe When true, subscribe to context changes; when false, resolve once.
  */
 function setupStandardDecorator(protoOrTarget, decoratorContext, context, callback, subscribe) {
     if (!('addInitializer' in decoratorContext)) {
@@ -69,103 +95,45 @@ function setupStandardDecorator(protoOrTarget, decoratorContext, context, callba
         return;
     }
     decoratorContext.addInitializer(function () {
-        queueMicrotask(() => {
-            if (subscribe) {
-                // Continuous subscription - stays active and updates property on context changes
-                new UmbContextConsumerController(this, context, (value) => {
-                    protoOrTarget.set.call(this, value);
-                    callback?.(value);
-                });
-            }
-            else {
-                // One-time consumption - uses asPromise() to get the value once and then cleans up
-                const controller = new UmbContextConsumerController(this, context, callback);
-                controller.asPromise().then((value) => {
-                    protoOrTarget.set.call(this, value);
-                });
-            }
-        });
+        setupConsumer(this, context, (value) => protoOrTarget.set.call(this, value), callback, subscribe);
     });
 }
 /**
- * Sets up a legacy decorator (TypeScript experimental) for regular properties.
- * This branch is used when decorating without the 'accessor' keyword.
- * Example: @consumeContext({context: TOKEN}) @state() myProp?: Type;
- *
- * The decorator receives:
- * - protoOrTarget: The class prototype
- * - propertyKey: The property name (string)
- *
- * This is the older TypeScript experimental decorator API, still widely used
- * in Umbraco because it works with @state() and @property() decorators.
- * The 'accessor' keyword is not compatible with these decorators yet.
- *
- * We support three initialization strategies:
- * 1. addInitializer (if available, e.g., on LitElement classes)
- * 2. hostConnected wrapper (for UmbController classes)
- * 3. Warning (if neither is available)
- * @param protoOrTarget
- * @param propertyKey
- * @param context
- * @param callback
- * @param subscribe
+ * Legacy decorator (TypeScript experimental) path for regular properties.
+ * @param {Interface<ReactiveEntity>} protoOrTarget The class prototype being decorated.
+ * @param {string} propertyKey The name of the decorated property.
+ * @param {string | UmbContextToken<BaseType, ResultType>} context Context alias or token to request.
+ * @param {UmbContextCallback<ResultType> | undefined} callback Optional user callback forwarded to the consumer.
+ * @param {boolean} subscribe When true, subscribe to context changes; when false, resolve once.
  */
 function setupLegacyDecorator(protoOrTarget, propertyKey, context, callback, subscribe) {
     const constructor = protoOrTarget.constructor;
-    // Strategy 1: Use addInitializer if available (LitElement classes)
+    // LitElement classes: use addInitializer for instance access at construction time.
     if (constructor.addInitializer) {
         constructor.addInitializer((element) => {
-            queueMicrotask(() => {
-                if (subscribe) {
-                    // Continuous subscription
-                    new UmbContextConsumerController(element, context, (value) => {
-                        element[propertyKey] = value;
-                        callback?.(value);
-                    });
-                }
-                else {
-                    // One-time consumption using asPromise()
-                    const controller = new UmbContextConsumerController(element, context, callback);
-                    controller.asPromise().then((value) => {
-                        element[propertyKey] = value;
-                    });
-                }
-            });
+            setupConsumer(element, context, (value) => {
+                element[propertyKey] = value;
+            }, callback, subscribe);
         });
         return;
     }
-    // Strategy 2: Wrap hostConnected for UmbController classes without addInitializer
+    // UmbControllerBase (non-Lit) classes: wrap hostConnected to set up on attach.
+    // We can't register at decoration time because we don't have an instance; wrapping
+    // hostConnected is the earliest hook available on the prototype.
     if ('hostConnected' in protoOrTarget && typeof protoOrTarget.hostConnected === 'function') {
         const originalHostConnected = protoOrTarget.hostConnected;
+        const setupMarker = Symbol(`consumeContext:${propertyKey}`);
         protoOrTarget.hostConnected = function () {
-            // Set up consumer once, using a flag to prevent multiple setups
-            if (!this.__consumeControllers) {
-                this.__consumeControllers = new Map();
-            }
-            if (!this.__consumeControllers.has(propertyKey)) {
-                if (subscribe) {
-                    // Continuous subscription
-                    const controller = new UmbContextConsumerController(this, context, (value) => {
-                        this[propertyKey] = value;
-                        callback?.(value);
-                    });
-                    this.__consumeControllers.set(propertyKey, controller);
-                }
-                else {
-                    // One-time consumption using asPromise()
-                    const controller = new UmbContextConsumerController(this, context, callback);
-                    controller.asPromise().then((value) => {
-                        this[propertyKey] = value;
-                    });
-                    // Don't store in map since it cleans itself up
-                }
+            if (!this[setupMarker]) {
+                this[setupMarker] = true;
+                setupConsumer(this, context, (value) => {
+                    this[propertyKey] = value;
+                }, callback, subscribe);
             }
-            // Call original hostConnected if it exists
             originalHostConnected?.call(this);
         };
         return;
     }
-    // Strategy 3: No supported initialization method available
     console.warn(`@consumeContext applied to ${constructor.name}.${propertyKey} but neither addInitializer nor hostConnected is available. ` +
         `Make sure the class extends UmbLitElement, UmbControllerBase, or implements UmbController with hostConnected.`);
 }

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

@@ -1,7 +1,7 @@
 /**
  * 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
+ * @param {Map<string, unknown>} contexts This is a map of the collected contexts from umb-debug
+ * @returns {Array<UmbDebugContextData>} An array of simplified context data
  */
 export declare function contextData(contexts: Map<any, any>): Array<UmbDebugContextData>;
 export interface UmbDebugContextData {

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

@@ -1,8 +1,8 @@
 /* eslint-disable no-case-declarations */
 /**
  * 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
+ * @param {Map<string, unknown>} contexts This is a map of the collected contexts from umb-debug
+ * @returns {Array<UmbDebugContextData>} An array of simplified context data
  */
 export function contextData(contexts) {
     const contextData = new Array();
@@ -14,8 +14,8 @@ export function contextData(contexts) {
 }
 /**
  * Used to find the methods and properties of a context
- * @param contextInstance The instance of the context
- * @returns A simplied object contain the properties and methods of the context
+ * @param {unknown} contextInstance The instance of the context
+ * @returns {UmbDebugContextItemData} A simplied object contain the properties and methods of the context
  */
 function contextItemData(contextInstance) {
     let contextItemData = { type: 'unknown' };
@@ -69,9 +69,8 @@ function contextItemData(contextInstance) {
 }
 /**
  * Gets a list of methods from a class
- * @param class The class to get the methods from
- * @param klass
- * @returns An array of method names as strings
+ * @param {object} klass The class to get the methods from
+ * @returns {Array<string>} An array of method names as strings
  */
 function getClassMethodNames(klass) {
     const isGetter = (x, name) => !!(Object.getOwnPropertyDescriptor(x, name) || {}).get;

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

@@ -8,7 +8,6 @@ export declare class UmbContextBoundary {
      * Creates an instance of UmbContextBoundary.
      * @param {EventTarget} eventTarget - the host element for this context provider
      * @param {string | UmbContextToken} contextIdentifier - a string or token to identify the context
-     * @param {*} instance - the instance to provide
      * @memberof UmbContextBoundary
      */
     constructor(eventTarget: EventTarget, contextIdentifier: string | UmbContextToken<any>);

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

@@ -10,7 +10,6 @@ export class UmbContextBoundary {
      * Creates an instance of UmbContextBoundary.
      * @param {EventTarget} eventTarget - the host element for this context provider
      * @param {string | UmbContextToken} contextIdentifier - a string or token to identify the context
-     * @param {*} instance - the instance to provide
      * @memberof UmbContextBoundary
      */
     constructor(eventTarget, contextIdentifier) {

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

@@ -65,7 +65,7 @@ export function provideContext(options) {
 /**
  * Sets up a standard decorator (Stage 3 TC39 proposal) for auto-accessors.
  * This branch is used when decorating with the 'accessor' keyword.
- * Example: @provideContext({context: TOKEN}) accessor myProp = new MyContext();
+ * Example: `@provideContext({context: TOKEN}) accessor myProp = new MyContext();`
  *
  * The decorator receives a ClassAccessorDecoratorContext object and returns
  * an accessor descriptor that intercepts the property initialization.
@@ -73,10 +73,11 @@ export function provideContext(options) {
  * This is the modern, standardized decorator API that will be the standard
  * when Lit 4.x is released.
  *
- * Note: Standard decorators currently don't work with @state()/@property()
+ * Note: Standard decorators currently don't work with `@state()`/`@property()`
  * decorators, which is why we still need the legacy branch.
- * @param protoOrTarget
- * @param context
+ * @param {ClassAccessorDecoratorTarget<unknown, InstanceType>} protoOrTarget The class prototype or target being decorated.
+ * @param {string | UmbContextToken<BaseType, ResultType>} context Context alias or token to provide.
+ * @returns {object} An accessor descriptor that intercepts the property initialization.
  */
 function setupStandardDecorator(protoOrTarget, context) {
     return {
@@ -87,10 +88,7 @@ function setupStandardDecorator(protoOrTarget, context) {
             return protoOrTarget.set.call(this, value);
         },
         init(value) {
-            // Defer controller creation to avoid timing issues with private fields
-            queueMicrotask(() => {
-                new UmbContextProviderController(this, context, value);
-            });
+            new UmbContextProviderController(this, context, value);
             return value;
         },
     };
@@ -98,30 +96,33 @@ function setupStandardDecorator(protoOrTarget, context) {
 /**
  * Sets up a legacy decorator (TypeScript experimental) for regular properties.
  * This branch is used when decorating without the 'accessor' keyword.
- * Example: @provideContext({context: TOKEN}) myProp = new MyContext();
+ * Example: `@provideContext({context: TOKEN}) myProp = new MyContext();`
  *
  * The decorator receives:
  * - protoOrTarget: The class prototype
  * - propertyKey: The property name (string)
  *
  * This is the older TypeScript experimental decorator API, still widely used
- * in Umbraco because it works with @state() and @property() decorators.
+ * in Umbraco because it works with `@state()` and `@property()` decorators.
  * The 'accessor' keyword is not compatible with these decorators yet.
  *
  * We support three initialization strategies:
  * 1. addInitializer (if available, e.g., on LitElement classes)
  * 2. hostConnected wrapper (for UmbController classes)
  * 3. Warning (if neither is available)
- * @param protoOrTarget
- * @param propertyKey
- * @param context
+ * @param {Interface<ReactiveEntity>} protoOrTarget The class prototype being decorated.
+ * @param {string} propertyKey The property name.
+ * @param {string | UmbContextToken<BaseType, ResultType>} context Context alias or token to provide.
  */
 function setupLegacyDecorator(protoOrTarget, propertyKey, context) {
     const constructor = protoOrTarget.constructor;
     // Strategy 1: Use addInitializer if available (LitElement classes)
     if (constructor.addInitializer) {
         constructor.addInitializer((element) => {
-            // Defer controller creation to avoid timing issues with private fields
+            // Defer to a microtask so the class-field initializer has run and
+            // element[propertyKey] is readable. addInitializer fires inside super(),
+            // which is before any subclass field initializer (including the one the
+            // decorator is attached to) runs.
             queueMicrotask(() => {
                 const initialValue = element[propertyKey];
                 new UmbContextProviderController(element, context, initialValue);

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

@@ -8,14 +8,14 @@ export declare class UmbContextProvider<BaseType extends UmbContextMinimal = Umb
     /**
      * Method to enable comparing the context providers by the instance they provide.
      * Note this method should have a unique name for the provider controller, for it not to be confused with a consumer.
-     * @returns {*}
+     * @returns {unknown} The provided instance.
      */
     providerInstance(): unknown;
     /**
      * Creates an instance of UmbContextProvider.
      * @param {EventTarget} eventTarget - the host element for this context provider
      * @param {string | UmbContextToken} contextIdentifier - a string or token to identify the context
-     * @param {*} instance - the instance to provide
+     * @param {ResultType} instance - the instance to provide
      * @memberof UmbContextProvider
      */
     constructor(eventTarget: EventTarget, contextIdentifier: string | UmbContextToken<BaseType, ResultType>, instance: ResultType);

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

@@ -11,7 +11,7 @@ export class UmbContextProvider {
     /**
      * Method to enable comparing the context providers by the instance they provide.
      * Note this method should have a unique name for the provider controller, for it not to be confused with a consumer.
-     * @returns {*}
+     * @returns {unknown} The provided instance.
      */
     providerInstance() {
         return this.#instance;
@@ -20,7 +20,7 @@ export class UmbContextProvider {
      * Creates an instance of UmbContextProvider.
      * @param {EventTarget} eventTarget - the host element for this context provider
      * @param {string | UmbContextToken} contextIdentifier - a string or token to identify the context
-     * @param {*} instance - the instance to provide
+     * @param {ResultType} instance - the instance to provide
      * @memberof UmbContextProvider
      */
     constructor(eventTarget, contextIdentifier, instance) {

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

@@ -12,27 +12,27 @@ export declare class UmbContextToken<BaseType extends UmbContextMinimal = UmbCon
     /**
      * Get the type of the token
      * @public
-     * @type      {T}
-     * @memberOf  UmbContextToken
+     * @type      {ResultType}
+     * @memberof UmbContextToken
      * @example   `typeof MyToken.TYPE`
      * @returns   undefined
      */
     readonly TYPE: ResultType;
     /**
-     * @param contextAlias   	Unique identifier for the context
-     * @param apiAlias   			Unique identifier for the api
-     * @param discriminator   A discriminator that will be used to discriminate the API — testing if the API lives up to a certain requirement. If the API does not meet the requirement then the consumer will not receive this API.
+     * @param {string} contextAlias   	Unique identifier for the context
+     * @param {string} apiAlias   			Unique identifier for the api
+     * @param {UmbContextDiscriminator<BaseType, ResultType>} discriminator   A discriminator that will be used to discriminate the API — testing if the API lives up to a certain requirement. If the API does not meet the requirement then the consumer will not receive this API.
      */
     constructor(contextAlias: string, apiAlias?: string, discriminator?: UmbContextDiscriminator<BaseType, ResultType>);
     /**
      * Get the discriminator method for the token
-     * @returns the discriminator method
+     * @returns {UmbContextDiscriminator<BaseType, ResultType> | undefined} the discriminator method
      */
     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.
-     * @returns the unique alias of the token
+     * @returns {string} the unique alias of the token
      */
     toString(): string;
 }

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

@@ -6,9 +6,9 @@
 export class UmbContextToken {
     #discriminator;
     /**
-     * @param contextAlias   	Unique identifier for the context
-     * @param apiAlias   			Unique identifier for the api
-     * @param discriminator   A discriminator that will be used to discriminate the API — testing if the API lives up to a certain requirement. If the API does not meet the requirement then the consumer will not receive this API.
+     * @param {string} contextAlias   	Unique identifier for the context
+     * @param {string} apiAlias   			Unique identifier for the api
+     * @param {UmbContextDiscriminator<BaseType, ResultType>} discriminator   A discriminator that will be used to discriminate the API — testing if the API lives up to a certain requirement. If the API does not meet the requirement then the consumer will not receive this API.
      */
     constructor(contextAlias, apiAlias = 'default', discriminator) {
         this.contextAlias = contextAlias;
@@ -16,8 +16,8 @@ export class UmbContextToken {
         /**
          * Get the type of the token
          * @public
-         * @type      {T}
-         * @memberOf  UmbContextToken
+         * @type      {ResultType}
+         * @memberof UmbContextToken
          * @example   `typeof MyToken.TYPE`
          * @returns   undefined
          */
@@ -26,7 +26,7 @@ export class UmbContextToken {
     }
     /**
      * Get the discriminator method for the token
-     * @returns the discriminator method
+     * @returns {UmbContextDiscriminator<BaseType, ResultType> | undefined} the discriminator method
      */
     getDiscriminator() {
         return this.#discriminator;
@@ -34,7 +34,7 @@ export class UmbContextToken {
     /**
      * This method must always return the unique alias of the token since that
      * will be used to look up the token in the injector.
-     * @returns the unique alias of the token
+     * @returns {string} the unique alias of the token
      */
     toString() {
         return this.contextAlias + '#' + this.apiAlias;

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

@@ -8,6 +8,12 @@ export interface UmbControllerHostBaseDeclaration extends Omit<UmbControllerHost
 /**
  * This mixin enables a class to host controllers.
  * This enables controllers to be added to the life cycle of this element.
+ *
+ * Internal storage uses TypeScript `private` + lazy `??=` initialization — the
+ * same pattern Lit's ReactiveElement uses for its own ReactiveController list.
+ * This allows `addUmbController` to be called during `addInitializer`
+ * callbacks (which run before subclass class-field initializers), mirroring
+ * Lit's behavior.
  * @param {object} superClass - superclass to be extended.
  * @mixin
  * @returns {UmbControllerHost} - A class which extends the given superclass.

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

@@ -1,14 +1,18 @@
 /**
  * This mixin enables a class to host controllers.
  * This enables controllers to be added to the life cycle of this element.
+ *
+ * Internal storage uses TypeScript `private` + lazy `??=` initialization — the
+ * same pattern Lit's ReactiveElement uses for its own ReactiveController list.
+ * This allows `addUmbController` to be called during `addInitializer`
+ * callbacks (which run before subclass class-field initializers), mirroring
+ * Lit's behavior.
  * @param {object} superClass - superclass to be extended.
  * @mixin
  * @returns {UmbControllerHost} - A class which extends the given superclass.
  */
 export const UmbControllerHostMixin = (superClass) => {
     class UmbControllerHostBaseClass extends superClass {
-        #controllers = [];
-        #attached = false;
         getHostElement() {
             return undefined;
         }
@@ -18,33 +22,34 @@ export const UmbControllerHostMixin = (superClass) => {
          * @returns {boolean} - true if the controller is assigned
          */
         hasUmbController(ctrl) {
-            return this.#controllers.indexOf(ctrl) !== -1;
+            return (this._controllers?.indexOf(ctrl) ?? -1) !== -1;
         }
         /**
          * Retrieve controllers matching a filter of this element.
-         * @param {Function} filterMethod - filter method
+         * @param {(ctrl: UmbController) => boolean} filterMethod - filter method
          * @returns {Array<UmbController>} - currently assigned controllers passing the filter method.
          */
         getUmbControllers(filterMethod) {
-            return this.#controllers.filter(filterMethod);
+            return this._controllers?.filter(filterMethod) ?? [];
         }
         /**
          * Append a controller to this element.
          * @param {UmbController} ctrl - the controller to append to this host.
          */
         addUmbController(ctrl) {
+            const controllers = (this._controllers ??= []);
             // If this specific class is already added, then skip out.
-            if (this.#controllers.indexOf(ctrl) !== -1) {
+            if (controllers.includes(ctrl)) {
                 return;
             }
             // Check if there is one already with same unique
             this.removeUmbControllerByAlias(ctrl.controllerAlias);
-            this.#controllers.push(ctrl);
-            if (this.#attached) {
+            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: [NL]
                 Promise.resolve().then(() => {
                     // Extra check to see if we are still attached and still added at this point:
-                    if (this.#attached && this.#controllers.includes(ctrl)) {
+                    if (this._attached && this._controllers?.includes(ctrl)) {
                         ctrl.hostConnected();
                     }
                 });
@@ -56,10 +61,12 @@ export const UmbControllerHostMixin = (superClass) => {
          * @param {UmbController} ctrl - The controller to remove and destroy from this host.
          */
         removeUmbController(ctrl) {
-            const index = this.#controllers.indexOf(ctrl);
+            if (!this._controllers)
+                return;
+            const index = this._controllers.indexOf(ctrl);
             if (index !== -1) {
-                this.#controllers.splice(index, 1);
-                if (this.#attached) {
+                this._controllers.splice(index, 1);
+                if (this._attached) {
                     ctrl.hostDisconnected();
                 }
                 ctrl.destroy();
@@ -68,11 +75,11 @@ export const UmbControllerHostMixin = (superClass) => {
         /**
          * Remove a controller from this element by its alias.
          * Notice this will also destroy the controller.
-         * @param {string | symbol} controllerAlias
+         * @param {string | symbol} controllerAlias The alias of the controller(s) to remove.
          */
         removeUmbControllerByAlias(controllerAlias) {
-            if (controllerAlias) {
-                this.#controllers.forEach((x) => {
+            if (controllerAlias && this._controllers) {
+                this._controllers.forEach((x) => {
                     if (x.controllerAlias === controllerAlias) {
                         this.removeUmbController(x);
                     }
@@ -80,20 +87,22 @@ export const UmbControllerHostMixin = (superClass) => {
             }
         }
         hostConnected() {
-            this.#attached = true;
+            this._attached = true;
             // Note: this might not be optimal, as if hostDisconnected remove one of the controllers, then the next controller will be skipped.
-            this.#controllers.forEach((ctrl) => ctrl.hostConnected());
+            this._controllers?.forEach((ctrl) => ctrl.hostConnected());
         }
         hostDisconnected() {
-            this.#attached = false;
+            this._attached = false;
             // Note: this might not be optimal, as if hostDisconnected remove one of the controllers, then the next controller will be skipped.
-            this.#controllers.forEach((ctrl) => ctrl.hostDisconnected());
+            this._controllers?.forEach((ctrl) => ctrl.hostDisconnected());
         }
         destroy() {
+            if (!this._controllers)
+                return;
             let ctrl;
             let prev = null;
             // Note: A very important way of doing this loop, as foreach will skip over the next item if the current item is removed.
-            while ((ctrl = this.#controllers[0])) {
+            while ((ctrl = this._controllers[0])) {
                 ctrl.destroy();
                 // Help developer realize that they made a mistake in code:
                 if (ctrl === prev) {
@@ -101,8 +110,8 @@ export const UmbControllerHostMixin = (superClass) => {
                 }
                 prev = ctrl;
             }
-            this.#controllers.length = 0;
-            this.#attached = false;
+            this._controllers.length = 0;
+            this._attached = false;
         }
     }
     return UmbControllerHostBaseClass;

package/dist-cms/libs/extension-api/controller/base-extension-initializer.controller.js

@@ -109,6 +109,12 @@ export class UmbBaseExtensionInitializer extends UmbControllerBase {
                         // Since this is a new call, then lets abort the pending call. [NL]
                         this.#abortPendingGoodCall();
                         await this._conditionsAreBad();
+                        // The manifest can be cleared during the await (e.g. the extension is
+                        // unregistered mid-navigation). _conditionsAreGood() asserts a non-null
+                        // manifest, so bail out here if it is gone.
+                        if (this.#manifest === undefined) {
+                            return;
+                        }
                         const abortController = new AbortController();
                         const promise = this._conditionsAreGood(abortController.signal);
                         entry = { manifest: this.#manifest, promise, abortController };

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

@@ -18,12 +18,12 @@ export declare class UmbExtensionApiInitializer<ManifestType extends ManifestApi
     /**
      * The api that is created for this extension.
      * @readonly
-     * @type {(class | undefined)}
+     * @type {ExtensionApiInterface | undefined}
      */
     get api(): ExtensionApiInterface | undefined;
     /**
      * The props that are passed to the class.
-     * @type {Record<string, any>}
+     * @type {Record<string, unknown>}
      * @memberof UmbExtensionApiController
      * @example
      * ```ts

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

@@ -15,14 +15,14 @@ export class UmbExtensionApiInitializer extends UmbBaseExtensionInitializer {
     /**
      * The api that is created for this extension.
      * @readonly
-     * @type {(class | undefined)}
+     * @type {ExtensionApiInterface | undefined}
      */
     get api() {
         return this.#api;
     }
     /**
      * The props that are passed to the class.
-     * @type {Record<string, any>}
+     * @type {Record<string, unknown>}
      * @memberof UmbExtensionApiController
      * @example
      * ```ts