@umbraco-cms/backoffice 14.0.0-b0704cee → 14.0.0-c26a40c4

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

@@ -16,7 +16,9 @@ export declare class UmbExtensionRegistry<IncomingManifestTypes extends Manifest
     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>>;
 }

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

@@ -1,5 +1,5 @@
 import { UmbBasicState } from '../../observable-api/index.js';
-import { map, distinctUntilChanged, combineLatest } from '../../../external/rxjs/index.js';
+import { map, distinctUntilChanged, combineLatest, of, switchMap, } from '../../../external/rxjs/index.js';
 function extensionArrayMemoization(previousValue, currentValue) {
     // If length is different, data is different:
     if (previousValue.length !== currentValue.length) {
@@ -11,7 +11,6 @@ function extensionArrayMemoization(previousValue, currentValue) {
     }
     return true;
 }
-// Note: Keeping the memoization in two separate function, for performance concern.
 function extensionAndKindMatchArrayMemoization(previousValue, currentValue) {
     // If length is different, data is different:
     if (previousValue.length !== currentValue.length) {
@@ -39,6 +38,12 @@ function extensionSingleMemoization(previousValue, currentValue) {
     }
     return previousValue === currentValue;
 }
+function extensionAndKindMatchSingleMemoization(previousValue, currentValue) {
+    if (previousValue && currentValue) {
+        return (previousValue.alias === currentValue.alias && previousValue.isMatchedWithKind === currentValue.isMatchedWithKind);
+    }
+    return previousValue === currentValue;
+}
 const sortExtensions = (a, b) => (b.weight || 0) - (a.weight || 0);
 export class UmbExtensionRegistry {
     constructor() {
@@ -49,6 +54,12 @@ export class UmbExtensionRegistry {
         this.kinds = this._kinds.asObservable();
     }
     defineKind(kind) {
+        const extensionsValues = this._extensions.getValue();
+        const extension = extensionsValues.find((extension) => extension.alias === kind.alias);
+        if (extension) {
+            console.error(`Extension Kind with alias ${kind.alias} is already registered`);
+            return;
+        }
         const nextData = this._kinds
             .getValue()
             .filter((k) => !(k.matchType === kind.matchType &&
@@ -57,7 +68,14 @@ export class UmbExtensionRegistry {
         this._kinds.next(nextData);
     }
     register(manifest) {
-        // TODO: Consider if we need to implement some safety features here, like checking if the object has a 'type' and/or 'alias'?
+        if (!manifest.type) {
+            console.error(`Extension is missing type`, manifest);
+            return;
+        }
+        if (!manifest.alias) {
+            console.error(`Extension is missing alias`, manifest);
+            return;
+        }
         if (manifest.type === 'kind') {
             this.defineKind(manifest);
             return;
@@ -110,6 +128,29 @@ export class UmbExtensionRegistry {
     _extensionsOfTypes(types) {
         return this.extensions.pipe(map((exts) => exts.filter((ext) => types.indexOf(ext.type) !== -1)), distinctUntilChanged(extensionArrayMemoization));
     }
+    getByAlias(alias) {
+        return this.extensions.pipe(map((exts) => exts.find((ext) => ext.alias === alias)), distinctUntilChanged(extensionSingleMemoization), switchMap((ext) => {
+            if (ext?.kind) {
+                return this._kindsOfType(ext.type).pipe(map((kinds) => {
+                    // Specific Extension Meta merge (does not merge conditions)
+                    if (ext) {
+                        // Since we dont have the type up front in this request, we will just get all kinds here and find the matching one:
+                        const baseManifest = kinds.find((kind) => kind.matchKind === ext.kind)?.manifest;
+                        // TODO: This check can go away when making a find kind based on type and kind.
+                        if (baseManifest) {
+                            const merged = { isMatchedWithKind: true, ...baseManifest, ...ext };
+                            if (baseManifest.meta) {
+                                merged.meta = { ...baseManifest.meta, ...ext.meta };
+                            }
+                            return merged;
+                        }
+                    }
+                    return ext;
+                }));
+            }
+            return of(ext);
+        }), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
+    }
     getByTypeAndAlias(type, alias) {
         return combineLatest([
             this.extensions.pipe(map((exts) => exts.find((ext) => ext.type === type && ext.alias === alias)), distinctUntilChanged(extensionSingleMemoization)),
@@ -128,7 +169,26 @@ export class UmbExtensionRegistry {
                 }
             }
             return ext;
-        }), distinctUntilChanged(extensionSingleMemoization));
+        }), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
+    }
+    getByTypeAndAliases(type, aliases) {
+        return combineLatest([
+            this.extensions.pipe(map((exts) => exts.filter((ext) => ext.type === type && aliases.indexOf(ext.alias) !== -1)), distinctUntilChanged(extensionArrayMemoization)),
+            this._kindsOfType(type),
+        ]).pipe(map(([exts, kinds]) => exts
+            .map((ext) => {
+            // Specific Extension Meta merge (does not merge conditions)
+            const baseManifest = kinds.find((kind) => kind.matchKind === ext.kind)?.manifest;
+            if (baseManifest) {
+                const merged = { isMatchedWithKind: true, ...baseManifest, ...ext };
+                if (baseManifest.meta) {
+                    merged.meta = { ...baseManifest.meta, ...ext.meta };
+                }
+                return merged;
+            }
+            return ext;
+        })
+            .sort(sortExtensions)), distinctUntilChanged(extensionAndKindMatchArrayMemoization));
     }
     extensionsOfType(type) {
         return combineLatest([this._extensionsOfType(type), this._kindsOfType(type)]).pipe(map(([exts, kinds]) => exts

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

@@ -1,5 +1,5 @@
-import { UmbEntryPointModule } from './entry-point.interface.js';
-import { UmbBackofficeExtensionRegistry } from '../../packages/core/extension-registry/index.js';
+import type { UmbExtensionCondition } from './condition/index.js';
+import type { UmbEntryPointModule } from './entry-point.interface.js';
 export type HTMLElementConstructor<T = HTMLElement> = new (...args: any[]) => T;
 export type ClassConstructor<T = object> = new (...args: any[]) => T;
 export type ManifestTypeMap<ManifestTypes extends ManifestBase> = {
@@ -39,11 +39,30 @@ export interface ManifestKind<ManifestTypes> {
     matchKind: string;
     manifest: Partial<ManifestTypes>;
 }
-export interface ManifestWithConditions<ConditionsType> {
+export interface ManifestWithConditions<ConditionType> {
     /**
      * Set the conditions for when the extension should be loaded
      */
-    conditions: ConditionsType;
+    conditions: ConditionType;
+}
+export interface UmbConditionConfigBase<AliasType extends string = string> {
+    alias: AliasType;
+}
+export type ConditionTypeMap<ConditionTypes extends UmbConditionConfigBase> = {
+    [Condition in ConditionTypes as Condition['alias']]: Condition;
+} & {
+    [key: string]: UmbConditionConfigBase;
+};
+export type SpecificConditionTypeOrUmbConditionConfigBase<ConditionTypes extends UmbConditionConfigBase, T extends keyof ConditionTypeMap<ConditionTypes> | string> = T extends keyof ConditionTypeMap<ConditionTypes> ? ConditionTypeMap<ConditionTypes>[T] : UmbConditionConfigBase;
+export interface ManifestWithDynamicConditions<ConditionTypes extends UmbConditionConfigBase = UmbConditionConfigBase> extends ManifestBase {
+    /**
+     * Set the conditions for when the extension should be loaded
+     */
+    conditions?: Array<ConditionTypes>;
+    /**
+     * Define one or more extension aliases that this extension should overwrite.
+     */
+    overwrites?: string | Array<string>;
 }
 export interface ManifestWithLoader<LoaderReturnType> extends ManifestBase {
     /**
@@ -78,6 +97,14 @@ export interface ManifestClass<ClassType = unknown> extends ManifestWithLoader<{
 export interface ManifestClassWithClassConstructor<T = unknown> extends ManifestClass<T> {
     class: ClassConstructor<T>;
 }
+export interface ManifestWithLoaderIncludingDefaultExport<T = unknown> extends ManifestWithLoader<{
+    default: T;
+} | Omit<object, 'default'>> {
+    /**
+     * The file location of the javascript file to load
+     */
+    js?: string;
+}
 export interface ManifestElement<ElementType extends HTMLElement = HTMLElement> extends ManifestWithLoader<{
     default: ClassConstructor<ElementType>;
 } | Omit<object, 'default'>> {
@@ -131,17 +158,27 @@ export interface ManifestEntryPoint extends ManifestWithLoader<UmbEntryPointModu
     /**
      * The file location of the javascript file to load in the backoffice
      */
-    js: string;
+    js?: string;
 }
 /**
  * This type of extension takes a JS module and registers all exported manifests from the pointed JS file.
  */
-export interface ManifestBundle extends ManifestWithLoader<{
-    [key: string]: Array<UmbBackofficeExtensionRegistry['MANIFEST_TYPES']>;
+export interface ManifestBundle<UmbManifestTypes extends ManifestBase = ManifestBase> extends ManifestWithLoader<{
+    [key: string]: Array<UmbManifestTypes>;
 }> {
     type: 'bundle';
     /**
      * The file location of the javascript file to load in the backoffice
      */
-    js: string;
+    js?: string;
+}
+/**
+ * This type of extension takes a JS module and registers all exported manifests from the pointed JS file.
+ */
+export interface ManifestCondition extends ManifestClass<UmbExtensionCondition> {
+    type: 'condition';
+    /**
+     * The file location of the javascript file to load in the backoffice
+     */
+    js?: string;
 }

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

@@ -0,0 +1,3 @@
+export * from './registry/translation.registry.js';
+export * from './localize.controller.js';
+export { registerTranslation } from './manager.js';

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

@@ -0,0 +1,3 @@
+export * from './registry/translation.registry.js';
+export * from './localize.controller.js';
+export { registerTranslation } from './manager.js';

package/dist-cms/libs/localization-api/localize.controller.d.ts

@@ -0,0 +1,47 @@
+import { DefaultTranslationSet, FunctionParams, TranslationSet } from './manager.js';
+import { UmbController, UmbControllerHost } from '../controller-api/index.js';
+/**
+ * The UmbLocalizeController enables localization for your element.
+ *
+ * @see UmbLocalizeElement
+ * @example
+ * ```ts
+ * import { UmbLocalizeController } from './index.js';
+ *
+ * \@customElement('my-element')
+ * export class MyElement extends LitElement {
+ *   private localize = new UmbLocalizeController(this);
+ *
+ *   render() {
+ *     return html`<p>${this.localize.term('general_close')}</p>`;
+ *   }
+ * }
+ * ```
+ */
+export declare class UmbLocalizeController<TranslationType extends TranslationSet = DefaultTranslationSet> implements UmbController {
+    #private;
+    controllerAlias: symbol;
+    constructor(host: UmbControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    destroy(): void;
+    /**
+     * Gets the host element's directionality as determined by the `dir` attribute. The return value is transformed to
+     * lowercase.
+     */
+    dir(): string;
+    /**
+     * Gets the host element's language as determined by the `lang` attribute. The return value is transformed to
+     * lowercase.
+     */
+    lang(): string;
+    private getTranslationData;
+    /** Outputs a translated term. */
+    term<K extends keyof TranslationType>(key: K, ...args: FunctionParams<TranslationType[K]>): string;
+    /** Outputs a localized date in the specified format. */
+    date(dateToFormat: Date | string, options?: Intl.DateTimeFormatOptions): string;
+    /** Outputs a localized number in the specified format. */
+    number(numberToFormat: number | string, options?: Intl.NumberFormatOptions): string;
+    /** Outputs a localized time in relative format. */
+    relativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, options?: Intl.RelativeTimeFormatOptions): string;
+}