@umbraco-cms/backoffice 14.0.0--preview005-c6c57135 → 14.0.0--preview005-44025f0f

package/dist-cms/apps/app/app.element.js

@@ -18,7 +18,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _UmbAppElement_instances, _UmbAppElement_authContext, _UmbAppElement_umbIconRegistry, _UmbAppElement_uuiIconRegistry, _UmbAppElement_serverConnection, _UmbAppElement_setup, _UmbAppElement_setAuthStatus, _UmbAppElement_redirect, _UmbAppElement_isAuthorizedGuard, _UmbAppElement_errorPage;
 import { UmbAppContext } from './app.context.js';
 import { UmbServerConnection } from './server-connection.js';
-import { UmbAuthContext } from '../../shared/auth/index.js';
+import { UMB_STORAGE_REDIRECT_URL, UmbAuthContext } from '../../shared/auth/index.js';
 import { css, html, customElement, property } from '../../external/lit/index.js';
 import { UUIIconRegistryEssential } from '../../external/uui/index.js';
 import { UmbIconRegistry } from '../../shared/icon-registry/index.js';
@@ -46,7 +46,6 @@ let UmbAppElement = class UmbAppElement extends UmbLitElement {
         /**
          * Bypass authentication.
          */
-        // TODO: this might not be the right solution
         this.bypassAuth = false;
         this._routes = [
             {
@@ -141,6 +140,14 @@ async function _UmbAppElement_setAuthStatus() {
     OpenAPI.WITH_CREDENTIALS = true;
 };
 _UmbAppElement_redirect = function _UmbAppElement_redirect() {
+    // If there is a ?code parameter in the url, then we are in the middle of the oauth flow
+    // and we need to complete the login (the authorization notifier will redirect after this is done
+    // essentially hitting this method again)
+    const queryParams = new URLSearchParams(window.location.search);
+    if (queryParams.has('code')) {
+        __classPrivateFieldGet(this, _UmbAppElement_authContext, "f")?.completeAuthorizationRequest();
+        return;
+    }
     switch (__classPrivateFieldGet(this, _UmbAppElement_serverConnection, "f")?.getStatus()) {
         case RuntimeLevelModel.INSTALL:
             history.replaceState(null, '', 'install');
@@ -153,16 +160,14 @@ _UmbAppElement_redirect = function _UmbAppElement_redirect() {
             break;
         case RuntimeLevelModel.RUN: {
             const pathname = pathWithoutBasePath({ start: true, end: false });
-            // If we are on the installer or upgrade page, redirect to the root
-            // but if not, keep the current path but replace state anyway to initialize the router
-            let currentRoute = location.href;
-            const savedRoute = sessionStorage.getItem('umb:auth:redirect');
-            if (savedRoute) {
-                sessionStorage.removeItem('umb:auth:redirect');
-                currentRoute = savedRoute;
+            // If we are on installer or upgrade page, redirect to the root since we are in the RUN state
+            if (pathname === '/install' || pathname === '/upgrade') {
+                history.replaceState(null, '', '/');
+                break;
             }
-            const finalPath = pathname === '/install' || pathname === '/upgrade' ? '/' : currentRoute;
-            history.replaceState(null, '', finalPath);
+            // Keep the current path but replace state anyway to initialize the router
+            // because the router will not initialize a wildcard route by itself
+            history.replaceState(null, '', location.href);
             break;
         }
         default:
@@ -179,10 +184,9 @@ _UmbAppElement_isAuthorizedGuard = function _UmbAppElement_isAuthorizedGuard() {
             return true;
         }
         // Save location.href so we can redirect to it after login
-        window.sessionStorage.setItem('umb:auth:redirect', location.href);
+        window.sessionStorage.setItem(UMB_STORAGE_REDIRECT_URL, location.href);
         // Make a request to the auth server to start the auth flow
-        // TODO: find better name for this method
-        __classPrivateFieldGet(this, _UmbAppElement_authContext, "f").login();
+        __classPrivateFieldGet(this, _UmbAppElement_authContext, "f").makeAuthorizationRequest();
         // Return false to prevent the route from being rendered
         return false;
     };
@@ -219,7 +223,7 @@ __decorate([
 ], UmbAppElement.prototype, "serverUrl", void 0);
 __decorate([
     property({ type: String })
-    // TODO: get from server config
+    // TODO: get from base element or maybe move to UmbAuthContext.#getRedirectUrl since it is only used there
 ], UmbAppElement.prototype, "backofficePath", void 0);
 __decorate([
     property({ type: Boolean })

package/dist-cms/custom-elements.json

@@ -504,6 +504,36 @@
         }
       ]
     },
+    {
+      "name": "umb-property-editor-ui-block-grid-group-configuration",
+      "path": "./../src/packages/block/block-grid/property-editors/block-grid-group-configuration/property-editor-ui-block-grid-group-configuration.element.ts",
+      "attributes": [
+        {
+          "name": "value",
+          "type": "UmbBlockGridGroupType[]"
+        }
+      ],
+      "properties": [
+        {
+          "name": "value",
+          "attribute": "value",
+          "type": "UmbBlockGridGroupType[]"
+        },
+        {
+          "name": "config"
+        },
+        {
+          "name": "styles",
+          "type": "array",
+          "default": "[\"UmbTextStyles\",null]"
+        }
+      ],
+      "events": [
+        {
+          "name": "property-value-change"
+        }
+      ]
+    },
     {
       "name": "umb-property-editor-ui-block-grid-layout-stylesheet",
       "path": "./../src/packages/block/block-grid/property-editors/block-grid-layout-stylesheet/property-editor-ui-block-grid-layout-stylesheet.element.ts",
@@ -540,8 +570,7 @@
       "properties": [
         {
           "name": "value",
-          "type": "UmbBlockTypeBaseModel[]",
-          "default": "[]"
+          "type": "UmbBlockTypeWithGroupKey[]"
         },
         {
           "name": "config"
@@ -549,7 +578,7 @@
         {
           "name": "styles",
           "type": "array",
-          "default": "[\"UmbTextStyles\"]"
+          "default": "[\"UmbTextStyles\",null]"
         }
       ]
     },
@@ -722,7 +751,7 @@
       "path": "./../src/packages/block/block-type/components/input-block-type/input-block-type.element.ts",
       "attributes": [
         {
-          "name": "entity-type",
+          "name": "workspacePath",
           "type": "string | undefined"
         }
       ],
@@ -732,8 +761,8 @@
           "type": "BlockType[]"
         },
         {
-          "name": "entityType",
-          "attribute": "entity-type",
+          "name": "workspacePath",
+          "attribute": "workspacePath",
           "type": "string | undefined"
         },
         {
@@ -741,6 +770,11 @@
           "type": "array",
           "default": "[null]"
         }
+      ],
+      "events": [
+        {
+          "name": "create"
+        }
       ]
     },
     {

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/data/data-type/data-type.data.js

@@ -692,6 +692,13 @@ export const data = [
                         icon: 'icon-book-alt',
                         groupKey: 'demo-block-group-id',
                     },
+                    {
+                        label: 'Test broken group key',
+                        contentElementTypeKey: 'test-block-id',
+                        editorSize: 'medium',
+                        icon: 'icon-war',
+                        groupKey: 'group-id-that-does-not-exist',
+                    },
                 ],
             },
         ],