@umbraco-cms/backoffice 14.0.0--preview005-7ef2bd26 → 14.0.0--preview005-0aa73f4a

package/dist-cms/custom-elements.json

@@ -3154,12 +3154,21 @@
       "name": "umb-entity-action",
       "path": "./../src/packages/core/entity-action/entity-action.element.ts",
       "attributes": [
+        {
+          "name": "entityType",
+          "type": "string | null | undefined"
+        },
         {
           "name": "unique",
           "type": "string | null | undefined"
         }
       ],
       "properties": [
+        {
+          "name": "entityType",
+          "attribute": "entityType",
+          "type": "string | null | undefined"
+        },
         {
           "name": "unique",
           "attribute": "unique",

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

@@ -120,7 +120,7 @@ export class UmbBaseExtensionInitializer extends UmbBaseController {
         __classPrivateFieldSet(this, _UmbBaseExtensionInitializer_onPermissionChanged, onPermissionChanged, "f");
     }
     _init() {
-        __classPrivateFieldSet(this, _UmbBaseExtensionInitializer_manifestObserver, this.observe(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_extensionRegistry, "f").getByAlias(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_alias, "f")), async (extensionManifest) => {
+        __classPrivateFieldSet(this, _UmbBaseExtensionInitializer_manifestObserver, this.observe(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_extensionRegistry, "f").byAlias(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_alias, "f")), async (extensionManifest) => {
             __classPrivateFieldGet(this, _UmbBaseExtensionInitializer_instances, "m", _UmbBaseExtensionInitializer_clearPermittedState).call(this);
             __classPrivateFieldSet(this, _UmbBaseExtensionInitializer_manifest, extensionManifest, "f");
             if (extensionManifest) {
@@ -197,7 +197,7 @@ _UmbBaseExtensionInitializer_promiseResolvers = new WeakMap(), _UmbBaseExtension
         oldAmountOfControllers === conditionConfigs.length;
     if (conditionConfigs.length > 0) {
         // Observes the conditions and initialize as they come in.
-        this.observe(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_extensionRegistry, "f").getByTypeAndAliases('condition', conditionAliases), __classPrivateFieldGet(this, _UmbBaseExtensionInitializer_gotConditions, "f"), '_observeConditions');
+        this.observe(__classPrivateFieldGet(this, _UmbBaseExtensionInitializer_extensionRegistry, "f").byTypeAndAliases('condition', conditionAliases), __classPrivateFieldGet(this, _UmbBaseExtensionInitializer_gotConditions, "f"), '_observeConditions');
     }
     else {
         this.removeControllerByAlias('_observeConditions');

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

@@ -111,8 +111,8 @@ export class UmbBaseExtensionsInitializer extends UmbBaseController {
     }
     _init() {
         let source = Array.isArray(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_type, "f"))
-            ? __classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_extensionRegistry, "f").extensionsOfTypes(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_type, "f"))
-            : __classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_extensionRegistry, "f").extensionsOfType(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_type, "f"));
+            ? __classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_extensionRegistry, "f").byTypes(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_type, "f"))
+            : __classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_extensionRegistry, "f").byType(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_type, "f"));
         if (__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_filter, "f")) {
             source = source.pipe(map((extensions) => extensions.filter(__classPrivateFieldGet(this, _UmbBaseExtensionsInitializer_filter, "f"))));
         }

package/dist-cms/libs/extension-api/initializers/bundle-extension-initializer.js

