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

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

@@ -0,0 +1,178 @@
+import { UmbBaseController } from '../../controller-api/index.js';
+import { createExtensionClass, } from '../index.js';
+export class UmbBaseExtensionController extends UmbBaseController {
+    #promiseResolvers;
+    #manifestObserver;
+    #extensionRegistry;
+    #alias;
+    #overwrites;
+    #manifest;
+    #conditionControllers;
+    #onPermissionChanged;
+    #isPermitted;
+    get weight() {
+        return this.#manifest?.weight ?? 0;
+    }
+    get permitted() {
+        return this.#isPermitted ?? false;
+    }
+    get manifest() {
+        return this.#manifest;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    get overwrites() {
+        return this.#overwrites;
+    }
+    constructor(host, extensionRegistry, alias, onPermissionChanged) {
+        super(host, alias);
+        this.#promiseResolvers = [];
+        this.#overwrites = [];
+        this.#conditionControllers = [];
+        this.hasConditions = async () => {
+            await this.#manifestObserver.asPromise();
+            return (this.#manifest?.conditions ?? []).length > 0;
+        };
+        this.#onConditionsChangedCallback = async () => {
+            const oldValue = this.#isPermitted ?? false;
+            // Find a condition that is not permitted (Notice how no conditions, means that this extension is permitted)
+            const isPositive = this.#conditionsAreInitialized() &&
+                this.#conditionControllers.find((condition) => condition.permitted === false) === undefined;
+            this._positive = isPositive;
+            if (isPositive) {
+                if (this.#isPermitted !== true) {
+                    this.#isPermitted = await this._conditionsAreGood();
+                }
+            }
+            else if (this.#isPermitted !== false) {
+                await this._conditionsAreBad();
+                this.#isPermitted = false;
+            }
+            if (oldValue !== this.#isPermitted) {
+                if (this.#isPermitted) {
+                    this.#promiseResolvers.forEach((x) => x());
+                    this.#promiseResolvers = [];
+                }
+                this.#onPermissionChanged(this.#isPermitted, this);
+            }
+        };
+        this.#extensionRegistry = extensionRegistry;
+        this.#alias = alias;
+        this.#onPermissionChanged = onPermissionChanged;
+    }
+    _init() {
+        this.#manifestObserver = this.observe(this.#extensionRegistry.getByAlias(this.#alias), async (extensionManifest) => {
+            this.#isPermitted = undefined;
+            this.#manifest = extensionManifest;
+            if (extensionManifest) {
+                if (extensionManifest.overwrites) {
+                    if (typeof extensionManifest.overwrites === 'string') {
+                        this.#overwrites = [extensionManifest.overwrites];
+                    }
+                    else if (Array.isArray(extensionManifest.overwrites)) {
+                        this.#overwrites = extensionManifest.overwrites;
+                    }
+                }
+                this.#gotConditions();
+            }
+            else {
+                this.#overwrites = [];
+                this.#cleanConditions();
+            }
+        });
+    }
+    asPromise() {
+        return new Promise((resolve) => {
+            this.#isPermitted === true ? resolve() : this.#promiseResolvers.push(resolve);
+        });
+    }
+    #cleanConditions() {
+        this.#conditionControllers.forEach((controller) => controller.destroy());
+        this.#conditionControllers = [];
+        this.removeControllerByAlias('_observeConditions');
+    }
+    #gotConditions() {
+        const conditionConfigs = this.#manifest?.conditions ?? [];
+        // As conditionConfigs might have been configured as something else than an array, then we ignorer them.
+        if (conditionConfigs.length === undefined || conditionConfigs.length === 0) {
+            this.#cleanConditions();
+            this.#onConditionsChangedCallback();
+            return;
+        }
+        const conditionAliases = conditionConfigs
+            .map((condition) => condition.alias)
+            .filter((value, index, array) => array.indexOf(value) === index);
+        const oldAmountOfControllers = this.#conditionControllers.length;
+        // Clean up conditions controllers based on keepers:
+        this.#conditionControllers = this.#conditionControllers.filter((current) => {
+            const continueExistence = conditionConfigs.find((config) => config === current.config);
+            if (!continueExistence) {
+                // Destroy condition that is no longer needed.
+                current.destroy();
+            }
+            return continueExistence;
+        });
+        // Check if there was no change in conditions:
+        // First check if any got removed(old amount equal controllers after clean-up)
+        // && check if any new is about to be added(old equal new amount):
+        const noChangeInConditions = oldAmountOfControllers === this.#conditionControllers.length &&
+            oldAmountOfControllers === conditionConfigs.length;
+        if (conditionConfigs.length > 0) {
+            // Observes the conditions and initialize as they come in.
+            this.observe(this.#extensionRegistry.getByTypeAndAliases('condition', conditionAliases), async (manifests) => {
+                // New comers:
+                manifests.forEach((conditionManifest) => {
+                    const configsOfThisType = conditionConfigs.filter((conditionConfig) => conditionConfig.alias === conditionManifest.alias);
+                    // Spin up conditions, based of condition configs:
+                    configsOfThisType.forEach(async (conditionConfig) => {
+                        // Check if we already have a controller for this config:
+                        const existing = this.#conditionControllers.find((controller) => controller.config === conditionConfig);
+                        if (!existing) {
+                            const conditionController = await createExtensionClass(conditionManifest, [
+                                {
+                                    host: this,
+                                    manifest: conditionManifest,
+                                    config: conditionConfig,
+                                    onChange: this.#onConditionsChangedCallback,
+                                },
+                            ]);
+                            if (conditionController) {
+                                // Some how listen to it? callback/event/onChange something.
+                                // then call this one: this.#onConditionsChanged();
+                                this.#conditionControllers.push(conditionController);
+                                this.#onConditionsChangedCallback();
+                            }
+                        }
+                    });
+                });
+            }, '_observeConditions');
+        }
+        else {
+            this.removeControllerByAlias('_observeConditions');
+        }
+        if (noChangeInConditions) {
+            // There was not change in the amount of conditions, but the manifest was changed, this means this.#isPermitted is set to undefined and this will always fire the callback:
+            this.#onConditionsChangedCallback();
+        }
+    }
+    #conditionsAreInitialized() {
+        // Not good if we don't have a manifest.
+        // Only good if conditions of manifest is equal to the amount of condition controllers (one for each condition).
+        return (this.#manifest !== undefined && this.#conditionControllers.length === (this.#manifest.conditions ?? []).length);
+    }
+    #onConditionsChangedCallback;
+    equal(otherClass) {
+        return otherClass?.manifest === this.manifest;
+    }
+    destroy() {
+        this.#promiseResolvers = [];
+        if (this.#isPermitted === true) {
+            this.#isPermitted = undefined;
+            this._conditionsAreBad();
+            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

@@ -0,0 +1,19 @@
+import type { ManifestBase, ManifestTypeMap, SpecificManifestTypeOrManifestBase, UmbBaseExtensionController, UmbExtensionRegistry } from '../index.js';
+import { UmbBaseController, UmbControllerHost } from '../../controller-api/index.js';
+export type PermittedControllerType<ControllerType extends {
+    manifest: any;
+}> = ControllerType & {
+    manifest: Required<Pick<ControllerType, 'manifest'>>;
+};
+/**
+ */
+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 {
+    #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);
+    protected _init(): void;
+    protected abstract _createController(manifest: ManifestType): ControllerType;
+    protected _extensionChanged: (isPermitted: boolean, controller: UmbBaseExtensionController<ManifestType>) => void;
+    destroy(): void;
+}

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

@@ -0,0 +1,112 @@
+import { map } from '../../../external/rxjs/index.js';
+import { UmbBaseController } from '../../controller-api/index.js';
+/**
+ */
+export class UmbBaseExtensionsController extends UmbBaseController {
+    #extensionRegistry;
+    #type;
+    #filter;
+    #onChange;
+    constructor(host, extensionRegistry, type, filter, onChange) {
+        super(host);
+        this._extensions = [];
+        this._permittedExts = [];
+        this.#gotManifests = (manifests) => {
+            if (!manifests) {
+                // Clean up:
+                this._extensions.forEach((controller) => {
+                    controller.destroy();
+                });
+                this._extensions.length = 0;
+                // _permittedExts should have been cleared via the destroy callbacks.
+                return;
+            }
+            // Clean up extensions that are no longer.
+            this._extensions = this._extensions.filter((controller) => {
+                if (!manifests.find((manifest) => manifest.alias === controller.alias)) {
+                    controller.destroy();
+                    // destroying the controller will, if permitted, make a last callback with isPermitted = false. This will also remove it from the _permittedExts array.
+                    return false;
+                }
+                return true;
+            });
+            // ---------------------------------------------------------------
+            // May change this into a Extensions Manager Controller???
+            // ---------------------------------------------------------------
+            manifests.forEach((manifest) => {
+                const existing = this._extensions.find((x) => x.alias === manifest.alias);
+                if (!existing) {
+                    // Idea: could be abstracted into a createController method, so we can override it in a subclass.
+                    // (This should be enough to be able to create a element extension controller instead.)
+                    this._extensions.push(this._createController(manifest));
+                }
+            });
+        };
+        this._extensionChanged = (isPermitted, controller) => {
+            let hasChanged = false;
+            const existingIndex = this._permittedExts.indexOf(controller);
+            if (isPermitted) {
+                if (existingIndex === -1) {
+                    this._permittedExts.push(controller);
+                    hasChanged = true;
+                }
+            }
+            else {
+                if (existingIndex !== -1) {
+                    this._permittedExts.splice(existingIndex, 1);
+                    hasChanged = true;
+                }
+            }
+            if (hasChanged) {
+                // The final list of permitted extensions to be displayed, this will be stripped from extensions that are overwritten by another extension and sorted accordingly.
+                const exposedPermittedExts = [...this._permittedExts];
+                // Removal of overwritten extensions:
+                this._permittedExts.forEach((extCtrl) => {
+                    // Check if it overwrites another extension:
+                    // if so, look up the extension it overwrites, and remove it from the list. and check that for if it overwrites another extension and so on.
+                    if (extCtrl.overwrites.length > 0) {
+                        extCtrl.overwrites.forEach((overwrite) => {
+                            this.#removeOverwrittenExtensions(exposedPermittedExts, overwrite);
+                        });
+                    }
+                });
+                // Sorting:
+                exposedPermittedExts.sort((a, b) => b.weight - a.weight);
+                this.#onChange(exposedPermittedExts, this);
+            }
+        };
+        this.#extensionRegistry = extensionRegistry;
+        this.#type = type;
+        this.#filter = filter;
+        this.#onChange = onChange;
+    }
+    _init() {
+        let source = Array.isArray(this.#type)
+            ? this.#extensionRegistry.extensionsOfTypes(this.#type)
+            : this.#extensionRegistry.extensionsOfType(this.#type);
+        if (this.#filter) {
+            source = source.pipe(map((extensions) => extensions.filter(this.#filter)));
+        }
+        this.observe(source, this.#gotManifests);
+    }
+    #gotManifests;
+    #removeOverwrittenExtensions(list, alias) {
+        const index = list.findIndex((a) => a.alias === alias);
+        if (index !== -1) {
+            const entry = list[index];
+            // Remove this extension:
+            list.splice(index, 1);
+            // Then remove other extensions that this was replacing:
+            if (entry.overwrites.length > 0) {
+                entry.overwrites.forEach((overwrite) => {
+                    this.#removeOverwrittenExtensions(list, overwrite);
+                });
+            }
+        }
+    }
+    destroy() {
+        super.destroy();
+        this._extensions.length = 0;
+        this._permittedExts.length = 0;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { ManifestCondition, ManifestWithDynamicConditions } from '../types.js';
+import { UmbBaseExtensionController } from './base-extension-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> {
+    #private;
+    _defaultElement?: string;
+    _component?: HTMLElement;
+    /**
+     * The component that is created for this extension.
+     * @readonly
+     * @type {(HTMLElement | undefined)}
+     */
+    get component(): HTMLElement | undefined;
+    get properties(): Record<string, unknown> | undefined;
+    set properties(newVal: Record<string, unknown> | undefined);
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: ControllerType) => void, defaultElement?: string);
+    protected _conditionsAreGood(): Promise<boolean>;
+    protected _conditionsAreBad(): Promise<void>;
+}

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

@@ -0,0 +1,82 @@
+import { createExtensionElement } from '../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 {
+    /**
+     * The component that is created for this extension.
+     * @readonly
+     * @type {(HTMLElement | undefined)}
+     */
+    get component() {
+        return this._component;
+    }
+    /**
+     * The props that are passed to the component.
+     * @type {Record<string, any>}
+     * @memberof UmbElementExtensionController
+     * @example
+     * ```ts
+     * const controller = new UmbElementExtensionController(host, extensionRegistry, alias, onPermissionChanged);
+     * controller.props = { foo: 'bar' };
+     * ```
+     * Is equivalent to:
+     * ```ts
+     * controller.component.foo = 'bar';
+     * ```
+     */
+    #properties;
+    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, onPermissionChanged, defaultElement) {
+        super(host, extensionRegistry, alias, onPermissionChanged);
+        this._defaultElement = defaultElement;
+        this._init();
+    }
+    #assignProperties = () => {
+        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];
+        });
+    };
+    async _conditionsAreGood() {
+        const manifest = this.manifest; // In this case we are sure its not undefined.
+        if (isManifestElementableType(manifest)) {
+            const newComponent = await createExtensionElement(manifest);
+            if (!this._positive) {
+                // We are not positive anymore, so we will back out of this creation.
+                return false;
+            }
+            this._component = newComponent;
+        }
+        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.
+        }
+        if (this._component) {
+            this.#assignProperties();
+            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();
+            }
+            this._component = undefined;
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { ManifestCondition, ManifestWithDynamicConditions } from '../types.js';
+import type { UmbExtensionRegistry } from '../registry/extension.registry.js';
+import { UmbBaseExtensionController } from './base-extension-controller.js';
+import type { UmbControllerHost } from '../../controller-api/index.js';
+export declare class UmbExtensionManifestController<ManifestType extends ManifestWithDynamicConditions = ManifestWithDynamicConditions> extends UmbBaseExtensionController<ManifestType> {
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestCondition>, alias: string, onPermissionChanged: (isPermitted: boolean, controller: UmbBaseExtensionController<ManifestType>) => void);
+    protected _conditionsAreGood(): Promise<boolean>;
+    protected _conditionsAreBad(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { UmbBaseExtensionController } from './base-extension-controller.js';
+export class UmbExtensionManifestController extends UmbBaseExtensionController {
+    constructor(host, extensionRegistry, alias, onPermissionChanged) {
+        super(host, extensionRegistry, alias, onPermissionChanged);
+        this._init();
+    }
+    async _conditionsAreGood() {
+        return true;
+    }
+    async _conditionsAreBad() {
+        // Destroy the element/class.
+    }
+}

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

@@ -0,0 +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 { 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> {
+    #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);
+    protected _createController(manifest: ManifestType): ControllerType;
+}

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

@@ -0,0 +1,29 @@
+import { UmbBaseExtensionsController } from './base-extensions-controller.js';
+import { UmbExtensionElementController, } from '../index.js';
+/**
+ */
+export class UmbExtensionsElementController extends UmbBaseExtensionsController {
+    //
+    #extensionRegistry;
+    #props;
+    get properties() {
+        return this.#props;
+    }
+    set properties(props) {
+        this.#props = props;
+        this._extensions.forEach((controller) => {
+            controller.properties = props;
+        });
+    }
+    constructor(host, extensionRegistry, type, filter, onChange, defaultElement) {
+        super(host, extensionRegistry, type, filter, onChange);
+        this.#extensionRegistry = extensionRegistry;
+        this._defaultElement = defaultElement;
+        this._init();
+    }
+    _createController(manifest) {
+        const extController = new UmbExtensionElementController(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

@@ -0,0 +1,11 @@
+import { UmbExtensionManifestController } from './extension-manifest-controller.js';
+import { type PermittedControllerType, UmbBaseExtensionsController } from './base-extensions-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> {
+    #private;
+    constructor(host: UmbControllerHost, extensionRegistry: UmbExtensionRegistry<ManifestTypes>, type: ManifestTypeName | Array<ManifestTypeName>, filter: null | ((manifest: ManifestType) => boolean), onChange: (permittedManifests: Array<MyPermittedControllerType>, controller: MyPermittedControllerType) => void);
+    protected _createController(manifest: ManifestType): ControllerType;
+}

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

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

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

@@ -0,0 +1,6 @@
+export * from './base-extension-controller.js';
+export * from './base-extensions-controller.js';
+export * from './extension-element-controller.js';
+export * from './extensions-element-controller.js';
+export * from './extension-manifest-controller.js';
+export * from './extensions-manifest-controller.js';

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

@@ -0,0 +1,6 @@
+export * from './base-extension-controller.js';
+export * from './base-extensions-controller.js';
+export * from './extension-element-controller.js';
+export * from './extensions-element-controller.js';
+export * from './extension-manifest-controller.js';
+export * from './extensions-manifest-controller.js';

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

@@ -1,12 +1,14 @@
 export * from './bundle-extension-initializer.js';
+export * from './condition/index.js';
+export * from './controller/index.js';
 export * from './create-extension-class.function.js';
 export * from './create-extension-element-or-fallback.function.js';
 export * from './create-extension-element.function.js';
 export * from './entry-point-extension-initializer.js';
+export * from './entry-point.interface.js';
 export * from './has-default-export.function.js';
 export * from './has-init-export.function.js';
 export * from './load-extension.function.js';
 export * from './registry/extension.registry.js';
 export * from './type-guards/index.js';
 export * from './types.js';
-export * from './entry-point.interface.js';

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

@@ -1,12 +1,14 @@
 export * from './bundle-extension-initializer.js';
+export * from './condition/index.js';
+export * from './controller/index.js';
 export * from './create-extension-class.function.js';
 export * from './create-extension-element-or-fallback.function.js';
 export * from './create-extension-element.function.js';
 export * from './entry-point-extension-initializer.js';
+export * from './entry-point.interface.js';
 export * from './has-default-export.function.js';
 export * from './has-init-export.function.js';
 export * from './load-extension.function.js';
 export * from './registry/extension.registry.js';
 export * from './type-guards/index.js';
 export * from './types.js';
-export * from './entry-point.interface.js';

package/dist-cms/libs/extension-api/registry/extension.registry.d.ts

@@ -12,11 +12,14 @@ export declare class UmbExtensionRegistry<IncomingManifestTypes extends Manifest
     unregisterMany(aliases: Array<string>): void;
     unregister(alias: string): void;
     isRegistered(alias: string): boolean;
+    private checkExtension;
     private _kindsOfType;
     private _extensionsOfType;
     private _kindsOfTypes;
     private _extensionsOfTypes;
+    getByAlias<T extends ManifestBase = ManifestBase>(alias: string): Observable<T | undefined>;
     getByTypeAndAlias<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, alias: string): Observable<T | undefined>;
+    getByTypeAndAliases<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, aliases: Array<string>): Observable<T[]>;
     extensionsOfType<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key): Observable<T[]>;
     extensionsOfTypes<ExtensionTypes extends ManifestBase = ManifestBase>(types: string[]): Observable<Array<ExtensionTypes>>;
 }