xt-components 0.6.3 → 0.7.0

package/fesm2022/xt-components.mjs

@@ -1,20 +1,31 @@
 import { isTypeReference, XtBaseTypeReference, xtTypeManager, ManagedDataHandler, isPrimitive } from 'xt-type';
 import * as i0 from '@angular/core';
 import { signal, computed, InjectionToken, inject, Injectable, input, model, output, viewChild, Component } from '@angular/core';
-import { loadRemoteModule } from '@angular-architects/native-federation';
-import { from, firstValueFrom } from 'rxjs';
+import { firstValueFrom, lastValueFrom, range, delay, find, from } from 'rxjs';
 import { NgComponentOutlet, CommonModule } from '@angular/common';
 import * as i1 from '@angular/forms';
 import { ReactiveFormsModule, FormControl, FormGroup, FormBuilder, FormArray } from '@angular/forms';
 
+/**
+ * Maintain the list of plugins loaded, with their components and actions
+ *
+ */
 class XtPluginRegistry {
     constructor() {
+        /** Map of all registered plugins by name */
         this.pluginRegistry = new Map();
+        /** Map of all registered components by component name */
         this.componentRegistry = new Map();
+        /** Cache of components found by value type */
         this.componentByTypeCache = new Map();
+        /** Map of all registered workflows by name */
+        this.workflowRegistry = new Map();
+        /** Map of actions registered by type, then by action name */
         this.actionByTypeRegistry = new Map();
-        this.listComponents = signal(new Array(), ...(ngDevMode ? [{ debugName: "listComponents" }] : []));
-        this.listPlugins = signal(new Array(), ...(ngDevMode ? [{ debugName: "listPlugins" }] : []));
+        /** Signal listing all registered component infos */
+        this.listComponents = signal(new Array(), ...(ngDevMode ? [{ debugName: "listComponents" }] : /* istanbul ignore next */ []));
+        /** Signal listing all registered plugin infos */
+        this.listPlugins = signal(new Array(), ...(ngDevMode ? [{ debugName: "listPlugins" }] : /* istanbul ignore next */ []));
     }
     /**
      * The component can manage any standard javascript primitives types. That's usually the default whenever we don't know any particular type
@@ -32,13 +43,20 @@ class XtPluginRegistry {
      * The components can manage any composite javascript type. Default when no type has been defined and it's a user defined javascript object (not a data type)
      */
     static { this.ANY_OBJECT_TYPE = "ANY_OBJECT_TYPE"; }
+    /** Components can manage any set of primitive types */
     static { this.ANY_PRIMITIVE_SET = "ANY_PRIMITIVE_SET"; }
+    /** Components can manage any set of object types */
     static { this.ANY_OBJECT_SET = "ANY_OBJECT_SET"; }
     /**
      * Whenever a component can handle any type of reference to a single entity or to multiple entities.
      */
     static { this.ANY_SINGLE_REFERENCE = "ANY_SINGLE_REFERENCE"; }
+    /** Whenever a component can handle any type of reference to multiple entities */
     static { this.ANY_MULTIPLE_REFERENCE = "ANY_MULTIPLE_REFERENCE"; }
+    /**
+     * Registers a plugin with its components, actions, and workflows
+     * @param info - The plugin information to register
+     */
     registerPlugin(info) {
         this.pluginRegistry.set(info.name, info);
         if (info.components != null) {
@@ -55,6 +73,12 @@ class XtPluginRegistry {
                 this.registerActionHandler(handler);
             }
         }
+        if (info.workflows != null) {
+            for (const wfw of info.workflows) {
+                this.registerWorkflow(wfw);
+            }
+        }
+        // Updates the signal which list all plugins
         this.listPlugins.update((array) => {
             let found = false;
             for (let i = 0; i < array.length; i++) {
@@ -68,6 +92,17 @@ class XtPluginRegistry {
             return [...array]; // You have to send another value, not just update the existing one.
         });
     }
+    /**
+     * Registers a workflow component
+     * @param info - The workflow information to register
+     */
+    registerWorkflow(info) {
+        this.workflowRegistry.set(info.name, info);
+    }
+    /**
+     * Registers a component in the component registry
+     * @param info - The component information to register
+     */
     registerComponent(info) {
         this.componentRegistry.set(info.componentName, info);
         this.listComponents.update((array) => {
@@ -83,6 +118,12 @@ class XtPluginRegistry {
             return array;
         });
     }
+    /**
+     * Finds components that can handle the given value type
+     * @param valueType - The value type to search for, or null/undefined to infer from the value
+     * @param value - The optional value to infer the type from
+     * @returns An array of matching component infos
+     */
     findComponentsForType(valueType, value) {
         let originalType = valueType;
         //console.debug('Finding type from '+valueType+' with value ',value);
@@ -134,9 +175,18 @@ class XtPluginRegistry {
         }
         return ret;
     }
+    /**
+     * Returns the global singleton plugin registry
+     * @returns The global XtPluginRegistry instance
+     */
     static registry() {
         return XT_REGISTRY;
     }
+    /**
+     * Finds component info for the given component class type
+     * @param type - The component class type to search for
+     * @returns The component info or null if not found
+     */
     findComponentInfo(type) {
         // Search for the component registered with this class
         for (const info of this.componentRegistry.values()) {
@@ -146,6 +196,12 @@ class XtPluginRegistry {
         }
         return null;
     }
+    /**
+     * Gets component info for the given component class type, throwing if not found
+     * @param type - The component class type to search for
+     * @returns The component info
+     * @throws Error if no component is found with the given class
+     */
     getComponentInfo(type) {
         const ret = this.findComponentInfo(type);
         if (ret == null) {
@@ -153,6 +209,32 @@ class XtPluginRegistry {
         }
         return ret;
     }
+    /**
+     * Finds all the workflow components that can handle the given workflow type
+     * @param type
+     */
+    listWorkflowsForType(type) {
+        const ret = [];
+        for (const info of this.workflowRegistry.values()) {
+            const index = info.workflowsHandled.findIndex((val) => val == type);
+            if (index >= 0) {
+                ret.push(info);
+            }
+        }
+        return ret;
+    }
+    /**
+     * Finds workflow info by name
+     * @param name - The workflow name to search for
+     * @returns The workflow info or undefined if not found
+     */
+    findWorkflowInfo(name) {
+        return this.workflowRegistry.get(name);
+    }
+    /**
+     * Registers action handlers grouped by type
+     * @param handlerInfo - The action handler information to register
+     */
     registerActionHandler(handlerInfo) {
         for (const type of handlerInfo.types) {
             const handlers = handlerInfo.actions;
@@ -166,6 +248,12 @@ class XtPluginRegistry {
             }
         }
     }
+    /**
+     * Finds action info for the given type and action name
+     * @param type - The type to look up
+     * @param actionName - The action name to find
+     * @returns The action info or undefined if not found
+     */
     findActionInfo(type, actionName) {
         const handlers = this.actionByTypeRegistry.get(type);
         if (handlers != null) {
@@ -173,6 +261,11 @@ class XtPluginRegistry {
         }
         return undefined;
     }
+    /**
+     * Lists all action infos registered for the given type
+     * @param type - The type to list actions for
+     * @returns An array of action name and info pairs
+     */
     listActionInfos(type) {
         const handlers = this.actionByTypeRegistry.get(type);
         if (handlers != null) {
@@ -185,15 +278,21 @@ class XtPluginRegistry {
     }
 }
 
+/**
+ * Base implementation of the XtContext interface.
+ * Manages display mode, form integration, child context hierarchy, and value tracking
+ * for an ng-extended component.
+ */
 class XtBaseContext {
     /**
-     *
-     * @param displayMode
-     * @param readOnly
-     * @param parentGroup
-     * @param controlName
+     * Creates a new XtBaseContext instance.
+     * @param displayMode - The display mode for this context
+     * @param subName - Optional sub-name used within a parent form group
+     * @param parentGroup - Optional parent FormGroup for reactive form integration
+     * @param parentContext - Optional parent context for hierarchy management
      */
     constructor(displayMode, subName, parentGroup, parentContext) {
+        /** The current display mode for this context. Defaults to FULL_VIEW. */
         this.displayMode = 'FULL_VIEW';
         /**
          * If it's a reference, we keep the context referenced
@@ -204,7 +303,8 @@ class XtBaseContext {
          * Keeps track of all the possible actions for this context
          * @protected
          */
-        this.listActions = signal(null, ...(ngDevMode ? [{ debugName: "listActions" }] : []));
+        this.listActions = signal(null, ...(ngDevMode ? [{ debugName: "listActions" }] : /* istanbul ignore next */ []));
+        /** Computed signal that returns the current display value from non-form storage. */
         this.displayValue = computed(() => {
             if (this.nonFormValue !== undefined) {
                 return this.nonFormValue();
@@ -212,7 +312,7 @@ class XtBaseContext {
             else {
                 throw new Error("Cannot display a value that does not exist. Are you sure you're not using Reactive Form with this context? " + this.toString());
             }
-        }, ...(ngDevMode ? [{ debugName: "displayValue" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "displayValue" }] : /* istanbul ignore next */ []));
         this.displayMode = displayMode;
         this.parentFormGroup = parentGroup;
         this.parentContext = parentContext;
@@ -225,13 +325,21 @@ class XtBaseContext {
             }
         }
     }
+    /**
+     * Sets the display value for this context when not managed by a reactive form.
+     * Propagates changes to child contexts and optionally notifies the parent context.
+     * @param newValue - The new value to set
+     * @param type - Optional type identifier to assign
+     * @param updateParent - Whether to propagate the change to the parent context (default true)
+     * @returns This context instance for chaining
+     */
     setDisplayValue(newValue, type, updateParent = true) {
         if (newValue !== undefined) {
             const oldValue = this.nonFormValue ? this.nonFormValue() : null;
             if (this.nonFormValue == null) {
                 if ((this.childContexts != null) && (this.childContexts.size > 0))
                     throw new Error('An XtContext with no values cannot have children ', { cause: this });
-                this.nonFormValue = signal(newValue, ...(ngDevMode ? [{ debugName: "nonFormValue" }] : []));
+                this.nonFormValue = signal(newValue, ...(ngDevMode ? [{ debugName: "nonFormValue" }] : /* istanbul ignore next */ []));
             }
             else {
                 this.nonFormValue.set(newValue);
@@ -259,18 +367,35 @@ class XtBaseContext {
             this.valueType = type;
         return this;
     }
+    /**
+     * Checks whether this context is bound to a reactive form group.
+     * @returns True if a form group exists
+     */
     isInForm() {
         return (this.formGroup() != null);
     }
+    /**
+     * Returns the sub-name used as the form control name, or null if not in a form.
+     * @returns The sub-name or null
+     */
     formControlNameOrNull() {
         return this.subName ?? null;
     }
+    /**
+     * Returns the current value from either the non-form signal or the form control.
+     * @returns The current value, or null/undefined
+     */
     value() {
         if (this.nonFormValue != null)
             return this.nonFormValue() ?? this.formControlValue();
         else
             return this.formControlValue();
     }
+    /**
+     * Returns a sub-value by name from the current value object.
+     * @param subsubName - Optional sub-key to retrieve from the value object
+     * @returns The sub-value or the full value if no key is given
+     */
     subValue(subsubName) {
         const value = this.nonFormValue ? this.nonFormValue() : this.formControlValue();
         if ((subsubName != null) && (value != null)) {
@@ -299,6 +424,10 @@ class XtBaseContext {
             throw new Error("No nonFormValue to update subDisplayValue" + this.toString());
         }
     }
+    /**
+     * Retrieves the value from the parent form group for this context's sub-name.
+     * @returns The form control value, or undefined if not in a form
+     */
     formControlValue() {
         let ret = undefined;
         if (this.isInForm()) {
@@ -316,6 +445,12 @@ class XtBaseContext {
         //console.debug("formControlValue of "+this.subName+ " is ",ret);
         return ret;
     }
+    /**
+     * Sets the value in the parent form group for this context's sub-name.
+     * @param newValue - The new value to set on the form control
+     * @param markAsDirty - Whether to mark the control as dirty (default false)
+     * @returns True if the value was successfully set
+     */
     setFormValue(newValue, markAsDirty = false) {
         if (this.isInForm()) {
             if (this.subName != null) {
@@ -366,6 +501,14 @@ class XtBaseContext {
         }
         return ret;
     }
+    /**
+     * Returns or creates a child context for the given sub-name.
+     * Resolves type information and references when a typeResolver is provided.
+     * @param subName - The sub-name for the child context
+     * @param subType - Optional type hint for the child
+     * @param typeResolver - Optional type resolver for resolving sub-types and references
+     * @returns The child XtContext
+     */
     subContext(subName, subType, typeResolver) {
         if ((subName == null) || (subName.length == 0)) {
             return this;
@@ -421,12 +564,24 @@ class XtBaseContext {
             return ret;
         }
     }
+    /**
+     * Returns the available form group, preferring localFormGroup over parentFormGroup.
+     * @returns The form group or undefined
+     */
     formGroup() {
         return this.localFormGroup ?? this.parentFormGroup;
     }
+    /**
+     * Checks whether this context holds a reference to another type.
+     * @returns True if a reference is set
+     */
     isReference() {
         return (this.reference != null);
     }
+    /**
+     * Sets the type reference information for this context.
+     * @param reference - The type reference to set
+     */
     setReferenceInfo(reference) {
         this.reference = reference;
         //this.subReferencesResolved.set(this.reference!=null);
@@ -446,6 +601,10 @@ class XtBaseContext {
       this.referencedContext.setDisplayValue(val);
       if( valueType!=null) this.referencedContext.valueType=valueType;
     }*/
+    /**
+     * Returns a string representation of this context, including its name, type, value, and reference info.
+     * @returns A human-readable description of the context
+     */
     toString() {
         let ret = 'XtContext named ';
         ret += this.subName ?? 'None';
@@ -461,12 +620,27 @@ class XtBaseContext {
     }
 }
 
+/**
+ * Represents a resolved component with its name, class reference, and output capability.
+ * Created by the resolver to indicate which XtComponent should be used for a given context.
+ */
 class XtResolvedComponent {
-    constructor(componantName, componentClass, outputs = false) {
-        this.componentName = componantName;
+    /**
+     * Creates a new XtResolvedComponent instance.
+     * @param componentName - The registered component name
+     * @param componentClass - The Angular component class
+     * @param outputs - Whether the component has outputs (default false)
+     */
+    constructor(componentName, componentClass, outputs = false) {
+        this.componentName = componentName;
         this.componentClass = componentClass;
         this.outputs = outputs;
     }
+    /**
+     * Creates an XtResolvedComponent from an XtComponentInfo.
+     * @param info - The component info from the plugin registry
+     * @returns A new XtResolvedComponent instance
+     */
     static from(info) {
         const ret = new XtResolvedComponent(info.componentName, info.componentClass);
         if ((info.outputs != null) && (info.outputs.length > 0)) {
@@ -476,6 +650,10 @@ class XtResolvedComponent {
     }
 }
 
+/**
+ * Just declare a type marker for Workflows
+ */
+
 /**
  * The global plugin registry.
  * Plugins will register to this when loaded.
@@ -492,19 +670,34 @@ function xtPluginRegistry() {
     return globalThis.XT_REGISTRY;
 }
 
+/** Injection token for providing a custom component resolver */
 const XT_RESOLVER_TOKEN = new InjectionToken('Enable providing a custom component resolver.');
+/** Injection token for providing a custom type resolver */
 const XT_TYPE_RESOLVER_TOKEN = new InjectionToken('Enable providing a custom type resolver.');
+/** Injection token for providing the plugin registry with a default factory */
 const XT_REGISTRY_TOKEN = new InjectionToken("Injects the Plugin Registry right into your angular component", {
     factory: () => {
         return xtPluginRegistry();
     }
 });
 
+/** Resolves components by looking them up in the plugin registry based on context type */
 class XtRegistryResolver {
+    /**
+     * Creates a new XtRegistryResolver
+     * @param registry - The plugin registry to use for component lookups
+     * @param typeResolver - The type resolver for type hierarchy information
+     */
     constructor(registry, typeResolver) {
         this.registry = registry;
         this.typeResolver = typeResolver;
     }
+    /**
+     * Resolves a component for the given context and optional subName
+     * @param baseContext - The context containing type and value information
+     * @param subName - Optional sub-name for nested property resolution
+     * @returns The resolved component info or null if no component matches
+     */
     resolve(baseContext, subName) {
         let typeToFind = baseContext.valueType;
         const typeInfo = this.typeResolver.findType(baseContext.valueType, subName);
@@ -525,9 +718,17 @@ class XtRegistryResolver {
     }
 }
 
+/** Represents a registered action with its metadata and enabled state */
 class XtAction {
+    /**
+     * Creates a new XtAction instance
+     * @param name - The unique name of the action
+     * @param info - Metadata describing the action
+     * @param enabled - Whether the action is initially enabled (defaults to false)
+     */
     constructor(name, info, enabled) {
-        this.enabled = signal(false, ...(ngDevMode ? [{ debugName: "enabled" }] : []));
+        /** Signal indicating whether the action is currently enabled */
+        this.enabled = signal(false, ...(ngDevMode ? [{ debugName: "enabled" }] : /* istanbul ignore next */ []));
         this.name = name;
         this.info = info;
         if (enabled != null) {
@@ -536,178 +737,73 @@ class XtAction {
     }
 }
 
-/**
- * A very light and not 100% compatible storemanager in case you are not using xt-store.
- * It can emulate XtStoreManager to some extends for doing some tests
- */
-class StoreTestHelper {
-    static ensureTestProviderOnly() {
-        StoreSupport.setTestStoreManager(new TestStoreManager());
-    }
-}
-class TestStoreManager {
-    constructor() {
-        this.defaultProvider = new TestStoreProvider();
-    }
-    getProvider(name) {
-        return this.defaultProvider;
-    }
-    getProviderSafe(name) {
-        return this.defaultProvider;
-    }
-    getDefaultProvider() {
-        return this.defaultProvider;
-    }
-    getDefaultProviderSafe() {
-        return this.defaultProvider;
-    }
-    newStoreCriteria(name, value, operator) {
-        return new TestStoreCriteria(name, value, operator);
-    }
-}
-class TestStoreProvider {
-    constructor() {
-        this.data = new Map();
-    }
-    getOrCreateArray(name) {
-        let ret = this.data.get(name);
-        if (ret == null) {
-            ret = new Map();
-            this.data.set(name, ret);
-        }
-        return ret;
-    }
-    extractKey(value, create) {
-        if (value._id != null)
-            return value._id; // ManagedData key
-        else if (value.id != null)
-            return value.id;
-        else {
-            if (create === true) {
-                const newId = Math.random().toString(36).substring(2, 8);
-                value._id = newId;
-                return newId;
-            }
-            return value.toString();
-        }
-    }
-    storeEntity(name, entity) {
-        this.getOrCreateArray(name).set(this.extractKey(entity, true), entity);
-        return Promise.resolve(entity);
-    }
-    safeLoadEntity(name, key) {
-        const ret = this.getOrCreateArray(name).get(key);
-        if (ret == null) {
-            throw new Error("No entity named " + name + " with key " + key);
-        }
-        return Promise.resolve(ret);
-    }
-    loadEntity(name, key) {
-        return Promise.resolve(this.getOrCreateArray(name).get(key));
-    }
-    deleteEntity(name, key) {
-        return Promise.resolve(this.getOrCreateArray(name).delete(key));
-    }
-    searchEntities(name, ...criteria) {
-        // No criteria defined, just send the full list
-        const ret = new Array();
-        if ((criteria == null) || (criteria.length == 0)) {
-            for (const toAdd of this.getOrCreateArray(name).values()) {
-                ret.push(toAdd);
-            }
-        }
-        else {
-            for (const toAdd of this.getOrCreateArray(name).values()) {
-                let canAdd = true;
-                for (const criter of criteria) {
-                    if (!criter.filter(toAdd)) {
-                        canAdd = false;
-                        break;
-                    }
-                }
-                if (canAdd)
-                    ret.push(toAdd);
-            }
-        }
-        return from([ret]);
-    }
-    searchAndPrepareEntities(name, sort, groupBy, transformer, ...criteria) {
-        throw new Error('Method not implemented.');
-    }
-    canStoreDocument() {
-        return true;
-    }
-    storeDocument(toStore) {
-        const ret = new TestDocumentInfo(toStore.name, true, URL.createObjectURL(toStore));
-        return Promise.resolve(ret);
-    }
-    storeDocuments(toStore) {
-        throw new Error('Method not implemented.');
-    }
-}
-class TestDocumentInfo {
-    constructor(documentName, isUrl, documentId) {
-        this.documentId = documentId;
-        this.documentName = documentName;
-        this.isUrl = isUrl;
-    }
-}
-class TestStoreCriteria {
-    constructor(name, value, operator) {
-        this.name = name;
-        this.value = value;
-        if (!operator)
-            this.operator = '=';
-        else {
-            this.operator = operator;
-        }
-    }
-    filter(toFilter) {
-        const testValue = toFilter[this.name];
-        switch (this.operator) {
-            case '=':
-                return testValue == this.value;
-            case '<':
-                return testValue < this.value;
-            case '<=':
-                return testValue < this.value;
-            default:
-                return true;
-        }
-    }
-}
-
 class StoreSupport {
+    /**
+     * Checks if a store manager is available (either test or global)
+     * @returns true if a store manager is available
+     */
     static isStoreManagerAvailable() {
         if (this.testStoreManager != null)
             return true;
         return (globalThis.xtStoreManager != undefined);
     }
+    /**
+     * Gets the current store manager (test or global)
+     * @returns The IStoreManager instance
+     */
     static getStoreManager() {
         return this.testStoreManager ?? (globalThis.xtStoreManager());
     }
+    /**
+     * Sets a test store manager for testing purposes
+     * @param testStoreManager - The test store manager to use
+     */
     static setTestStoreManager(testStoreManager) {
         StoreSupport.testStoreManager = testStoreManager;
     }
+    /**
+     * Creates a new store criteria for filtering
+     * @param name - The property name to filter on
+     * @param value - The value to filter by
+     * @param operator - The comparison operator (defaults to '=')
+     * @returns A new IStoreCriteria instance
+     */
     static newStoreCriteria(name, value, operator) {
-        return new TestStoreCriteria(name, value, operator);
+        if (operator == null)
+            operator = '=';
+        return StoreSupport.getStoreManager().newStoreCriteria(name, value, operator);
     }
 }
+/** Sort direction options */
+var ISortByDirection;
+(function (ISortByDirection) {
+    /** No sorting */
+    ISortByDirection["None"] = "None";
+    /** Sort in ascending order */
+    ISortByDirection["Ascending"] = "Ascending";
+    /** Sort in descending order */
+    ISortByDirection["Descending"] = "Descending";
+})(ISortByDirection || (ISortByDirection = {}));
 
 /**
  * An all in one helper class, enabling manipulation of the context, with data and type associated with it.
  */
 class XtResolverService {
     constructor() {
+        /** Injected plugin registry for component and type registration. */
         this.pluginRegistry = inject(XT_REGISTRY_TOKEN);
+        /** Optional base resolver injected via DI token. */
         this.baseResolver = inject(XT_RESOLVER_TOKEN, { optional: true });
+        /** Optional base type resolver injected via DI token. */
         this.baseTypeResolver = inject(XT_TYPE_RESOLVER_TOKEN, { optional: true });
+        /** Computed signal that lists all registered components. */
         this.listComponents = computed(() => {
             return this.pluginRegistry.listComponents();
-        }, ...(ngDevMode ? [{ debugName: "listComponents" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "listComponents" }] : /* istanbul ignore next */ []));
+        /** Computed signal that lists all registered plugins. */
         this.listPlugins = computed(() => {
             return this.pluginRegistry.listPlugins();
-        }, ...(ngDevMode ? [{ debugName: "listPlugins" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "listPlugins" }] : /* istanbul ignore next */ []));
         if (this.baseTypeResolver == null) {
             this.typeResolver = xtTypeManager();
         }
@@ -719,6 +815,12 @@ class XtResolverService {
         else
             this.resolver = this.baseResolver;
     }
+    /**
+     * Finds the best matching component for the given context and optional sub-name.
+     * @param baseContext - The context to resolve against
+     * @param subName - Optional sub-name for nested resolution
+     * @returns The resolved component descriptor
+     */
     findBestComponent(baseContext, subName) {
         const ret = this.resolver.resolve(baseContext, subName);
         if (ret != null)
@@ -726,10 +828,24 @@ class XtResolverService {
         else
             throw new Error("No components found for this context " + baseContext.toString());
     }
+    /**
+     * Resolves the type name for the given context and optional sub-name.
+     * @param baseContext - The context to query
+     * @param subName - Optional sub-name for nested type resolution
+     * @param value - Optional value for type inference
+     * @returns The type name, or null/undefined
+     */
     findTypeOf(baseContext, subName, value) {
         const ret = this.typeResolver.findTypeName(baseContext.valueType, subName, value);
         return ret;
     }
+    /**
+     * Finds the type handler for the given context, resolving references if necessary.
+     * @param baseContext - The context to query
+     * @param subName - Optional sub-name for nested resolution
+     * @param value - Optional value for handler inference
+     * @returns An object with the type name and its handler
+     */
     findTypeHandlerOf(baseContext, subName, value) {
         let ret = { typeName: undefined, handler: undefined };
         if (baseContext.isReference()) {
@@ -740,16 +856,37 @@ class XtResolverService {
         }
         return ret;
     }
+    /**
+     * Lists the sub-names defined by the type of the given context.
+     * @param baseContext - The context to query
+     * @param value - Optional value for type inference
+     * @returns An array of sub-name strings
+     */
     listSubNamesOf(baseContext, value) {
         return this.typeResolver.listSubNames(baseContext.valueType, value);
     }
+    /**
+     * Lists the sub-names defined by a given value type string.
+     * @param valueType - The type string to query
+     * @param value - Optional value for type inference
+     * @returns An array of sub-name strings
+     */
     listSubNamesOfType(valueType, value) {
         return this.typeResolver.listSubNames(valueType, value);
     }
+    /**
+     * Registers a full plugin including its types and type handlers.
+     * @param info - The plugin information to register
+     */
     registerPlugin(info) {
         this.pluginRegistry.registerPlugin(info);
         this.registerTypes(info.types, info.typeHandlers);
     }
+    /**
+     * Registers type definitions and optional type handlers with the type resolver.
+     * @param types - The type definitions to register
+     * @param handlers - Optional type handler definitions
+     */
     registerTypes(types, handlers) {
         if ((types != null) && (this.typeResolver.canUpdate())) {
             for (const newType in types) {
@@ -809,6 +946,12 @@ class XtResolverService {
             }
         }
     }
+    /**
+     * Checks if a handler is defined for the given type among the provided handler infos.
+     * @param newType - The type to check
+     * @param handlers - The handler definitions to search
+     * @returns A handler instance or null
+     */
     handlerDefinedFor(newType, handlers) {
         for (const handler of handlers ?? []) {
             if (handler.typesHandled.includes(newType)) {
@@ -817,9 +960,19 @@ class XtResolverService {
         }
         return null;
     }
+    /**
+     * Gets the resolved component info for a given component type.
+     * @param type - The component type class
+     * @returns The resolved component descriptor
+     */
     getComponentInfo(type) {
         return XtResolvedComponent.from(this.pluginRegistry.getComponentInfo(type));
     }
+    /**
+     * Finds the resolved component info for a given component type, returning null if not found.
+     * @param type - The component type class
+     * @returns The resolved component descriptor or null
+     */
     findComponentInfo(type) {
         const ret = this.pluginRegistry.findComponentInfo(type);
         if (ret == null)
@@ -830,25 +983,20 @@ class XtResolverService {
     /**
      * Dynamically load a register a plugin from the given url
      * The plugin must export at least a Register entrypoint that will be called right after loading..
-     * @param url
      * @returns a Promise with the module loaded and already registered.
+     * @param module
      */
-    loadPlugin(url) {
-        return loadRemoteModule({
-            remoteEntry: url.toString(),
-            exposedModule: './Register'
-        }).then((module) => {
-            const pluginName = module.registerPlugin(this);
-            // Transform the configured Uris to real urls
-            const pluginConfig = this.pluginRegistry.pluginRegistry.get(pluginName);
-            if (pluginConfig?.uriLogo != null) {
-                let urlString = url.toString();
-                const lastSlash = urlString.lastIndexOf('/');
-                urlString = urlString.substring(0, lastSlash + 1) + pluginConfig?.uriLogo;
-                pluginConfig.uriLogo = urlString;
-            }
-            return module;
-        });
+    registerPluginModule(module, url) {
+        const pluginName = module.registerPlugin(this);
+        // Transform the configured Uris to real urls
+        const pluginConfig = this.pluginRegistry.pluginRegistry.get(pluginName);
+        if (pluginConfig?.uriLogo != null) {
+            let urlString = url.toString();
+            const lastSlash = urlString.lastIndexOf('/');
+            urlString = urlString.substring(0, lastSlash + 1) + pluginConfig?.uriLogo;
+            pluginConfig.uriLogo = urlString;
+        }
+        return true;
     }
     /**
      * Based on the type & value of the element, find which property is on its type and returns it's value
@@ -881,6 +1029,13 @@ class XtResolverService {
         }
         return structuredClone(value);
     }
+    /**
+     * Resolves a mapping helper from the context's value type to a target type.
+     * @param context - The source context
+     * @param targetType - The target type to map to
+     * @param value - Optional value for handler inference
+     * @returns A MappingHelper if a mapping exists, otherwise undefined
+     */
     resolveMappingOf(context, targetType, value) {
         if (context.valueType != null) {
             const typeHandler = this.typeResolver.findTypeHandler(targetType, false, undefined, value);
@@ -893,6 +1048,12 @@ class XtResolverService {
         }
         return undefined;
     }
+    /**
+     * Resolves the referenced value for a context that holds a type reference, using the provided store manager.
+     * @param context - The context with a reference to resolve
+     * @param storeMgr - The store manager for entity lookup
+     * @returns The resolved referenced value(s), or null/undefined
+     */
     async resolveReferencedValue(context, storeMgr) {
         if (!context.isReference())
             return undefined;
@@ -914,6 +1075,9 @@ class XtResolverService {
         }
         return undefined;
     }
+    /**
+     * Resolves all pending type references in the type resolver.
+     */
     resolvePendingReferences() {
         this.typeResolver.resolveAllTypeReferences();
     }
@@ -928,16 +1092,17 @@ class XtResolverService {
         const store = StoreSupport.getStoreManager().getProviderSafe(reference.toType);
         return store.searchEntities(reference.toType);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtResolverService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtResolverService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtResolverService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtResolverService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [] });
 
+/** Default implementation of XtComponentOutput */
 class XtBaseOutput {
 }
 
@@ -948,19 +1113,31 @@ class XtBaseOutput {
  */
 class XtRenderComponent {
     constructor() {
+        /** Injected resolver service for finding the best component */
         this.resolverService = inject(XtResolverService);
-        this.componentType = input(...(ngDevMode ? [undefined, { debugName: "componentType" }] : []));
-        this.displayMode = input.required(...(ngDevMode ? [{ debugName: "displayMode" }] : []));
-        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : []));
-        // Either we set the value directly
-        this.value = model(...(ngDevMode ? [undefined, { debugName: "value" }] : []));
-        // Or we are inside a Form
-        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : []));
-        this.subName = input(...(ngDevMode ? [undefined, { debugName: "subName" }] : []));
+        /** Optional explicit component type to render */
+        this.componentType = input(...(ngDevMode ? [undefined, { debugName: "componentType" }] : /* istanbul ignore next */ []));
+        /** The display mode (e.g. EDIT, VIEW, etc.) */
+        this.displayMode = input.required(...(ngDevMode ? [{ debugName: "displayMode" }] : /* istanbul ignore next */ []));
+        /** The value type identifier used for component resolution */
+        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : /* istanbul ignore next */ []));
+        /** The value to display/edit (used when not inside a form) */
+        this.value = model(...(ngDevMode ? [undefined, { debugName: "value" }] : /* istanbul ignore next */ []));
+        /** The parent form group (used when inside a form) */
+        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : /* istanbul ignore next */ []));
+        /** The sub-name within the form group */
+        this.subName = input(...(ngDevMode ? [undefined, { debugName: "subName" }] : /* istanbul ignore next */ []));
+        /** Object holding the output emitters from the rendered component */
         this.outputsObject = new XtBaseOutput();
-        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : []));
+        /** Inputs to pass through to the rendered component */
+        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : /* istanbul ignore next */ []));
+        /** Emits the outputs from the rendered component */
         this.outputs = output();
+        /** Model signals to pass through to the rendered component */
+        this.models = input(...(ngDevMode ? [undefined, { debugName: "models" }] : /* istanbul ignore next */ []));
+        /** Reference to the NgComponentOutlet used to dynamically render the component */
         this.outlet = viewChild.required(NgComponentOutlet);
+        /** Computed context derived from display mode, form group, value, and value type */
         this.context = computed(() => {
             let form = this.formGroup();
             const ret = new XtBaseContext(this.displayMode(), this.subName(), form);
@@ -980,14 +1157,16 @@ class XtRenderComponent {
                 }
             }
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "context" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
+        /** Computed context that resolves references (if any) */
         this.realContext = computed(() => {
             let ret = this.context();
             /*if ((ret.isReference())&& (ret.referencedContext!=null)) {
               ret = ret.referencedContext;
             }*/
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "realContext" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "realContext" }] : /* istanbul ignore next */ []));
+        /** Computed component type to render, resolved from the context if not explicitly set */
         this.type = computed(() => {
             //console.debug("Calculating type in XtRenderSubComponent");
             let type = this.componentType();
@@ -1001,7 +1180,7 @@ class XtRenderComponent {
                 type = compFound.componentClass;
             }
             return type ?? null;
-        }, ...(ngDevMode ? [{ debugName: "type" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
     }
     /**
      * Transfers the input and outputs from the host to the rendered component
@@ -1025,16 +1204,16 @@ class XtRenderComponent {
             }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtRenderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "20.3.9", type: XtRenderComponent, isStandalone: true, selector: "xt-render", inputs: { componentType: { classPropertyName: "componentType", publicName: "componentType", isSignal: true, isRequired: false, transformFunction: null }, displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: true, transformFunction: null }, valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null }, subName: { classPropertyName: "subName", publicName: "subName", isSignal: true, isRequired: false, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", outputs: "outputs" }, viewQueries: [{ propertyName: "outlet", first: true, predicate: NgComponentOutlet, descendants: true, isSignal: true }], ngImport: i0, template: "<ng-container *ngComponentOutlet=\"type(); inputs: {context:context ()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtRenderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "21.2.7", type: XtRenderComponent, isStandalone: true, selector: "xt-render", inputs: { componentType: { classPropertyName: "componentType", publicName: "componentType", isSignal: true, isRequired: false, transformFunction: null }, displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: true, transformFunction: null }, valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null }, subName: { classPropertyName: "subName", publicName: "subName", isSignal: true, isRequired: false, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, models: { classPropertyName: "models", publicName: "models", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange", outputs: "outputs" }, viewQueries: [{ propertyName: "outlet", first: true, predicate: NgComponentOutlet, descendants: true, isSignal: true }], ngImport: i0, template: "<ng-container *ngComponentOutlet=\"type(); inputs: {context:context (), models:models()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtRenderComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtRenderComponent, decorators: [{
             type: Component,
             args: [{ selector: 'xt-render', standalone: true, imports: [
                         NgComponentOutlet,
                         ReactiveFormsModule
-                    ], template: "<ng-container *ngComponentOutlet=\"type(); inputs: {context:context ()}\" />\n" }]
-        }], ctorParameters: () => [], propDecorators: { componentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentType", required: false }] }], displayMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "displayMode", required: true }] }], valueType: [{ type: i0.Input, args: [{ isSignal: true, alias: "valueType", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], formGroup: [{ type: i0.Input, args: [{ isSignal: true, alias: "formGroup", required: false }] }], subName: [{ type: i0.Input, args: [{ isSignal: true, alias: "subName", required: false }] }], inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputs", required: false }] }], outputs: [{ type: i0.Output, args: ["outputs"] }], outlet: [{ type: i0.ViewChild, args: [i0.forwardRef(() => NgComponentOutlet), { isSignal: true }] }] } });
+                    ], template: "<ng-container *ngComponentOutlet=\"type(); inputs: {context:context (), models:models()}\" />\n" }]
+        }], ctorParameters: () => [], propDecorators: { componentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentType", required: false }] }], displayMode: [{ type: i0.Input, args: [{ isSignal: true, alias: "displayMode", required: true }] }], valueType: [{ type: i0.Input, args: [{ isSignal: true, alias: "valueType", required: false }] }], value: [{ type: i0.Input, args: [{ isSignal: true, alias: "value", required: false }] }, { type: i0.Output, args: ["valueChange"] }], formGroup: [{ type: i0.Input, args: [{ isSignal: true, alias: "formGroup", required: false }] }], subName: [{ type: i0.Input, args: [{ isSignal: true, alias: "subName", required: false }] }], inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputs", required: false }] }], outputs: [{ type: i0.Output, args: ["outputs"] }], models: [{ type: i0.Input, args: [{ isSignal: true, alias: "models", required: false }] }], outlet: [{ type: i0.ViewChild, args: [i0.forwardRef(() => NgComponentOutlet), { isSignal: true }] }] } });
 
 /**
  * Dynamically render a component that will display the given subValue.
@@ -1042,20 +1221,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  */
 class XtRenderSubComponent {
     constructor() {
-        this.context = input.required(...(ngDevMode ? [{ debugName: "context" }] : []));
-        this.componentType = input(...(ngDevMode ? [undefined, { debugName: "componentType" }] : []));
+        /** The context containing display mode, form group, and value for the sub-component */
+        this.context = input.required(...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
+        /** Optional explicit component type to render */
+        this.componentType = input(...(ngDevMode ? [undefined, { debugName: "componentType" }] : /* istanbul ignore next */ []));
+        /** Object holding the output emitters from the rendered sub-component */
         this.outputsObject = new XtBaseOutput();
-        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : []));
+        /** Inputs to pass through to the rendered sub-component */
+        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : /* istanbul ignore next */ []));
+        /** Emits the outputs from the rendered sub-component */
         this.outputs = output();
+        /** Model signals to pass through to the rendered sub-component */
+        this.models = input(...(ngDevMode ? [undefined, { debugName: "models" }] : /* istanbul ignore next */ []));
+        /** Reference to the NgComponentOutlet used to dynamically render the sub-component */
         this.outlet = viewChild.required(NgComponentOutlet);
+        /** Injected resolver service for finding the best component */
         this.resolverService = inject(XtResolverService);
+        /** Computed context that resolves references (if any) */
         this.realContext = computed(() => {
             let ret = this.context();
             /*if ((ret.isReference()) && (ret.referencedContext!=null)) {
               ret = ret.referencedContext;
             }*/
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "realContext" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "realContext" }] : /* istanbul ignore next */ []));
+        /** Computed component type to render, resolved from the context if not explicitly set */
         this.type = computed(() => {
             //console.debug("Calculating type in XtRenderSubComponent");
             let type = this.componentType();
@@ -1069,7 +1259,7 @@ class XtRenderSubComponent {
                 type = compFound.componentClass;
             }
             return type ?? null;
-        }, ...(ngDevMode ? [{ debugName: "type" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
     }
     /**
      * Transfers the input and outputs from the host to the rendered component
@@ -1093,17 +1283,18 @@ class XtRenderSubComponent {
             }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtRenderSubComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "20.3.9", type: XtRenderSubComponent, isStandalone: true, selector: "xt-render-sub", inputs: { context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: true, transformFunction: null }, componentType: { classPropertyName: "componentType", publicName: "componentType", isSignal: true, isRequired: false, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outputs: "outputs" }, viewQueries: [{ propertyName: "outlet", first: true, predicate: NgComponentOutlet, descendants: true, isSignal: true }], ngImport: i0, template: "{{componentType()}}\n<ng-container *ngComponentOutlet=\"type(); inputs: {context:realContext ()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtRenderSubComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "21.2.7", type: XtRenderSubComponent, isStandalone: true, selector: "xt-render-sub", inputs: { context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: true, transformFunction: null }, componentType: { classPropertyName: "componentType", publicName: "componentType", isSignal: true, isRequired: false, transformFunction: null }, inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, models: { classPropertyName: "models", publicName: "models", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outputs: "outputs" }, viewQueries: [{ propertyName: "outlet", first: true, predicate: NgComponentOutlet, descendants: true, isSignal: true }], ngImport: i0, template: "{{componentType()}}\n<ng-container *ngComponentOutlet=\"type(); inputs: {context:realContext (), models:models()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtRenderSubComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtRenderSubComponent, decorators: [{
             type: Component,
             args: [{ selector: 'xt-render-sub', standalone: true, imports: [
                         NgComponentOutlet,
                         ReactiveFormsModule
-                    ], template: "{{componentType()}}\n<ng-container *ngComponentOutlet=\"type(); inputs: {context:realContext ()}\" />\n" }]
-        }], propDecorators: { context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: true }] }], componentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentType", required: false }] }], inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputs", required: false }] }], outputs: [{ type: i0.Output, args: ["outputs"] }], outlet: [{ type: i0.ViewChild, args: [i0.forwardRef(() => NgComponentOutlet), { isSignal: true }] }] } });
+                    ], template: "{{componentType()}}\n<ng-container *ngComponentOutlet=\"type(); inputs: {context:realContext (), models:models()}\" />\n" }]
+        }], propDecorators: { context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: true }] }], componentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentType", required: false }] }], inputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "inputs", required: false }] }], outputs: [{ type: i0.Output, args: ["outputs"] }], models: [{ type: i0.Input, args: [{ isSignal: true, alias: "models", required: false }] }], outlet: [{ type: i0.ViewChild, args: [i0.forwardRef(() => NgComponentOutlet), { isSignal: true }] }] } });
 
+/** Default implementation of XtComponentInput */
 class XtBaseInput {
 }
 
@@ -1113,59 +1304,77 @@ class XtBaseInput {
  */
 class XtSimpleComponent {
     constructor() {
-        this.context = input.required(...(ngDevMode ? [{ debugName: "context" }] : []));
+        /** Required input signal providing the XtContext for this component. */
+        this.context = input.required(...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
+        /** Object holding the base output definitions for this component. */
         this.outputsObject = new XtBaseOutput();
+        /** Object holding the base input definitions for this component. */
         this.inputsObject = new XtBaseInput();
+        /** Output emitter that publishes the component's output map. */
         this.outputs = output();
+        /** Input signal accepting model bindings for two-way data flow. */
+        this.models = input(...(ngDevMode ? [undefined, { debugName: "models" }] : /* istanbul ignore next */ []));
+        /** Computed signal indicating whether this component is inside a reactive form. */
         this.isInForm = computed(() => {
             return this.context()?.isInForm() ?? false;
-        }, ...(ngDevMode ? [{ debugName: "isInForm" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "isInForm" }] : /* istanbul ignore next */ []));
+        /** Computed signal returning the form control name, if any. */
         this.formControlNameIfAny = computed(() => {
             return this.context()?.subName;
-        }, ...(ngDevMode ? [{ debugName: "formControlNameIfAny" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formControlNameIfAny" }] : /* istanbul ignore next */ []));
+        /** Computed signal returning the form group if one exists, or undefined. */
         this.formGroupIfAny = computed(() => {
             return this.context()?.formGroup();
-        }, ...(ngDevMode ? [{ debugName: "formGroupIfAny" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formGroupIfAny" }] : /* istanbul ignore next */ []));
+        /** Computed signal returning the form group, throwing if none exists. */
         this.formGroup = computed(() => {
             const ret = this.context()?.formGroup();
             if (ret == null)
                 throw new Error('No form groups in this component of type ' + this.componentDescriptor());
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "formGroup" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formGroup" }] : /* istanbul ignore next */ []));
         /**
          * Returns the component form name, which is for now the subName
          */
         this.componentNameInForm = computed(() => {
             return this.safelyGetSubName();
-        }, ...(ngDevMode ? [{ debugName: "componentNameInForm" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "componentNameInForm" }] : /* istanbul ignore next */ []));
+        /** Computed signal that safely returns the sub-name, throwing if it is null. */
         this.safelyGetSubName = computed(() => {
             const ret = this.context()?.subName;
             if (ret == null)
                 throw new Error('This component has no name in the form ' + this.componentDescriptor());
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "safelyGetSubName" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "safelyGetSubName" }] : /* istanbul ignore next */ []));
         /**
-         * Returns the form control name and create a form control behind the scene
+         * Computed signal returning the form control name for this component.
          */
         this.formControlName = computed(() => {
             const ret = this.safelyGetSubName();
             //this.manageFormControl<any>(ret); // Don't create anything at this point. It's a computed value.
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "formControlName" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formControlName" }] : /* istanbul ignore next */ []));
+        /** Computed signal that retrieves the existing AbstractControl for this component's sub-name. */
         this.formControl = computed(() => {
             const subName = this.safelyGetSubName();
             const formControl = this.manageFormControl(subName, false);
             if (formControl == null)
                 throw new Error("Calling formControl for subName " + subName + " when none exist.");
             return formControl;
-        }, ...(ngDevMode ? [{ debugName: "formControl" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formControl" }] : /* istanbul ignore next */ []));
+        /** Computed signal exposing the raw value from the context. */
         this.getValue = computed(() => {
             return this.context().value();
-        }, ...(ngDevMode ? [{ debugName: "getValue" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "getValue" }] : /* istanbul ignore next */ []));
+        /** Computed signal exposing the display value from the context. */
         this.displayValue = computed(() => {
             return this.context().displayValue();
-        }, ...(ngDevMode ? [{ debugName: "displayValue" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "displayValue" }] : /* istanbul ignore next */ []));
     }
+    /**
+     * Angular lifecycle hook. Sets up input/output bindings and emits outputs
+     * if any output objects have been defined.
+     */
     ngOnInit() {
         this.setupInputOutput();
         if (Object.keys(this.outputsObject).length > 0) {
@@ -1173,6 +1382,13 @@ class XtSimpleComponent {
             this.outputs.emit(this.outputsObject);
         }
     }
+    /**
+     * Manages a form control within the component's form group, optionally creating it if it does not exist.
+     * Can be safely called even when no form group is available.
+     * @param ctrlName - The name of the form control
+     * @param create - Whether to create the control if it does not exist (default true)
+     * @returns The AbstractControl, or undefined if no form group is available
+     */
     manageFormControl(ctrlName, create = true) {
         const formGroup = this.formGroupIfAny();
         if (formGroup == null) {
@@ -1189,6 +1405,10 @@ class XtSimpleComponent {
             return ctrl ?? undefined;
         }
     }
+    /**
+     * Returns a human-readable descriptor for this component.
+     * @returns A string describing the component type and context
+     */
     componentDescriptor() {
         return "Component with type " + this.constructor.name + " with context " + this.context().toString();
     }
@@ -1199,22 +1419,33 @@ class XtSimpleComponent {
     setupInputOutput() {
         // Nothing to do here
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.9", type: XtSimpleComponent, isStandalone: true, selector: "ng-component", inputs: { context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { outputs: "outputs" }, ngImport: i0, template: '', isInline: true }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.7", type: XtSimpleComponent, isStandalone: true, selector: "ng-component", inputs: { context: { classPropertyName: "context", publicName: "context", isSignal: true, isRequired: true, transformFunction: null }, models: { classPropertyName: "models", publicName: "models", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { outputs: "outputs" }, ngImport: i0, template: '', isInline: true }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtSimpleComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtSimpleComponent, decorators: [{
             type: Component,
             args: [{
                     standalone: true,
                     imports: [],
                     template: ''
                 }]
-        }], ctorParameters: () => [], propDecorators: { context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: true }] }], outputs: [{ type: i0.Output, args: ["outputs"] }] } });
+        }], ctorParameters: () => [], propDecorators: { context: [{ type: i0.Input, args: [{ isSignal: true, alias: "context", required: true }] }], outputs: [{ type: i0.Output, args: ["outputs"] }], models: [{ type: i0.Input, args: [{ isSignal: true, alias: "models", required: false }] }] } });
 
+/**
+ * A composite XtComponent that manages a form group for its sub-elements.
+ * Extends XtSimpleComponent to provide context-based form group management
+ * and sub-context resolution for nested components.
+ * Selector: not directly used (abstract base via template).
+ */
 class XtCompositeComponent extends XtSimpleComponent {
     constructor() {
         super(...arguments);
+        /** Injected service for resolving components and type information. */
         this.resolverService = inject(XtResolverService);
+        /**
+         * Computes the local form group for this composite, creating one from the parent form group if it does not exist.
+         * Overrides the base implementation to manage a dedicated form group for sub-elements.
+         */
         this.formGroupIfAny = computed(() => {
             const context = this.context();
             if (context == null)
@@ -1231,7 +1462,7 @@ class XtCompositeComponent extends XtSimpleComponent {
                 ret = context.localFormGroup;
             }
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "formGroupIfAny" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formGroupIfAny" }] : /* istanbul ignore next */ []));
         /**
          * We need to create a new form group to manage the sub elements.
          */
@@ -1240,55 +1471,85 @@ class XtCompositeComponent extends XtSimpleComponent {
             if (ret == null)
                 throw new Error('No form groups in this component of type ' + this.componentDescriptor());
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "formGroup" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "formGroup" }] : /* istanbul ignore next */ []));
     }
     /**
-     * Helper function to calculate the sub context
-     * @param subName
-     * @param subType
+     * Helper function to calculate the sub context for a named child element.
+     * @param subName - The name of the sub-element
+     * @param subType - Optional type hint for the sub-element
+     * @returns The sub-context for the given child
      */
     subContext(subName, subType) {
         this.formGroupIfAny(); // Ensure the context is properly initialized
         return this.context().subContext(subName, subType, this.resolverService.typeResolver);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtCompositeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.9", type: XtCompositeComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [""] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtCompositeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.7", type: XtCompositeComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [""] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtCompositeComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtCompositeComponent, decorators: [{
             type: Component,
             args: [{ standalone: true, imports: [], template: '' }]
         }] });
 
+/** Default implementation of XtComponentModel */
+class XtBaseModel {
+}
+
+/** Service for handling error and warning messages throughout the application */
 class XtMessageHandler {
+    /**
+     * Handles an error occurrence by logging it to the console
+     * @param error - The error object
+     * @param errorMsg - Optional custom error message
+     */
     errorOccurred(error, errorMsg) {
         console.error(errorMsg, error);
     }
+    /**
+     * Handles a warning occurrence by logging it to the console
+     * @param warningMsg - Optional warning message
+     */
     warningOccurred(warningMsg) {
         console.warn(warningMsg);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtMessageHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtMessageHandler, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtMessageHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtMessageHandler, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: XtMessageHandler, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: XtMessageHandler, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
 
+/**
+ * Attaches a value to a form group by creating either a FormControl or nested FormGroup based on the value type
+ * @param formGroup - The form group to attach to
+ * @param controlName - The control name within the form group
+ * @param value - The value to attach
+ * @param valueType - Optional type identifier for type resolution
+ * @param resolver - Optional type resolver for determining if the value is primitive
+ */
 function attachToFormGroup(formGroup, controlName, value, valueType, resolver) {
     // If it's a single value, just create the control
     if (((value != null) && (isPrimitive(value))
         || (resolver?.isPrimitiveType(valueType)))) {
         const simpleControl = new FormControl(value);
-        formGroup.addControl(controlName, simpleControl);
+        formGroup.setControl(controlName, simpleControl);
     }
     else {
         const complexGroup = new FormGroup({});
         updateFormGroupWithValue(complexGroup, value, valueType, resolver);
-        formGroup.addControl(controlName, complexGroup);
+        formGroup.setControl(controlName, complexGroup);
     }
 }
+/**
+ * Updates a form group with the properties from a value object, adding, updating, or removing controls as needed
+ * @param formGroup - The form group to update
+ * @param value - The value object containing the properties to sync
+ * @param valueType - Optional type identifier for type resolution
+ * @param resolver - Optional type resolver for determining property types
+ */
 function updateFormGroupWithValue(formGroup, value, valueType, resolver) {
     const toDelete = new Set(Object.keys(formGroup.controls));
     // We merge the properties of the value if any, with the properties of the model
@@ -1353,7 +1614,27 @@ function updateFormGroupWithValue(formGroup, value, valueType, resolver) {
     }
 }
 
+/**
+ * Helper class to ease unit testing
+ */
 class XtUnitTestHelper {
+    /*  public static registerComponent<T> (name:string, compClass:T, type:string){
+        this.resolverService.pluginRegistry.registerComponent({
+          componentName:name,
+          componentClass: compClass,
+          typesHandled: [type]
+        });
+      }
+    */
+    /**
+     * Asynchronously wait for test function to return true. By default try 20 times with a delay of 50ms
+     * @param test
+     * @param tries
+     * @param timer
+     */
+    static async waitFor(test, tries = 20, timer = 50) {
+        await lastValueFrom(range(0, tries).pipe(delay(timer), find(test)));
+    }
 }
 
 /**
@@ -1362,14 +1643,17 @@ class XtUnitTestHelper {
  */
 class HostTestSimpleComponent {
     constructor() {
-        this.type = input.required(...(ngDevMode ? [{ debugName: "type" }] : []));
-        this.displayMode = input('FULL_VIEW', ...(ngDevMode ? [{ debugName: "displayMode" }] : []));
-        this.value = input(undefined, ...(ngDevMode ? [{ debugName: "value" }] : []));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.9", type: HostTestSimpleComponent, isStandalone: true, selector: "test-host", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Simple Component</h1> <xt-render [componentType]="type()" [displayMode]="displayMode()" [value]="value()" ></xt-render> ', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderComponent, selector: "xt-render", inputs: ["componentType", "displayMode", "valueType", "value", "formGroup", "subName", "inputs"], outputs: ["valueChange", "outputs"] }] }); }
+        /** Required input for the component type to render. */
+        this.type = input.required(...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
+        /** Input for the display mode. Defaults to FULL_VIEW. */
+        this.displayMode = input('FULL_VIEW', ...(ngDevMode ? [{ debugName: "displayMode" }] : /* istanbul ignore next */ []));
+        /** Input for the value to pass to the rendered component. */
+        this.value = input(undefined, ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.7", type: HostTestSimpleComponent, isStandalone: true, selector: "test-host", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Simple Component</h1> <xt-render [componentType]="type()" [displayMode]="displayMode()" [value]="value()" ></xt-render> ', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderComponent, selector: "xt-render", inputs: ["componentType", "displayMode", "valueType", "value", "formGroup", "subName", "inputs", "models"], outputs: ["valueChange", "outputs"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestSimpleComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestSimpleComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-host',
@@ -1385,48 +1669,61 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  */
 class HostTestFormComponent {
     constructor() {
+        /** Injected FormBuilder for creating form groups. */
         this.builder = inject(FormBuilder);
-        this.type = input.required(...(ngDevMode ? [{ debugName: "type" }] : []));
-        this.controlName = input.required(...(ngDevMode ? [{ debugName: "controlName" }] : []));
-        // You can send the description to be used in a FormBuilder to create the formgroup;
-        this.formDescription = input({}, ...(ngDevMode ? [{ debugName: "formDescription" }] : []));
-        // Or set the FormGroup directly
-        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : []));
-        //  parentFormGroup = this.builder.group<{[keys:string]: AbstractControl}>({});
-        this.createdFormGroup = null;
-    }
-    computedFormGroup() {
-        if (this.createdFormGroup == null) {
-            const formGroup = this.formGroup();
-            this.createdFormGroup = formGroup ?? generateFormGroup(this.formDescription());
-        }
-        //  this.parentFormGroup.addControl(this.controlName()??HostTestTypedFormComponent.CONTROL_NAME, this.createdFormGroup);
-        return this.createdFormGroup;
+        /** Required input for the component type to render. */
+        this.type = input.required(...(ngDevMode ? [{ debugName: "type" }] : /* istanbul ignore next */ []));
+        /** Required input for the form control name. */
+        this.controlName = input.required(...(ngDevMode ? [{ debugName: "controlName" }] : /* istanbul ignore next */ []));
+        /** Input for the form description object used to generate the form group. */
+        this.formDescription = input({}, ...(ngDevMode ? [{ debugName: "formDescription" }] : /* istanbul ignore next */ []));
+        /** Input to provide an existing FormGroup directly. */
+        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : /* istanbul ignore next */ []));
+        /** The parent FormGroup that contains the component's form group. */
+        this.parentFormGroup = this.builder.group({});
+        /** Computed signal returning the created form group. */
+        this.createdFormGroup = computed(() => {
+            return this.computeFormGroup();
+        }, ...(ngDevMode ? [{ debugName: "createdFormGroup" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Computes the form group from the input, either using a provided form group or generating one from the form description.
+     * @returns The created FormGroup
+     */
+    computeFormGroup() {
+        const formGroup = this.formGroup();
+        let createdFormGroup = formGroup ?? generateFormGroup(this.formDescription());
+        this.parentFormGroup.addControl(this.controlName() ?? HostTestTypedFormComponent.CONTROL_NAME, createdFormGroup);
+        return createdFormGroup;
     }
+    /**
+     * Patches the component's form control with a new value.
+     * @param newVal - The value to patch
+     */
     patchValue(newVal) {
         const patch = {};
         patch[this.controlName()] = newVal;
-        if (this.createdFormGroup != null)
-            this.createdFormGroup.patchValue(patch);
-        else
-            throw new Error("FormGroup not yet created. Did you set formGroup or formDescription property ?");
+        const createdFormGroup = this.createdFormGroup();
+        createdFormGroup.patchValue(patch);
     }
+    /**
+     * Retrieves the current value from the component's form control.
+     * @returns The current form value
+     */
     retrieveValue() {
-        if (this.createdFormGroup != null)
-            return this.createdFormGroup.value[this.controlName()];
-        else
-            throw new Error("FormGroup not yet created. Did you set formGroup or formDescription property ?");
+        const createdFormGroup = this.createdFormGroup();
+        return createdFormGroup.value[this.controlName()];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.9", type: HostTestFormComponent, isStandalone: true, selector: "test-form-host", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, controlName: { classPropertyName: "controlName", publicName: "controlName", isSignal: true, isRequired: true, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Form Component</h1> <form [formGroup]="computedFormGroup()"> <xt-render [componentType]="type()" displayMode="FULL_EDITABLE" [subName]="controlName()" [formGroup]="computedFormGroup()"></xt-render></form>', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderComponent, selector: "xt-render", inputs: ["componentType", "displayMode", "valueType", "value", "formGroup", "subName", "inputs"], outputs: ["valueChange", "outputs"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.7", type: HostTestFormComponent, isStandalone: true, selector: "test-form-host", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, controlName: { classPropertyName: "controlName", publicName: "controlName", isSignal: true, isRequired: true, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Form Component</h1> <form [formGroup]="parentFormGroup"> <xt-render [componentType]="type()" displayMode="FULL_EDITABLE" [subName]="controlName()" [formGroup]="createdFormGroup()"></xt-render></form>', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderComponent, selector: "xt-render", inputs: ["componentType", "displayMode", "valueType", "value", "formGroup", "subName", "inputs", "models"], outputs: ["valueChange", "outputs"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],[formArray],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestFormComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestFormComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-form-host',
                     standalone: true,
                     imports: [CommonModule, XtRenderComponent, ReactiveFormsModule],
-                    template: '<h1>Test Form Component</h1> <form [formGroup]="computedFormGroup()"> <xt-render [componentType]="type()" displayMode="FULL_EDITABLE" [subName]="controlName()" [formGroup]="computedFormGroup()"></xt-render></form>'
+                    template: '<h1>Test Form Component</h1> <form [formGroup]="parentFormGroup"> <xt-render [componentType]="type()" displayMode="FULL_EDITABLE" [subName]="controlName()" [formGroup]="createdFormGroup()"></xt-render></form>'
                 }]
         }], propDecorators: { type: [{ type: i0.Input, args: [{ isSignal: true, alias: "type", required: true }] }], controlName: [{ type: i0.Input, args: [{ isSignal: true, alias: "controlName", required: true }] }], formDescription: [{ type: i0.Input, args: [{ isSignal: true, alias: "formDescription", required: false }] }], formGroup: [{ type: i0.Input, args: [{ isSignal: true, alias: "formGroup", required: false }] }] } });
 /**
@@ -1435,20 +1732,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  */
 class HostTestTypedComponent {
     constructor() {
-        this.displayMode = input('FULL_VIEW', ...(ngDevMode ? [{ debugName: "displayMode" }] : []));
-        this.value = input(...(ngDevMode ? [undefined, { debugName: "value" }] : []));
-        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : []));
+        /** Input for the display mode. Defaults to FULL_VIEW. */
+        this.displayMode = input('FULL_VIEW', ...(ngDevMode ? [{ debugName: "displayMode" }] : /* istanbul ignore next */ []));
+        /** Input for the value to display. */
+        this.value = input(...(ngDevMode ? [undefined, { debugName: "value" }] : /* istanbul ignore next */ []));
+        /** Input for the value type string used for context creation. */
+        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : /* istanbul ignore next */ []));
+        /** Computed signal that creates the XtBaseContext from the input values. */
         this.context = computed(() => {
             const ret = new XtBaseContext(this.displayMode());
             ret.valueType = this.valueType();
             ret.setDisplayValue(this.value());
             return ret;
-        }, ...(ngDevMode ? [{ debugName: "context" }] : []));
+        }, ...(ngDevMode ? [{ debugName: "context" }] : /* istanbul ignore next */ []));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestTypedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.9", type: HostTestTypedComponent, isStandalone: true, selector: "test-typed-host", inputs: { displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Typed Component</h1> <xt-render-sub [context]="context()" ></xt-render-sub> ', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderSubComponent, selector: "xt-render-sub", inputs: ["context", "componentType", "inputs"], outputs: ["outputs"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestTypedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.7", type: HostTestTypedComponent, isStandalone: true, selector: "test-typed-host", inputs: { displayMode: { classPropertyName: "displayMode", publicName: "displayMode", isSignal: true, isRequired: false, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Typed Component</h1> <xt-render-sub [context]="context()" ></xt-render-sub> ', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: XtRenderSubComponent, selector: "xt-render-sub", inputs: ["context", "componentType", "inputs", "models"], outputs: ["outputs"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestTypedComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestTypedComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-typed-host',
@@ -1464,64 +1765,84 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
  */
 class HostTestTypedFormComponent {
     constructor() {
+        /** Injected FormBuilder for creating form groups. */
         this.builder = inject(FormBuilder);
+        /** Injected resolver service for type resolution. */
         this.resolver = inject(XtResolverService);
-        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : []));
-        this.controlName = input(...(ngDevMode ? [undefined, { debugName: "controlName" }] : []));
-        // You can send the description to be used in a FormBuilder to create the formgroup;
-        this.formDescription = input(null, ...(ngDevMode ? [{ debugName: "formDescription" }] : []));
-        // Or set the FormGroup directly
-        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : []));
+        /** Input for the value type string. */
+        this.valueType = input(...(ngDevMode ? [undefined, { debugName: "valueType" }] : /* istanbul ignore next */ []));
+        /** Input for the form control name. */
+        this.controlName = input(...(ngDevMode ? [undefined, { debugName: "controlName" }] : /* istanbul ignore next */ []));
+        /** Input for the form description used to generate the form group. */
+        this.formDescription = input(null, ...(ngDevMode ? [{ debugName: "formDescription" }] : /* istanbul ignore next */ []));
+        /** Input to provide an existing FormGroup directly. */
+        this.formGroup = input(...(ngDevMode ? [undefined, { debugName: "formGroup" }] : /* istanbul ignore next */ []));
+        /** The parent FormGroup that contains the component's form group. */
         this.parentFormGroup = this.builder.group({});
-        this.createdFormGroup = null;
+        /** Computed signal returning the created form group. */
+        this.createdFormGroup = computed(() => {
+            return this.computeFormGroup();
+        }, ...(ngDevMode ? [{ debugName: "createdFormGroup" }] : /* istanbul ignore next */ []));
+        /** Computed signal that builds the XtBaseContext from form group and control name. */
+        this.subContext = computed(() => {
+            const ctrlName = this.controlName();
+            const createdFormGroup = this.createdFormGroup();
+            let ret = null;
+            if (ctrlName == null) {
+                ret = new XtBaseContext('FULL_EDITABLE', HostTestTypedFormComponent.CONTROL_NAME, this.parentFormGroup);
+            }
+            else {
+                ret = new XtBaseContext('FULL_EDITABLE', ctrlName, createdFormGroup);
+            }
+            ret.valueType = this.valueType();
+            return ret;
+        }, ...(ngDevMode ? [{ debugName: "subContext" }] : /* istanbul ignore next */ []));
     }
+    /** Default control name used if none is provided. */
     static { this.CONTROL_NAME = 'ForTest'; }
     ngOnInit() {
-        this.computeFormGroup();
     }
+    /**
+     * Computes the form group from inputs, generating one from description or type if needed.
+     * @returns The created FormGroup
+     */
     computeFormGroup() {
-        if (this.createdFormGroup == null) {
-            const formGroup = this.formGroup();
-            if (this.formDescription() != null) {
-                this.createdFormGroup = formGroup ?? generateFormGroup(this.formDescription());
-            }
-            else {
-                this.createdFormGroup = this.builder.group({});
-                if (this.valueType() != null) {
-                    updateFormGroupWithValue(this.createdFormGroup, {}, this.valueType(), this.resolver.typeResolver);
-                }
-            }
-            this.parentFormGroup.addControl(this.controlName() ?? HostTestTypedFormComponent.CONTROL_NAME, this.createdFormGroup);
-        }
-        return this.createdFormGroup;
-    }
-    ;
-    subContext() {
-        this.computeFormGroup(); // Make sure the subformgroups are created
-        const ctrlName = this.controlName();
-        let ret = null;
-        if (ctrlName == null) {
-            ret = new XtBaseContext('FULL_EDITABLE', HostTestTypedFormComponent.CONTROL_NAME, this.parentFormGroup);
+        let createdFormGroup = null;
+        const formGroup = this.formGroup();
+        if (this.formDescription() != null) {
+            createdFormGroup = formGroup ?? generateFormGroup(this.formDescription());
         }
         else {
-            ret = new XtBaseContext('FULL_EDITABLE', ctrlName, this.createdFormGroup);
+            createdFormGroup = this.builder.group({});
+            if (this.valueType() != null) {
+                updateFormGroupWithValue(createdFormGroup, {}, this.valueType(), this.resolver.typeResolver);
+            }
         }
-        ret.valueType = this.valueType();
-        return ret;
+        this.parentFormGroup.addControl(this.controlName() ?? HostTestTypedFormComponent.CONTROL_NAME, createdFormGroup);
+        return createdFormGroup;
     }
-    ;
+    /**
+     * Patches a form control with a new value.
+     * @param controlName - The name of the control to patch
+     * @param newVal - The value to set
+     */
     patchValue(controlName, newVal) {
         const patch = {};
         patch[controlName] = newVal;
-        this.computeFormGroup().patchValue(patch);
+        this.createdFormGroup().patchValue(patch);
     }
+    /**
+     * Retrieves the current value from a form control.
+     * @param controlName - The name of the control to read
+     * @returns The current form value
+     */
     retrieveValue(controlName) {
-        return this.computeFormGroup().value[controlName];
+        return this.createdFormGroup().value[controlName];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestTypedFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.3.9", type: HostTestTypedFormComponent, isStandalone: true, selector: "test-typed-form-host", inputs: { valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null }, controlName: { classPropertyName: "controlName", publicName: "controlName", isSignal: true, isRequired: false, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Typed Form Component</h1> <form [formGroup]="parentFormGroup"> <xt-render-sub [context]="subContext()"></xt-render-sub></form>', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: XtRenderSubComponent, selector: "xt-render-sub", inputs: ["context", "componentType", "inputs"], outputs: ["outputs"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestTypedFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "21.2.7", type: HostTestTypedFormComponent, isStandalone: true, selector: "test-typed-form-host", inputs: { valueType: { classPropertyName: "valueType", publicName: "valueType", isSignal: true, isRequired: false, transformFunction: null }, controlName: { classPropertyName: "controlName", publicName: "controlName", isSignal: true, isRequired: false, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, formGroup: { classPropertyName: "formGroup", publicName: "formGroup", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: '<h1>Test Typed Form Component</h1> <form [formGroup]="parentFormGroup"> <xt-render-sub [context]="subContext()"></xt-render-sub></form>', isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],[formArray],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: XtRenderSubComponent, selector: "xt-render-sub", inputs: ["context", "componentType", "inputs", "models"], outputs: ["outputs"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImport: i0, type: HostTestTypedFormComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.7", ngImport: i0, type: HostTestTypedFormComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-typed-form-host',
@@ -1530,12 +1851,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.9", ngImpor
                     template: '<h1>Test Typed Form Component</h1> <form [formGroup]="parentFormGroup"> <xt-render-sub [context]="subContext()"></xt-render-sub></form>'
                 }]
         }], propDecorators: { valueType: [{ type: i0.Input, args: [{ isSignal: true, alias: "valueType", required: false }] }], controlName: [{ type: i0.Input, args: [{ isSignal: true, alias: "controlName", required: false }] }], formDescription: [{ type: i0.Input, args: [{ isSignal: true, alias: "formDescription", required: false }] }], formGroup: [{ type: i0.Input, args: [{ isSignal: true, alias: "formGroup", required: false }] }] } });
+/**
+ * Generates a FormGroup from a form description object.
+ * @param formDescription - The description object used to build the form group
+ * @returns A FormGroup instance
+ */
 function generateFormGroup(formDescription) {
     if (typeof formDescription != 'object') {
         throw new Error('Form Description should be an object of values');
     }
     return generateFormControl(formDescription);
 }
+/**
+ * Recursively generates an AbstractControl from a form description value.
+ * Handles null, arrays, objects (as FormGroup), and primitive values (as FormControl).
+ * @param formDescription - The value to convert into a form control
+ * @returns An AbstractControl instance
+ */
 function generateFormControl(formDescription) {
     if (formDescription == null) {
         return new FormControl(formDescription);
@@ -1557,6 +1889,265 @@ function generateFormControl(formDescription) {
     return new FormControl(formDescription);
 }
 
+/**
+ * A very light and not 100% compatible storemanager in case you are not using xt-store.
+ * It can emulate XtStoreManager to some extends for doing some tests
+ */
+class StoreTestHelper {
+    /**
+     * Sets a TestStoreManager as the test store manager in StoreSupport.
+     * Call this in test setup to use the in-memory store provider.
+     */
+    static ensureTestProviderOnly() {
+        StoreSupport.setTestStoreManager(new TestStoreManager());
+    }
+}
+/**
+ * A test implementation of IStoreManager that always returns a single TestStoreProvider.
+ * Used to emulate xt-store for unit testing purposes.
+ */
+class TestStoreManager {
+    constructor() {
+        /** The default provider returned for all store operations. */
+        this.defaultProvider = new TestStoreProvider();
+    }
+    /**
+     * Returns the default test store provider.
+     * @param name - Ignored; always returns the same provider
+     * @returns The default TestStoreProvider
+     */
+    getProvider(name) {
+        return this.defaultProvider;
+    }
+    /**
+     * Returns the default test store provider (safe variant).
+     * @param name - Ignored; always returns the same provider
+     * @returns The default TestStoreProvider
+     */
+    getProviderSafe(name) {
+        return this.defaultProvider;
+    }
+    /**
+     * Returns the default test store provider.
+     * @returns The default TestStoreProvider or undefined
+     */
+    getDefaultProvider() {
+        return this.defaultProvider;
+    }
+    /**
+     * Returns the default test store provider (safe variant).
+     * @returns The default TestStoreProvider
+     */
+    getDefaultProviderSafe() {
+        return this.defaultProvider;
+    }
+    /**
+     * Creates a new TestStoreCriteria instance.
+     * @param name - The field name for the criteria
+     * @param value - The value to match
+     * @param operator - The comparison operator
+     * @returns A new TestStoreCriteria
+     */
+    newStoreCriteria(name, value, operator) {
+        return new TestStoreCriteria(name, value, operator);
+    }
+}
+/**
+ * A test implementation of IStoreProvider that stores entities in an in-memory map.
+ * Supports basic CRUD and filtering operations for unit testing.
+ */
+class TestStoreProvider {
+    constructor() {
+        /** In-memory data store, keyed by entity type name then by entity key. */
+        this.data = new Map();
+    }
+    /**
+     * Gets or creates a named entity map within the data store.
+     * @param name - The entity type name
+     * @returns The map of entities for the given type
+     */
+    getOrCreateArray(name) {
+        let ret = this.data.get(name);
+        if (ret == null) {
+            ret = new Map();
+            this.data.set(name, ret);
+        }
+        return ret;
+    }
+    /**
+     * Extracts a unique key from a value object, using _id, id, or generating a new one.
+     * @param value - The value to extract the key from
+     * @param create - Whether to generate a new key if none exists
+     * @returns The extracted or generated key string
+     */
+    extractKey(value, create) {
+        if (value._id != null)
+            return value._id; // ManagedData key
+        else if (value.id != null)
+            return value.id;
+        else {
+            if (create === true) {
+                const newId = Math.random().toString(36).substring(2, 8);
+                value._id = newId;
+                return newId;
+            }
+            return value.toString();
+        }
+    }
+    /**
+     * Stores an entity in the in-memory data store.
+     * @param name - The entity type name
+     * @param entity - The entity to store
+     * @returns A promise resolving to the stored entity
+     */
+    storeEntity(name, entity) {
+        this.getOrCreateArray(name).set(this.extractKey(entity, true), entity);
+        return Promise.resolve(entity);
+    }
+    /**
+     * Loads an entity by key, throwing if not found.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to the entity
+     */
+    safeLoadEntity(name, key) {
+        const ret = this.getOrCreateArray(name).get(key);
+        if (ret == null) {
+            throw new Error("No entity named " + name + " with key " + key);
+        }
+        return Promise.resolve(ret);
+    }
+    /**
+     * Loads an entity by key, returning undefined if not found.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to the entity or undefined
+     */
+    loadEntity(name, key) {
+        return Promise.resolve(this.getOrCreateArray(name).get(key));
+    }
+    /**
+     * Deletes an entity by key.
+     * @param name - The entity type name
+     * @param key - The entity key
+     * @returns A promise resolving to true if deleted, false otherwise
+     */
+    deleteEntity(name, key) {
+        return Promise.resolve(this.getOrCreateArray(name).delete(key));
+    }
+    /**
+     * Searches entities by optional criteria. Returns all entities if no criteria provided.
+     * @param name - The entity type name
+     * @param criteria - Optional filter criteria
+     * @returns An observable of matching entities
+     */
+    searchEntities(name, ...criteria) {
+        // No criteria defined, just send the full list
+        const ret = new Array();
+        if ((criteria == null) || (criteria.length == 0)) {
+            for (const toAdd of this.getOrCreateArray(name).values()) {
+                ret.push(toAdd);
+            }
+        }
+        else {
+            for (const toAdd of this.getOrCreateArray(name).values()) {
+                let canAdd = true;
+                for (const criter of criteria) {
+                    if (!criter.filter(toAdd)) {
+                        canAdd = false;
+                        break;
+                    }
+                }
+                if (canAdd)
+                    ret.push(toAdd);
+            }
+        }
+        return from([ret]);
+    }
+    /**
+     * Search and prepare entities with sorting, grouping, and transformation (not implemented).
+     */
+    searchAndPrepareEntities(name, sort, groupBy, transformer, ...criteria) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Indicates that this provider supports document storage.
+     * @returns True
+     */
+    canStoreDocument() {
+        return true;
+    }
+    /**
+     * Stores a document file and returns its document info.
+     * @param toStore - The file to store
+     * @returns A promise resolving to the document info
+     */
+    storeDocument(toStore) {
+        const ret = new TestDocumentInfo(toStore.name, true, URL.createObjectURL(toStore));
+        return Promise.resolve(ret);
+    }
+    /**
+     * Stores multiple document files (not implemented).
+     */
+    storeDocuments(toStore) {
+        throw new Error('Method not implemented.');
+    }
+}
+/**
+ * A test implementation of IDocumentInfo for testing document storage operations.
+ */
+class TestDocumentInfo {
+    /**
+     * Creates a new TestDocumentInfo instance.
+     * @param documentName - The document name
+     * @param isUrl - Whether the document is a URL
+     * @param documentId - Optional document identifier
+     */
+    constructor(documentName, isUrl, documentId) {
+        this.documentId = documentId;
+        this.documentName = documentName;
+        this.isUrl = isUrl;
+    }
+}
+/**
+ * A test implementation of IStoreCriteria that filters entities by field comparison.
+ */
+class TestStoreCriteria {
+    /**
+     * Creates a new TestStoreCriteria instance.
+     * @param name - The field name to filter on
+     * @param value - The value to compare against
+     * @param operator - The comparison operator (default '=')
+     */
+    constructor(name, value, operator) {
+        this.name = name;
+        this.value = value;
+        if (!operator)
+            this.operator = '=';
+        else {
+            this.operator = operator;
+        }
+    }
+    /**
+     * Filters an entity by comparing its field value against the criteria value.
+     * @param toFilter - The entity to test
+     * @returns True if the entity matches the criteria
+     */
+    filter(toFilter) {
+        const testValue = toFilter[this.name];
+        switch (this.operator) {
+            case '=':
+                return testValue == this.value;
+            case '<':
+                return testValue < this.value;
+            case '<=':
+                return testValue < this.value;
+            default:
+                return true;
+        }
+    }
+}
+
 /*
  * Public API Surface of xt-components
  */
@@ -1565,5 +2156,5 @@ function generateFormControl(formDescription) {
  * Generated bundle index. Do not edit.
  */
 
-export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, StoreSupport, StoreTestHelper, TestDocumentInfo, TestStoreCriteria, TestStoreManager, TestStoreProvider, XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN, XtBaseContext, XtCompositeComponent, XtMessageHandler, XtPluginRegistry, XtRenderComponent, XtRenderSubComponent, XtResolvedComponent, XtResolverService, XtSimpleComponent, XtUnitTestHelper, attachToFormGroup, initXtPluginRegistry, updateFormGroupWithValue, xtPluginRegistry };
+export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, ISortByDirection, StoreSupport, StoreTestHelper, TestDocumentInfo, TestStoreCriteria, TestStoreManager, TestStoreProvider, XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN, XtBaseContext, XtBaseInput, XtBaseModel, XtBaseOutput, XtCompositeComponent, XtMessageHandler, XtPluginRegistry, XtRenderComponent, XtRenderSubComponent, XtResolvedComponent, XtResolverService, XtSimpleComponent, XtUnitTestHelper, attachToFormGroup, initXtPluginRegistry, updateFormGroupWithValue, xtPluginRegistry };
 //# sourceMappingURL=xt-components.mjs.map