@@ -18,7 +18,7 @@ export class UmbBundleExtensionInitializer extends UmbBaseController {
         _UmbBundleExtensionInitializer_extensionRegistry.set(this, void 0);
         _UmbBundleExtensionInitializer_bundleMap.set(this, new Map());
         __classPrivateFieldSet(this, _UmbBundleExtensionInitializer_extensionRegistry, extensionRegistry, "f");
-        this.observe(extensionRegistry.extensionsOfType('bundle'), (bundles) => {
+        this.observe(extensionRegistry.byType('bundle'), (bundles) => {
             // Unregister removed bundles:
             __classPrivateFieldGet(this, _UmbBundleExtensionInitializer_bundleMap, "f").forEach((existingBundle) => {
                 if (!bundles.find((b) => b.alias === existingBundle.alias)) {

package/dist-cms/libs/extension-api/initializers/entry-point-extension-initializer.js

@@ -20,7 +20,7 @@ export class UmbEntryPointExtensionInitializer extends UmbBaseController {
         _UmbEntryPointExtensionInitializer_entryPointMap.set(this, new Map());
         __classPrivateFieldSet(this, _UmbEntryPointExtensionInitializer_host, host, "f");
         __classPrivateFieldSet(this, _UmbEntryPointExtensionInitializer_extensionRegistry, extensionRegistry, "f");
-        this.observe(extensionRegistry.extensionsOfType('entryPoint'), (entryPoints) => {
+        this.observe(extensionRegistry.byType('entryPoint'), (entryPoints) => {
             entryPoints.forEach((entryPoint) => {
                 if (__classPrivateFieldGet(this, _UmbEntryPointExtensionInitializer_entryPointMap, "f").has(entryPoint.alias))
                     return;

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

@@ -2,6 +2,7 @@ import type { ManifestBase, ManifestKind } from '../types/index.js';
 import type { ManifestTypeMap, SpecificManifestTypeOrManifestBase } from '../types/map.types.js';
 import type { Observable } from '../../../external/rxjs/index.js';
 export declare class UmbExtensionRegistry<IncomingManifestTypes extends ManifestBase, ManifestTypes extends ManifestBase = IncomingManifestTypes | ManifestBase> {
+    #private;
     readonly MANIFEST_TYPES: ManifestTypes;
     private _extensions;
     readonly extensions: Observable<ManifestTypes[]>;
@@ -13,33 +14,59 @@ 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[]>;
-    /**
-     * Get an observable of an extension by type and a given filter method.
+    /**
+     * Get an observable that provides extensions matching the given alias.
+     * @param alias {string} - The alias of the extensions to get.
+     * @returns {Observable<T | undefined>} - An observable of the extension that matches the alias.
+     */
+    byAlias<T extends ManifestBase = ManifestBase>(alias: string): Observable<T | undefined>;
+    /**
+     * @deprecated Use `byAlias` instead.
+     */
+    getByAlias: <T extends ManifestBase = ManifestBase>(alias: string) => Observable<T | undefined>;
+    /**
+     * Get an observable that provides extensions matching the given type and alias.
+     * @param type {string} - The type of the extensions to get.
+     * @param alias {string} - The alias of the extensions to get.
+     * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type and alias.
+     */
+    byTypeAndAlias<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, alias: string): Observable<T | undefined>;
+    /**
+     * @deprecated Use `byTypeAndAlias` instead.
+     */
+    getByTypeAndAlias: <Key extends string | number | ManifestTypes["type"], T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, alias: string) => Observable<T | undefined>;
+    byTypeAndAliases<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, aliases: Array<string>): Observable<T[]>;
+    /**
+     * @deprecated Use `byTypeAndAliases` instead.
+     */
+    getByTypeAndAliases: <Key extends string | number | ManifestTypes["type"], T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, aliases: Array<string>) => Observable<T[]>;
+    /**
+     * Get an observable of extensions by type and a given filter method.
      * This will return the all extensions that matches the type and which filter method returns true.
      * The filter method will be called for each extension manifest of the given type, and the first argument to it is the extension manifest.
      * @param type {string} - The type of the extension to get
      * @param filter {(ext: T): void} - The filter method to use to filter the extensions
-     * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type and filter method
+     * @returns {Observable<Array<T>>} - An observable of the extensions that matches the type and filter method
      */
-    byTypeAndFilter<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, filter: (ext: T) => boolean): Observable<T | undefined>;
+    byTypeAndFilter<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key, filter: (ext: T) => boolean): Observable<T[]>;
     /**
      * Get an observable that provides extensions matching the given type.
      * @param type {string} - The type of the extensions to get.
      * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type.
      */
-    extensionsOfType<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key): Observable<T[]>;
+    byType<Key extends keyof ManifestTypeMap<ManifestTypes> | string, T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key): Observable<T[]>;
+    /**
+     * @deprecated Use `byType` instead.
+     */
+    extensionsOfType: <Key extends string | number | ManifestTypes["type"], T extends ManifestBase = SpecificManifestTypeOrManifestBase<ManifestTypes, Key>>(type: Key) => Observable<T[]>;
     /**
      * Get an observable that provides extensions matching given types.
      * @param type {Array<string>} - The types of the extensions to get.
      * @returns {Observable<T | undefined>} - An observable of the extensions that matches the types.
      */
-    extensionsOfTypes<ExtensionTypes extends ManifestBase = ManifestBase>(types: string[]): Observable<Array<ExtensionTypes>>;
+    byTypes<ExtensionTypes extends ManifestBase = ManifestBase>(types: string[]): Observable<Array<ExtensionTypes>>;
+    /**
+     * @deprecated Use `byTypes` instead.
+     */
+    extensionsOfTypes: <ExtensionTypes extends ManifestBase = ManifestBase>(types: string[]) => Observable<ExtensionTypes[]>;
 }

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

@@ -1,3 +1,9 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _UmbExtensionRegistry_instances, _UmbExtensionRegistry_checkExtension, _UmbExtensionRegistry_kindsOfType, _UmbExtensionRegistry_extensionsOfType, _UmbExtensionRegistry_kindsOfTypes, _UmbExtensionRegistry_extensionsOfTypes, _UmbExtensionRegistry_mergeExtensionWithKinds, _UmbExtensionRegistry_mergeExtensionsWithKinds;
 import { UmbBasicState } from '../../observable-api/index.js';
 import { map, distinctUntilChanged, combineLatest, of, switchMap } from '../../../external/rxjs/index.js';
 function extensionArrayMemoization(previousValue, currentValue) {
@@ -48,11 +54,32 @@ function extensionAndKindMatchSingleMemoization(previousValue, currentValue) {
 const sortExtensions = (a, b) => (b.weight || 0) - (a.weight || 0);
 export class UmbExtensionRegistry {
     constructor() {
+        _UmbExtensionRegistry_instances.add(this);
         this.MANIFEST_TYPES = undefined;
         this._extensions = new UmbBasicState([]);
         this.extensions = this._extensions.asObservable();
         this._kinds = new UmbBasicState([]);
         this.kinds = this._kinds.asObservable();
+        /**
+         * @deprecated Use `byAlias` instead.
+         */
+        this.getByAlias = this.byAlias.bind(this);
+        /**
+         * @deprecated Use `byTypeAndAlias` instead.
+         */
+        this.getByTypeAndAlias = this.byTypeAndAlias.bind(this);
+        /**
+         * @deprecated Use `byTypeAndAliases` instead.
+         */
+        this.getByTypeAndAliases = this.byTypeAndAliases.bind(this);
+        /**
+         * @deprecated Use `byType` instead.
+         */
+        this.extensionsOfType = this.byType.bind(this);
+        /**
+         * @deprecated Use `byTypes` instead.
+         */
+        this.extensionsOfTypes = this.byTypes.bind(this);
     }
     defineKind(kind) {
         const extensionsValues = this._extensions.getValue();
@@ -69,7 +96,7 @@ export class UmbExtensionRegistry {
         this._kinds.setValue(nextData);
     }
     register(manifest) {
-        const isValid = this.checkExtension(manifest);
+        const isValid = __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_checkExtension).call(this, manifest);
         if (!isValid) {
             return;
         }
@@ -97,181 +124,124 @@ export class UmbExtensionRegistry {
         }
         return false;
     }
-    /*
-    getByAlias(alias: string) {
-        // TODO: make pipes prettier/simpler/reuseable
-        return this.extensions.pipe(map((extensions) => extensions.find((extension) => extension.alias === alias) || null));
-    }
-    */
-    checkExtension(manifest) {
-        if (!manifest.type) {
-            console.error(`Extension is missing type`, manifest);
-            return false;
-        }
-        if (!manifest.alias) {
-            console.error(`Extension is missing alias`, manifest);
-            return false;
-        }
-        if (manifest.type === 'kind') {
-            this.defineKind(manifest);
-            return false;
-        }
-        const extensionsValues = this._extensions.getValue();
-        const extension = extensionsValues.find((extension) => extension.alias === manifest.alias);
-        if (extension) {
-            console.error(`Extension with alias ${manifest.alias} is already registered`);
-            return false;
-        }
-        return true;
-    }
-    _kindsOfType(type) {
-        return this.kinds.pipe(map((kinds) => kinds.filter((kind) => kind.matchType === type)), distinctUntilChanged(extensionArrayMemoization));
-    }
-    _extensionsOfType(type) {
-        return this.extensions.pipe(map((exts) => exts.filter((ext) => ext.type === type)), distinctUntilChanged(extensionArrayMemoization));
-    }
-    _kindsOfTypes(types) {
-        return this.kinds.pipe(map((kinds) => kinds.filter((kind) => types.indexOf(kind.matchType) !== -1)), distinctUntilChanged(extensionArrayMemoization));
-    }
-    // TODO: can we get rid of as unknown here
-    _extensionsOfTypes(types) {
-        return this.extensions.pipe(map((exts) => exts.filter((ext) => types.indexOf(ext.type) !== -1)), distinctUntilChanged(extensionArrayMemoization));
-    }
-    // TODO: get rid of the name get
-    getByAlias(alias) {
+    /**
+     * Get an observable that provides extensions matching the given alias.
+     * @param alias {string} - The alias of the extensions to get.
+     * @returns {Observable<T | undefined>} - An observable of the extension that matches the alias.
+     */
+    byAlias(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 __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfType).call(this, ext.type).pipe(map((kinds) => __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionWithKinds).call(this, [ext, kinds])));
             }
             return of(ext);
         }), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
     }
-    // TODO: get rid of the name get
-    getByTypeAndAlias(type, alias) {
+    /**
+     * Get an observable that provides extensions matching the given type and alias.
+     * @param type {string} - The type of the extensions to get.
+     * @param alias {string} - The alias of the extensions to get.
+     * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type and alias.
+     */
+    byTypeAndAlias(type, alias) {
         return combineLatest([
             this.extensions.pipe(map((exts) => exts.find((ext) => ext.type === type && ext.alias === alias)), distinctUntilChanged(extensionSingleMemoization)),
-            this._kindsOfType(type),
-        ]).pipe(map(([ext, kinds]) => {
-            // TODO: share one merge function between the different methods of this class:
-            // Specific Extension Meta merge (does not merge conditions)
-            if (ext) {
-                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;
-        }), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
+            __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfType).call(this, type),
+        ]).pipe(map(__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionWithKinds)), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
     }
-    // TODO: get rid of the name get
-    getByTypeAndAliases(type, aliases) {
+    byTypeAndAliases(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));
+            __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfType).call(this, type),
+        ]).pipe(map(__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionsWithKinds)), distinctUntilChanged(extensionAndKindMatchArrayMemoization));
     }
     /**
-     * Get an observable of an extension by type and a given filter method.
+     * Get an observable of extensions by type and a given filter method.
      * This will return the all extensions that matches the type and which filter method returns true.
      * The filter method will be called for each extension manifest of the given type, and the first argument to it is the extension manifest.
      * @param type {string} - The type of the extension to get
      * @param filter {(ext: T): void} - The filter method to use to filter the extensions
-     * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type and filter method
+     * @returns {Observable<Array<T>>} - An observable of the extensions that matches the type and filter method
      */
     byTypeAndFilter(type, filter) {
         return combineLatest([
-            this.extensions.pipe(map((exts) => exts.find((ext) => ext.type === type && filter(ext))), distinctUntilChanged(extensionSingleMemoization)),
-            this._kindsOfType(type),
-        ]).pipe(map(([ext, kinds]) => {
-            // TODO: share one merge function between the different methods of this class:
-            // Specific Extension Meta merge (does not merge conditions)
-            if (ext) {
-                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;
-        }), distinctUntilChanged(extensionAndKindMatchSingleMemoization));
+            this.extensions.pipe(map((exts) => exts.filter((ext) => ext.type === type && filter(ext))), distinctUntilChanged(extensionArrayMemoization)),
+            __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfType).call(this, type),
+        ]).pipe(map(__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionsWithKinds)), distinctUntilChanged(extensionAndKindMatchArrayMemoization));
     }
     /**
      * Get an observable that provides extensions matching the given type.
      * @param type {string} - The type of the extensions to get.
      * @returns {Observable<T | undefined>} - An observable of the extensions that matches the type.
      */
