@umbraco-cms/backoffice 14.0.0--preview004-a8f35fb0 → 14.0.0--preview004-024f35fe

package/dist-cms/apps/backoffice/backoffice.context.d.ts

@@ -1,11 +1,11 @@
 import { UmbContextToken } from '../../libs/context-api/index.js';
-import { UmbExtensionManifestController } from '../../libs/extension-api/index.js';
+import { UmbExtensionManifestInitializer } from '../../libs/extension-api/index.js';
 import { UmbControllerHost } from '../../libs/controller-api/index.js';
 import { ManifestSection } from '../../packages/core/extension-registry/index.js';
 export declare class UmbBackofficeContext {
     #private;
     readonly activeSectionAlias: import("rxjs").Observable<string | undefined>;
-    readonly allowedSections: import("rxjs").Observable<UmbExtensionManifestController<ManifestSection>[]>;
+    readonly allowedSections: import("rxjs").Observable<UmbExtensionManifestInitializer<ManifestSection, any>[]>;
     constructor(host: UmbControllerHost);
     setActiveSectionAlias(alias: string): void;
 }

package/dist-cms/custom-elements.json

@@ -404,8 +404,8 @@
       ]
     },
     {
-      "name": "umb-controller-host-initializer",
-      "path": "./../src/libs/controller-api/controller-host-initializer.element.ts",
+      "name": "umb-controller-host-provider",
+      "path": "./../src/libs/controller-api/controller-host-provider.element.ts",
       "properties": [
         {
           "name": "create",

package/dist-cms/libs/controller-api/{controller-host-initializer.element.d.ts → controller-host-provider.element.d.ts}

@@ -1,9 +1,9 @@
 import { UmbControllerHostElement } from './controller-host-element.mixin.js';
-declare const UmbControllerHostInitializerElement_base: import("../extension-api/types.js").HTMLElementConstructor<UmbControllerHostElement> & {
+declare const UmbControllerHostProviderElement_base: import("../extension-api/types.js").HTMLElementConstructor<UmbControllerHostElement> & {
     new (): HTMLElement;
     prototype: HTMLElement;
 };
-export declare class UmbControllerHostInitializerElement extends UmbControllerHostInitializerElement_base implements UmbControllerHostElement {
+export declare class UmbControllerHostProviderElement extends UmbControllerHostProviderElement_base implements UmbControllerHostElement {
     /**
      * A way to initialize controllers.
      * @required
@@ -14,7 +14,7 @@ export declare class UmbControllerHostInitializerElement extends UmbControllerHo
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'umb-controller-host-initializer': UmbControllerHostInitializerElement;
+        'umb-controller-host-provider': UmbControllerHostProviderElement;
     }
 }
 export {};

package/dist-cms/libs/controller-api/{controller-host-initializer.element.js → controller-host-provider.element.js}

@@ -1,5 +1,5 @@
 import { UmbControllerHostElementMixin } from './controller-host-element.mixin.js';
-export class UmbControllerHostInitializerElement extends UmbControllerHostElementMixin(HTMLElement) {
+export class UmbControllerHostProviderElement extends UmbControllerHostElementMixin(HTMLElement) {
     constructor() {
         super();
         this.attachShadow({ mode: 'open' });
@@ -13,4 +13,4 @@ export class UmbControllerHostInitializerElement extends UmbControllerHostElemen
         }
     }
 }
-customElements.define('umb-controller-host-initializer', UmbControllerHostInitializerElement);
+customElements.define('umb-controller-host-provider', UmbControllerHostProviderElement);

package/dist-cms/libs/extension-api/controller/{base-extension-controller.d.ts → base-extension-initializer.controller.d.ts}

@@ -1,6 +1,6 @@
 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 {
+export declare abstract class UmbBaseExtensionInitializer<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, SubClassType = never> extends UmbBaseController {
     #private;
     protected _positive?: boolean;
     get weight(): number;
@@ -9,11 +9,11 @@ export declare abstract class UmbBaseExtensionController<ManifestType extends Ma
     get alias(): string;
     get overwrites(): string[];
     hasConditions: () => Promise<boolean>;
-    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: SubClassType) => void);
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, extensionTypeName: string, 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;
+    equal(otherClass: UmbBaseExtensionInitializer | undefined): boolean;
     destroy(): void;
 }

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

@@ -1,6 +1,6 @@
 import { UmbBaseController } from '../../controller-api/index.js';
 import { createExtensionApi, } from '../index.js';
-export class UmbBaseExtensionController extends UmbBaseController {
+export class UmbBaseExtensionInitializer extends UmbBaseController {
     #promiseResolvers;
     #manifestObserver;
     #extensionRegistry;
@@ -25,8 +25,8 @@ export class UmbBaseExtensionController extends UmbBaseController {
     get overwrites() {
         return this.#overwrites;
     }
-    constructor(host, extensionRegistry, alias, onPermissionChanged) {
-        super(host, alias);
+    constructor(host, extensionRegistry, extensionTypeName, alias, onPermissionChanged) {
+        super(host, extensionTypeName + alias);
         this.#promiseResolvers = [];
         this.#overwrites = [];
         this.#conditionControllers = [];
@@ -54,7 +54,7 @@ export class UmbBaseExtensionController extends UmbBaseController {
                     this.#promiseResolvers.forEach((x) => x());
                     this.#promiseResolvers = [];
                 }
-                this.#onPermissionChanged(this.#isPermitted, this);
+                this.#onPermissionChanged?.(this.#isPermitted, this);
             }
         };
         this.#extensionRegistry = extensionRegistry;
@@ -170,7 +170,7 @@ export class UmbBaseExtensionController extends UmbBaseController {
         if (this.#isPermitted === true) {
             this.#isPermitted = undefined;
             this._conditionsAreBad();
-            this.#onPermissionChanged(false, this);
+            this.#onPermissionChanged?.(false, this);
         }
         super.destroy();
         // Destroy the conditions controllers, are begin destroyed cause they are controllers.

package/dist-cms/libs/extension-api/controller/{base-extensions-controller.d.ts → base-extensions-initializer.controller.d.ts}

@@ -1,4 +1,4 @@
-import type { ManifestBase, ManifestTypeMap, SpecificManifestTypeOrManifestBase, UmbBaseExtensionController, UmbExtensionRegistry } from '../index.js';
+import type { ManifestBase, ManifestTypeMap, SpecificManifestTypeOrManifestBase, UmbBaseExtensionInitializer, UmbExtensionRegistry } from '../index.js';
 import { UmbBaseController, UmbControllerHost } from '../../controller-api/index.js';
 export type PermittedControllerType<ControllerType extends {
     manifest: any;
@@ -7,13 +7,13 @@ export type PermittedControllerType<ControllerType extends {
 };
 /**
  */
-export declare abstract class UmbBaseExtensionsController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbBaseExtensionController<ManifestType> = UmbBaseExtensionController<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseController {
+export declare abstract class UmbBaseExtensionsInitializer<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbBaseExtensionInitializer<ManifestType> = UmbBaseExtensionInitializer<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseController {
     #private;
     protected _extensions: Array<ControllerType>;
     private _permittedExts;
-    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestType>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>, controller: MyPermittedControllerType) => void);
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestType>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange?: (permittedManifests: Array<MyPermittedControllerType>) => void);
     protected _init(): void;
     protected abstract _createController(manifest: ManifestType): ControllerType;
-    protected _extensionChanged: (isPermitted: boolean, controller: UmbBaseExtensionController<ManifestType>) => void;
+    protected _extensionChanged: (isPermitted: boolean, controller: ControllerType) => void;
     destroy(): void;
 }

package/dist-cms/libs/extension-api/controller/{base-extensions-controller.js → base-extensions-initializer.controller.js}

@@ -2,7 +2,7 @@ import { map } from '../../../external/rxjs/index.js';
 import { UmbBaseController } from '../../controller-api/index.js';
 /**
  */
-export class UmbBaseExtensionsController extends UmbBaseController {
+export class UmbBaseExtensionsInitializer extends UmbBaseController {
     #extensionRegistry;
     #type;
     #filter;
@@ -72,7 +72,7 @@ export class UmbBaseExtensionsController extends UmbBaseController {
                 });
                 // Sorting:
                 exposedPermittedExts.sort((a, b) => b.weight - a.weight);
-                this.#onChange(exposedPermittedExts, this);
+                this.#onChange?.(exposedPermittedExts);
             }
         };
         this.#extensionRegistry = extensionRegistry;
@@ -108,5 +108,6 @@ export class UmbBaseExtensionsController extends UmbBaseController {
         super.destroy();
         this._extensions.length = 0;
         this._permittedExts.length = 0;
+        this.#onChange?.(this._permittedExts);
     }
 }

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

@@ -0,0 +1,41 @@
+import { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { UmbApi, ManifestApi, ManifestCondition } from '../types.js';
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
+import { UmbControllerHost } from '../../controller-api/index.js';
+/**
+ * This Controller manages a single Extension and its API instance.
+ * When the extension is permitted to be used, its API will be instantiated and available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionApiController(host, extensionRegistry, alias, [], (permitted, ctrl) => { ctrl.api.helloWorld() }));
+* ```
+ * @export
+ * @class UmbExtensionApiController
+ */
+export declare class UmbExtensionApiInitializer<ManifestType extends ManifestApi = ManifestApi, ControllerType extends UmbExtensionApiInitializer<ManifestType, any> = any, ExtensionApiInterface extends UmbApi = ManifestType extends ManifestApi ? NonNullable<ManifestType['API_TYPE']> : UmbApi> extends UmbBaseExtensionInitializer<ManifestType, ControllerType> {
+    #private;
+    /**
+     * The api that is created for this extension.
+     * @readonly
+     * @type {(class | undefined)}
+     */
+    get api(): ExtensionApiInterface | undefined;
+    /**
+     * The props that are passed to the class.
+     * @type {Record<string, any>}
+     * @memberof UmbExtensionApiController
+     * @example
+     * ```ts
+     * const controller = new UmbExtensionApiController(host, extensionRegistry, alias, [], onPermissionChanged);
+     * controller.props = { foo: 'bar' };
+     * ```
+     * Is equivalent to:
+     * ```ts
+     * controller.component.foo = 'bar';
+     * ```
+     */
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, constructorArguments: Array<unknown> | undefined, onPermissionChanged?: (isPermitted: boolean, controller: ControllerType) => void);
+    protected _conditionsAreGood(): Promise<boolean>;
+    protected _conditionsAreBad(): Promise<void>;
+}

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

@@ -0,0 +1,95 @@
+import { createExtensionApi } from '../functions/create-extension-api.function.js';
+import { isManifestApiType } from '../type-guards/is-manifest-apiable-type.function.js';
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
+/**
+ * This Controller manages a single Extension and its API instance.
+ * When the extension is permitted to be used, its API will be instantiated and available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionApiController(host, extensionRegistry, alias, [], (permitted, ctrl) => { ctrl.api.helloWorld() }));
+* ```
+ * @export
+ * @class UmbExtensionApiController
+ */
+export class UmbExtensionApiInitializer extends UmbBaseExtensionInitializer {
+    #api;
+    #constructorArguments;
+    /**
+     * The api that is created for this extension.
+     * @readonly
+     * @type {(class | undefined)}
+     */
+    get api() {
+        return this.#api;
+    }
+    /**
+     * The props that are passed to the class.
+     * @type {Record<string, any>}
+     * @memberof UmbExtensionApiController
+     * @example
+     * ```ts
+     * const controller = new UmbExtensionApiController(host, extensionRegistry, alias, [], onPermissionChanged);
+     * controller.props = { foo: 'bar' };
+     * ```
+     * Is equivalent to:
+     * ```ts
+     * controller.component.foo = 'bar';
+     * ```
+     */
+    /*
+    #properties?: Record<string, unknown>;
+    get properties() {
+        return this.#properties;
+    }
+    set properties(newVal) {
+        this.#properties = newVal;
+        // TODO: we could optimize this so we only re-set the changed props.
+        this.#assignProperties();
+    }
+    */
+    constructor(host, extensionRegistry, alias, constructorArguments, onPermissionChanged) {
+        super(host, extensionRegistry, 'extApi_', alias, onPermissionChanged);
+        this.#constructorArguments = constructorArguments;
+        this._init();
+    }
+    /*
+    #assignProperties = () => {
+        if (!this._api || !this.#properties) return;
+
+        // TODO: we could optimize this so we only re-set the updated props.
+        Object.keys(this.#properties).forEach((key) => {
+            (this._api as any)[key] = this.#properties![key];
+        });
+    };
+    */
+    async _conditionsAreGood() {
+        const manifest = this.manifest; // In this case we are sure its not undefined.
+        if (isManifestApiType(manifest)) {
+            const newApi = await createExtensionApi(manifest, this.#constructorArguments);
+            if (!this._positive) {
+                // We are not positive anymore, so we will back out of this creation.
+                return false;
+            }
+            this.#api = newApi;
+        }
+        else {
+            this.#api = undefined;
+            console.warn('Manifest did not provide any useful data for a api class to construct.');
+        }
+        if (this.#api) {
+            //this.#assignProperties();
+            return true; // we will confirm we have a component and are still good to go.
+        }
+        return false; // we will reject the state, we have no component, we are not good to be shown.
+    }
+    async _conditionsAreBad() {
+        // Destroy the api:
+        if (this.#api) {
+            if ('destroy' in this.#api) {
+                this.#api.destroy();
+            }
+            this.#api = undefined;
+        }
+    }
+}

package/dist-cms/libs/extension-api/controller/{extension-element-controller.d.ts → extension-element-initializer.controller.d.ts}

@@ -1,11 +1,20 @@
 import { UmbExtensionRegistry } from '../registry/extension.registry.js';
 import { ManifestCondition, ManifestWithDynamicConditions } from '../types.js';
-import { UmbBaseExtensionController } from './base-extension-controller.js';
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
 import { UmbControllerHost } from '../../controller-api/index.js';
-export declare class UmbExtensionElementController<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, ControllerType extends UmbExtensionElementController<ManifestType> = any> extends UmbBaseExtensionController<ManifestType, ControllerType> {
+/**
+ * This Controller manages a single Extension and its Element.
+ * When the extension is permitted to be used, its Element will be instantiated and available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionElementController(host, extensionRegistry, alias, (permitted, ctrl) => { console.log("Extension is permitted and this is the element: ", ctrl.component) }));
+* ```
+ * @export
+ * @class UmbExtensionElementController
+ */
+export declare class UmbExtensionElementInitializer<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, ControllerType extends UmbExtensionElementInitializer<ManifestType, any> = any> extends UmbBaseExtensionInitializer<ManifestType, ControllerType> {
     #private;
-    _defaultElement?: string;
-    _component?: HTMLElement;
     /**
      * The component that is created for this extension.
      * @readonly

package/dist-cms/libs/extension-api/controller/{extension-element-controller.js → extension-element-initializer.controller.js}

@@ -1,14 +1,27 @@
 import { createExtensionElement } from '../functions/create-extension-element.function.js';
 import { isManifestElementableType } from '../type-guards/is-manifest-elementable-type.function.js';
-import { UmbBaseExtensionController } from './base-extension-controller.js';
-export class UmbExtensionElementController extends UmbBaseExtensionController {
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
+/**
+ * This Controller manages a single Extension and its Element.
+ * When the extension is permitted to be used, its Element will be instantiated and available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionElementController(host, extensionRegistry, alias, (permitted, ctrl) => { console.log("Extension is permitted and this is the element: ", ctrl.component) }));
+* ```
+ * @export
+ * @class UmbExtensionElementController
+ */
+export class UmbExtensionElementInitializer extends UmbBaseExtensionInitializer {
+    #defaultElement;
+    #component;
     /**
      * The component that is created for this extension.
      * @readonly
      * @type {(HTMLElement | undefined)}
      */
     get component() {
-        return this._component;
+        return this.#component;
     }
     /**
      * The props that are passed to the component.
@@ -34,49 +47,49 @@ export class UmbExtensionElementController extends UmbBaseExtensionController {
         this.#assignProperties();
     }
     constructor(host, extensionRegistry, alias, onPermissionChanged, defaultElement) {
-        super(host, extensionRegistry, alias, onPermissionChanged);
-        this._defaultElement = defaultElement;
+        super(host, extensionRegistry, 'extElement_', alias, onPermissionChanged);
+        this.#defaultElement = defaultElement;
         this._init();
     }
     #assignProperties = () => {
-        if (!this._component || !this.#properties)
+        if (!this.#component || !this.#properties)
             return;
         // TODO: we could optimize this so we only re-set the updated props.
         Object.keys(this.#properties).forEach((key) => {
-            this._component[key] = this.#properties[key];
+            this.#component[key] = this.#properties[key];
         });
     };
     async _conditionsAreGood() {
         const manifest = this.manifest; // In this case we are sure its not undefined.
         if (isManifestElementableType(manifest)) {
-            const newComponent = await createExtensionElement(manifest, this._defaultElement);
+            const newComponent = await createExtensionElement(manifest, this.#defaultElement);
             if (!this._positive) {
                 // We are not positive anymore, so we will back out of this creation.
                 return false;
             }
-            this._component = newComponent;
+            this.#component = newComponent;
         }
-        else if (this._defaultElement) {
-            this._component = document.createElement(this._defaultElement);
+        else if (this.#defaultElement) {
+            this.#component = document.createElement(this.#defaultElement);
         }
         else {
-            this._component = undefined;
-            // TODO: Lets make an console.error in this case? we could not initialize any component based on this manifest.
+            this.#component = undefined;
+            console.warn('Manifest did not provide any useful data for a web component to be created.');
         }
-        if (this._component) {
+        if (this.#component) {
             this.#assignProperties();
-            this._component.manifest = manifest;
+            this.#component.manifest = manifest;
             return true; // we will confirm we have a component and are still good to go.
         }
         return false; // we will reject the state, we have no component, we are not good to be shown.
     }
     async _conditionsAreBad() {
         // Destroy the element:
-        if (this._component) {
-            if ('destroy' in this._component) {
-                this._component.destroy();
+        if (this.#component) {
+            if ('destroy' in this.#component) {
+                this.#component.destroy();
             }
-            this._component = undefined;
+            this.#component = undefined;
         }
     }
 }

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

@@ -0,0 +1,20 @@
+import type { ManifestCondition, ManifestWithDynamicConditions } from '../types.js';
+import type { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
+import type { UmbControllerHost } from '../../controller-api/index.js';
+/**
+ * This Controller manages a single Extension and its Manifest.
+ * When the extension is permitted to be used, the manifest is available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionManifestController(host, extensionRegistry, alias, (permitted, ctrl) => { console.log("Extension is permitted and this is the manifest: ", ctrl.manifest) }));
+* ```
+ * @export
+ * @class UmbExtensionManifestController
+ */
+export declare class UmbExtensionManifestInitializer<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions, ControllerType extends UmbBaseExtensionInitializer<ManifestType, any> = any> extends UmbBaseExtensionInitializer<ManifestType, ControllerType> {
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: ControllerType) => void);
+    protected _conditionsAreGood(): Promise<boolean>;
+    protected _conditionsAreBad(): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+import { UmbBaseExtensionInitializer } from './base-extension-initializer.controller.js';
+/**
+ * This Controller manages a single Extension and its Manifest.
+ * When the extension is permitted to be used, the manifest is available for the consumer.
+ *
+ * @example
+* ```ts
+* const controller = new UmbExtensionManifestController(host, extensionRegistry, alias, (permitted, ctrl) => { console.log("Extension is permitted and this is the manifest: ", ctrl.manifest) }));
+* ```
+ * @export
+ * @class UmbExtensionManifestController
+ */
+export class UmbExtensionManifestInitializer extends UmbBaseExtensionInitializer {
+    constructor(host, extensionRegistry, alias, onPermissionChanged) {
+        super(host, extensionRegistry, 'extManifest_', alias, onPermissionChanged);
+        this._init();
+    }
+    async _conditionsAreGood() {
+        return true;
+    }
+    async _conditionsAreBad() {
+        // Destroy the element/class.
+    }
+}

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

@@ -0,0 +1,21 @@
+import { type PermittedControllerType, UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
+import { UmbExtensionApiInitializer } from './extension-api-initializer.controller.js';
+import { type ManifestTypeMap, type SpecificManifestTypeOrManifestBase, type UmbExtensionRegistry, ManifestApi, ManifestBase } from '../index.js';
+import type { UmbControllerHost } from '../../controller-api/index.js';
+/**
+ * This Controller manages a set of Extensions and their Manifest.
+ * When one or more extensions is permitted to be used, the callback gives all permitted extensions and their manifest.
+ *
+ * @example
+* ```ts
+TODO: Correct this, start using builder pattern:
+* const controller = new UmbExtensionsApiInitializer(host, extensionRegistry, type, ['constructor argument 1', 'constructor argument '], filter?, (permitted, ctrl) => { console.log("Extension is permitted and this is the manifest: ", ctrl.manifest) }));
+* ```
+ * @export
+ * @class UmbExtensionsApiInitializer
+ */
+export declare class UmbExtensionsApiInitializer<ManifestTypes extends ManifestApi, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string = string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ManifestTypeAsApi extends ManifestApi = ManifestType extends ManifestApi ? ManifestType : never, ControllerType extends UmbExtensionApiInitializer<ManifestTypeAsApi> = UmbExtensionApiInitializer<ManifestTypeAsApi>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseExtensionsInitializer<ManifestTypes, ManifestTypeName, ManifestTypeAsApi, ControllerType, MyPermittedControllerType> {
+    #private;
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, constructorArguments: Array<unknown> | undefined, filter?: undefined | null | ((manifest: ManifestTypeAsApi) => boolean), onChange?: (permittedManifests: Array<MyPermittedControllerType>) => void);
+    protected _createController(manifest: ManifestTypeAsApi): ControllerType;
+}

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

@@ -0,0 +1,42 @@
+import { UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
+import { UmbExtensionApiInitializer } from './extension-api-initializer.controller.js';
+/**
+ * This Controller manages a set of Extensions and their Manifest.
+ * When one or more extensions is permitted to be used, the callback gives all permitted extensions and their manifest.
+ *
+ * @example
+* ```ts
+TODO: Correct this, start using builder pattern:
+* const controller = new UmbExtensionsApiInitializer(host, extensionRegistry, type, ['constructor argument 1', 'constructor argument '], filter?, (permitted, ctrl) => { console.log("Extension is permitted and this is the manifest: ", ctrl.manifest) }));
+* ```
+ * @export
+ * @class UmbExtensionsApiInitializer
+ */
+export class UmbExtensionsApiInitializer extends UmbBaseExtensionsInitializer {
+    //
+    #extensionRegistry;
+    /*
+    #props?: Record<string, unknown>;
+
+    public get properties() {
+        return this.#props;
+    }
+    public set properties(props: Record<string, unknown> | undefined) {
+        this.#props = props;
+        this._extensions.forEach((controller) => {
+            controller.properties = props;
+        });
+    }
+    */
+    #constructorArgs;
+    constructor(host, extensionRegistry, type, constructorArguments, filter, onChange) {
+        super(host, extensionRegistry, type, filter, onChange);
+        this.#extensionRegistry = extensionRegistry;
+        this.#constructorArgs = constructorArguments;
+        this._init();
+    }
+    _createController(manifest) {
+        const extController = new UmbExtensionApiInitializer(this, this.#extensionRegistry, manifest.alias, this.#constructorArgs, this._extensionChanged);
+        return extController;
+    }
+}

package/dist-cms/libs/extension-api/controller/{extensions-element-controller.d.ts → extensions-element-initializer.controller.d.ts}

@@ -1,13 +1,13 @@
-import { type PermittedControllerType, UmbBaseExtensionsController } from './base-extensions-controller.js';
-import { type ManifestBase, type ManifestTypeMap, type SpecificManifestTypeOrManifestBase, UmbExtensionElementController, type UmbExtensionRegistry } from '../index.js';
+import { type PermittedControllerType, UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
+import { type ManifestBase, type ManifestTypeMap, type SpecificManifestTypeOrManifestBase, UmbExtensionElementInitializer, type UmbExtensionRegistry } from '../index.js';
 import type { UmbControllerHost } from '../../controller-api/index.js';
 /**
  */
-export declare class UmbExtensionsElementController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string = string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbExtensionElementController<ManifestType> = UmbExtensionElementController<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseExtensionsController<ManifestTypes, ManifestTypeName, ManifestType, ControllerType, MyPermittedControllerType> {
+export declare class UmbExtensionsElementController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string = string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbExtensionElementInitializer<ManifestType> = UmbExtensionElementInitializer<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseExtensionsInitializer<ManifestTypes, ManifestTypeName, ManifestType, ControllerType, MyPermittedControllerType> {
     #private;
     private _defaultElement?;
     get properties(): Record<string, unknown> | undefined;
     set properties(props: Record<string, unknown> | undefined);
-    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>, controller: MyPermittedControllerType) => void, defaultElement?: string);
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: undefined | null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>) => void, defaultElement?: string);
     protected _createController(manifest: ManifestType): ControllerType;
 }

package/dist-cms/libs/extension-api/controller/{extensions-element-controller.js → extensions-element-initializer.controller.js}

@@ -1,8 +1,8 @@
-import { UmbBaseExtensionsController } from './base-extensions-controller.js';
-import { UmbExtensionElementController, } from '../index.js';
+import { UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
+import { UmbExtensionElementInitializer, } from '../index.js';
 /**
  */
-export class UmbExtensionsElementController extends UmbBaseExtensionsController {
+export class UmbExtensionsElementController extends UmbBaseExtensionsInitializer {
     //
     #extensionRegistry;
     #props;
@@ -22,7 +22,7 @@ export class UmbExtensionsElementController extends UmbBaseExtensionsController
         this._init();
     }
     _createController(manifest) {
-        const extController = new UmbExtensionElementController(this, this.#extensionRegistry, manifest.alias, this._extensionChanged, this._defaultElement);
+        const extController = new UmbExtensionElementInitializer(this, this.#extensionRegistry, manifest.alias, this._extensionChanged, this._defaultElement);
         extController.properties = this.#props;
         return extController;
     }

package/dist-cms/libs/extension-api/controller/{extensions-manifest-controller.d.ts → extensions-manifest-initializer.controller.d.ts}

@@ -1,11 +1,11 @@
-import { UmbExtensionManifestController } from './extension-manifest-controller.js';
-import { type PermittedControllerType, UmbBaseExtensionsController } from './base-extensions-controller.js';
+import { UmbExtensionManifestInitializer } from './extension-manifest-initializer.controller.js';
+import { type PermittedControllerType, UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
 import { ManifestBase, ManifestTypeMap, SpecificManifestTypeOrManifestBase, UmbExtensionRegistry } from '../index.js';
 import { UmbControllerHost } from '../../controller-api/index.js';
 /**
  */
-export declare class UmbExtensionsManifestController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbExtensionManifestController<ManifestType> = UmbExtensionManifestController<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseExtensionsController<ManifestTypes, ManifestTypeName, ManifestType, ControllerType, MyPermittedControllerType> {
+export declare class UmbExtensionsManifestController<ManifestTypes extends ManifestBase, ManifestTypeName extends keyof ManifestTypeMap<ManifestTypes> | string, ManifestType extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, ManifestTypeName>, ControllerType extends UmbExtensionManifestInitializer<ManifestType> = UmbExtensionManifestInitializer<ManifestType>, MyPermittedControllerType extends ControllerType = PermittedControllerType<ControllerType>> extends UmbBaseExtensionsInitializer<ManifestTypes, ManifestTypeName, ManifestType, ControllerType, MyPermittedControllerType> {
     #private;
-    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>, controller: MyPermittedControllerType) => void);
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>) => void);
     protected _createController(manifest: ManifestType): ControllerType;
 }

package/dist-cms/libs/extension-api/controller/{extensions-manifest-controller.js → extensions-manifest-initializer.controller.js}

@@ -1,8 +1,8 @@
-import { UmbExtensionManifestController } from './extension-manifest-controller.js';
-import { UmbBaseExtensionsController } from './base-extensions-controller.js';
+import { UmbExtensionManifestInitializer } from './extension-manifest-initializer.controller.js';
+import { UmbBaseExtensionsInitializer } from './base-extensions-initializer.controller.js';
 /**
  */
-export class UmbExtensionsManifestController extends UmbBaseExtensionsController {
+export class UmbExtensionsManifestController extends UmbBaseExtensionsInitializer {
     //
     #extensionRegistry;
     constructor(host, extensionRegistry, type, filter, onChange) {
@@ -11,6 +11,6 @@ export class UmbExtensionsManifestController extends UmbBaseExtensionsController
         this._init();
     }
     _createController(manifest) {
-        return new UmbExtensionManifestController(this, this.#extensionRegistry, manifest.alias, this._extensionChanged);
+        return new UmbExtensionManifestInitializer(this, this.#extensionRegistry, manifest.alias, this._extensionChanged);
     }
 }