-    extensionsOfType(type) {
-        return combineLatest([this._extensionsOfType(type), 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));
+    byType(type) {
+        return combineLatest([__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_extensionsOfType).call(this, type), __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfType).call(this, type)]).pipe(map(__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionsWithKinds)), distinctUntilChanged(extensionAndKindMatchArrayMemoization));
     }
     /**
      * Get an observable that provides extensions matching given types.
      * @param type {Array<string>} - The types of the extensions to get.
      * @returns {Observable<T | undefined>} - An observable of the extensions that matches the types.
      */
-    extensionsOfTypes(types) {
-        return combineLatest([this._extensionsOfTypes(types), this._kindsOfTypes(types)]).pipe(map(([exts, kinds]) => exts
-            .map((ext) => {
-            // Specific Extension Meta merge (does not merge conditions)
-            if (ext) {
-                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));
+    byTypes(types) {
+        return combineLatest([__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_extensionsOfTypes).call(this, types), __classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_kindsOfTypes).call(this, types)]).pipe(map(__classPrivateFieldGet(this, _UmbExtensionRegistry_instances, "m", _UmbExtensionRegistry_mergeExtensionsWithKinds)), distinctUntilChanged(extensionAndKindMatchArrayMemoization));
     }
 }
+_UmbExtensionRegistry_instances = new WeakSet(), _UmbExtensionRegistry_checkExtension = function _UmbExtensionRegistry_checkExtension(manifest) {
+    if (!manifest.type) {
+        console.error(`Extension is missing type`, manifest);
+        return false;
+    }
+    if (!manifest.alias) {
+        console.error(`Extension is missing alias`, manifest);
+        return false;
+    }
+    if (manifest.type === 'kind') {
+        this.defineKind(manifest);
+        return false;
+    }
+    const extensionsValues = this._extensions.getValue();
+    const extension = extensionsValues.find((extension) => extension.alias === manifest.alias);
+    if (extension) {
+        console.error(`Extension with alias ${manifest.alias} is already registered`);
+        return false;
+    }
+    return true;
+}, _UmbExtensionRegistry_kindsOfType = function _UmbExtensionRegistry_kindsOfType(type) {
+    return this.kinds.pipe(map((kinds) => kinds.filter((kind) => kind.matchType === type)), distinctUntilChanged(extensionArrayMemoization));
+}, _UmbExtensionRegistry_extensionsOfType = function _UmbExtensionRegistry_extensionsOfType(type) {
+    return this.extensions.pipe(map((exts) => exts.filter((ext) => ext.type === type)), distinctUntilChanged(extensionArrayMemoization));
+}, _UmbExtensionRegistry_kindsOfTypes = function _UmbExtensionRegistry_kindsOfTypes(types) {
+    return this.kinds.pipe(map((kinds) => kinds.filter((kind) => types.indexOf(kind.matchType) !== -1)), distinctUntilChanged(extensionArrayMemoization));
+}, _UmbExtensionRegistry_extensionsOfTypes = function _UmbExtensionRegistry_extensionsOfTypes(types) {
+    return this.extensions.pipe(map((exts) => exts.filter((ext) => types.indexOf(ext.type) !== -1)), distinctUntilChanged(extensionArrayMemoization));
+}, _UmbExtensionRegistry_mergeExtensionWithKinds = function _UmbExtensionRegistry_mergeExtensionWithKinds([ext, kinds,]) {
+    // Specific Extension Meta merge (does not merge conditions)
+    if (ext) {
+        // Since we don't 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;
+}, _UmbExtensionRegistry_mergeExtensionsWithKinds = function _UmbExtensionRegistry_mergeExtensionsWithKinds([exts, kinds,]) {
+    return 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);
+};

package/dist-cms/mocks/handlers/document-type/folder.handlers.d.ts

@@ -0,0 +1 @@
+export declare const folderHandlers: import("msw").RestHandler<import("node_modules/msw/lib/glossary-de6278a9.js").M<import("node_modules/msw/lib/glossary-de6278a9.js").h>>[];

package/dist-cms/mocks/handlers/document-type/folder.handlers.js

@@ -0,0 +1,40 @@
+const { rest } = window.MockServiceWorker;
+import { umbDocumentTypeMockDb } from '../../data/document-type/document-type.db.js';
+import { UMB_SLUG } from './slug.js';
+import { umbracoPath } from '../../../shared/utils/index.js';
+export const folderHandlers = [
+    rest.post(umbracoPath(`${UMB_SLUG}/folder`), async (req, res, ctx) => {
+        const requestBody = await req.json();
+        if (!requestBody)
+            return res(ctx.status(400, 'no body found'));
+        const id = umbDocumentTypeMockDb.folder.create(requestBody);
+        return res(ctx.status(201), ctx.set({
+            Location: req.url.href + '/' + id,
+            'Umb-Generated-Resource': id,
+        }));
+    }),
+    rest.get(umbracoPath(`${UMB_SLUG}/folder/:id`), (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return res(ctx.status(400));
+        const response = umbDocumentTypeMockDb.folder.read(id);
+        return res(ctx.status(200), ctx.json(response));
+    }),
+    rest.put(umbracoPath(`${UMB_SLUG}/folder/:id`), async (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return res(ctx.status(400, 'no id found'));
+        const requestBody = await req.json();
+        if (!requestBody)
+            return res(ctx.status(400, 'no body found'));
+        umbDocumentTypeMockDb.folder.update(id, requestBody);
+        return res(ctx.status(200));
+    }),
+    rest.delete(umbracoPath(`${UMB_SLUG}/folder/:id`), (req, res, ctx) => {
+        const id = req.params.id;
+        if (!id)
+            return res(ctx.status(400));
+        umbDocumentTypeMockDb.folder.delete(id);
+        return res(ctx.status(200));
+    }),
+];

package/dist-cms/mocks/handlers/document-type/index.js

@@ -1,4 +1,5 @@
 import { treeHandlers } from './tree.handlers.js';
 import { detailHandlers } from './detail.handlers.js';
 import { itemHandlers } from './item.handlers.js';
-export const handlers = [...treeHandlers, ...itemHandlers, ...detailHandlers];
+import { folderHandlers } from './folder.handlers.js';
+export const handlers = [...treeHandlers, ...itemHandlers, ...folderHandlers, ...detailHandlers];

package/dist-cms/packages/core/action/index.d.ts

@@ -1,4 +1,3 @@
 export * from './repository-action.js';
 export * from './action.interface.js';
 export * from './action-event.context.js';
-export * from './action.event.js';

package/dist-cms/packages/core/action/index.js

@@ -1,4 +1,3 @@
 export * from './repository-action.js';
 export * from './action.interface.js';
 export * from './action-event.context.js';
-export * from './action.event.js';

package/dist-cms/packages/core/components/entity-actions-bundle/entity-actions-bundle.element.js

@@ -68,7 +68,7 @@ _UmbEntityActionsBundleElement_sectionSidebarContext = new WeakMap();
 _UmbEntityActionsBundleElement_instances = new WeakSet();
 _UmbEntityActionsBundleElement_observeEntityActions = function _UmbEntityActionsBundleElement_observeEntityActions() {
     this.observe(umbExtensionsRegistry
-        .extensionsOfType('entityAction')
+        .byType('entityAction')
         .pipe(map((actions) => actions.filter((action) => action.meta.entityTypes.includes(this.entityType)))), (actions) => {
         this._hasActions = actions.length > 0;
     }, 'umbEntityActionsObserver');

package/dist-cms/packages/core/components/input-section/input-section.element.js

@@ -21,7 +21,7 @@ let UmbInputSectionElement = class UmbInputSectionElement extends UmbInputListBa
     }
     _observeSections() {
         if (this.value.length > 0) {
-            this.observe(umbExtensionsRegistry.extensionsOfType('section'), (sections) => {
+            this.observe(umbExtensionsRegistry.byType('section'), (sections) => {
                 this._sections = sections.filter((section) => this.value.includes(section.alias));
             });
         }

package/dist-cms/packages/core/components/input-tiny-mce/input-tiny-mce.element.js

@@ -133,7 +133,7 @@ _UmbInputTinyMceElement_loadPlugins =
  * the plugins are ready and so are not associated with the editor.
  */
 async function _UmbInputTinyMceElement_loadPlugins() {
-    const observable = umbExtensionsRegistry?.extensionsOfType('tinyMcePlugin');
+    const observable = umbExtensionsRegistry?.byType('tinyMcePlugin');
     const manifests = (await firstValueFrom(observable));
     const promises = [];
     for (const manifest of manifests) {

package/dist-cms/packages/core/data-type/entity-actions/copy/copy.action.d.ts

@@ -3,6 +3,6 @@ import { UmbEntityActionBase } from '../../../entity-action/index.js';
 import type { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
 export declare class UmbCopyDataTypeEntityAction extends UmbEntityActionBase<UmbCopyDataTypeRepository> {
     #private;
-    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string, entityType: string);
     execute(): Promise<void>;
 }

package/dist-cms/packages/core/data-type/entity-actions/copy/copy.action.js

@@ -14,8 +14,8 @@ import { UmbEntityActionBase } from '../../../entity-action/index.js';
 import { UMB_MODAL_MANAGER_CONTEXT, UMB_DATA_TYPE_PICKER_MODAL, } from '../../../modal/index.js';
 // TODO: investigate what we need to make a generic copy action
 export class UmbCopyDataTypeEntityAction extends UmbEntityActionBase {
-    constructor(host, repositoryAlias, unique) {
-        super(host, repositoryAlias, unique);
+    constructor(host, repositoryAlias, unique, entityType) {
+        super(host, repositoryAlias, unique, entityType);
         _UmbCopyDataTypeEntityAction_modalManagerContext.set(this, void 0);
         this.consumeContext(UMB_MODAL_MANAGER_CONTEXT, (instance) => {
             __classPrivateFieldSet(this, _UmbCopyDataTypeEntityAction_modalManagerContext, instance, "f");

package/dist-cms/packages/core/data-type/entity-actions/create/create.action.d.ts

@@ -3,6 +3,6 @@ import { UmbEntityActionBase } from '../../../entity-action/index.js';
 import type { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
 export declare class UmbCreateDataTypeEntityAction extends UmbEntityActionBase<UmbDataTypeDetailRepository> {
     #private;
-    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string, entityType: string);
     execute(): Promise<void>;
 }

package/dist-cms/packages/core/data-type/entity-actions/create/create.action.js

@@ -14,8 +14,8 @@ import { UMB_DATA_TYPE_CREATE_OPTIONS_MODAL } from './modal/index.js';
 import { UmbEntityActionBase } from '../../../entity-action/index.js';
 import { UMB_MODAL_MANAGER_CONTEXT } from '../../../modal/index.js';
 export class UmbCreateDataTypeEntityAction extends UmbEntityActionBase {
-    constructor(host, repositoryAlias, unique) {
-        super(host, repositoryAlias, unique);
+    constructor(host, repositoryAlias, unique, entityType) {
+        super(host, repositoryAlias, unique, entityType);
         _UmbCreateDataTypeEntityAction_modalManagerContext.set(this, void 0);
         this.consumeContext(UMB_MODAL_MANAGER_CONTEXT, (instance) => {
             __classPrivateFieldSet(this, _UmbCreateDataTypeEntityAction_modalManagerContext, instance, "f");

package/dist-cms/packages/core/data-type/entity-actions/move/move.action.d.ts

@@ -3,6 +3,6 @@ import { UmbEntityActionBase } from '../../../entity-action/index.js';
 import type { UmbControllerHostElement } from '../../../../../libs/controller-api/index.js';
 export declare class UmbMoveDataTypeEntityAction extends UmbEntityActionBase<UmbMoveDataTypeRepository> {
     #private;
-    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string);
+    constructor(host: UmbControllerHostElement, repositoryAlias: string, unique: string, entityType: string);
     execute(): Promise<void>;
 }