xt-components 0.4.1 → 0.4.4

package/fesm2022/xt-components.mjs

@@ -1,8 +1,10 @@
 import * as i0 from '@angular/core';
 import { computed, signal, InjectionToken, inject, Injectable, input, model, output, viewChild, Component } from '@angular/core';
-import * as i1 from '@angular/forms';
-import { FormControl, FormGroup, ReactiveFormsModule, FormBuilder, FormArray } from '@angular/forms';
+import { xtTypeManager, ManagedDataHandler, isPrimitive } from 'xt-type';
+import { loadRemoteModule } from '@angular-architects/native-federation';
 import { NgComponentOutlet, CommonModule } from '@angular/common';
+import * as i1 from '@angular/forms';
+import { ReactiveFormsModule, FormControl, FormGroup, FormBuilder, FormArray } from '@angular/forms';
 
 class XtBaseContext {
     /**
@@ -118,6 +120,18 @@ class XtBaseContext {
         //console.debug("formControlValue of "+this.subName+ " is ",ret);
         return ret;
     }
+    setFormValue(newValue) {
+        if (this.isInForm()) {
+            if (this.subName != null) {
+                const control = this.parentFormGroup?.get(this.subName);
+                if (control != null) {
+                    control.setValue(newValue);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
     /**
      * Returns the context associated with a specific element in a set.
      * Value must be an array.
@@ -165,7 +179,7 @@ class XtBaseContext {
                 ret.valueType = subType;
             }
             else if ((this.valueType != null) && (typeResolver != null)) {
-                ret.valueType = typeResolver.findType(this, subName, this.value()) ?? undefined;
+                ret.valueType = typeResolver.findTypeName(this.valueType, subName, this.value()) ?? undefined;
             }
             if (this.childContexts == null)
                 this.childContexts = new Map();
@@ -208,6 +222,7 @@ class XtPluginRegistry {
         this.componentRegistry = new Map();
         this.componentByTypeCache = new Map();
         this.listComponents = signal(new Array());
+        this.listPlugins = signal(new Array());
     }
     /**
      * The component can manage any standard javascript primitives types. That's usually the default whenever we don't know any particular type
@@ -238,6 +253,18 @@ class XtPluginRegistry {
             if (updated)
                 this.componentByTypeCache.clear(); // Force recalculation of type
         }
+        this.listPlugins.update((array) => {
+            let found = false;
+            for (let i = 0; i < array.length; i++) {
+                if (array[i].name == info.name) {
+                    found = true;
+                    array[i] = info;
+                }
+            }
+            if (!found)
+                array.push(info);
+            return [...array]; // You have to send another value, not just update the existing one.
+        });
     }
     registerComponent(info) {
         this.componentRegistry.set(info.componentName, info);
@@ -325,13 +352,28 @@ class XtPluginRegistry {
         return ret;
     }
 }
-const XT_REGISTRY = new XtPluginRegistry();
+
+/**
+ * The global plugin registry.
+ * Plugins will register to this when loaded.
+ */
+function initXtPluginRegistry() {
+    if (globalThis.XT_REGISTRY == null) {
+        globalThis.XT_REGISTRY = new XtPluginRegistry();
+    }
+}
+function xtPluginRegistry() {
+    if (globalThis.XT_REGISTRY == null) {
+        initXtPluginRegistry();
+    }
+    return globalThis.XT_REGISTRY;
+}
 
 const XT_RESOLVER_TOKEN = new InjectionToken('Enable providing a custom component resolver.');
 const XT_TYPE_RESOLVER_TOKEN = new InjectionToken('Enable providing a custom type resolver.');
 const XT_REGISTRY_TOKEN = new InjectionToken("Injects the Plugin Registry right into your angular component", {
     factory: () => {
-        return XT_REGISTRY;
+        return xtPluginRegistry();
     }
 });
 
@@ -341,7 +383,7 @@ class XtRegistryResolver {
         this.typeResolver = typeResolver;
     }
     resolve(baseContext, subName) {
-        const ret = this.registry.findComponentsForType(this.typeResolver.findType(baseContext, subName), baseContext.subValue(subName));
+        const ret = this.registry.findComponentsForType(this.typeResolver.findTypeName(baseContext.valueType, subName), baseContext.subValue(subName));
         if (ret != null && ret.length > 0) {
             return XtResolvedComponent.from(ret[0]);
         }
@@ -349,158 +391,6 @@ class XtRegistryResolver {
     }
 }
 
-class XtTypeHierarchyResolver {
-    constructor() {
-        this.types = new Map();
-    }
-    addType(typeName, type) {
-        this.types.set(typeName, fromDescription(type));
-    }
-    canUpdate() {
-        return true;
-    }
-    findType(typeInfo, subName, value) {
-        if (typeInfo == null)
-            return typeInfo;
-        if (typeInfo.valueType == null)
-            return typeInfo.valueType;
-        if (subName == null) {
-            return typeInfo.valueType;
-        }
-        else {
-            const selectedType = this.types.get(typeInfo.valueType);
-            if ((selectedType != null) && (selectedType.children != null)) {
-                const type = selectedType.children[subName].type;
-                if (type == null) {
-                    throw new Error('SubType named ' + subName + ' of ' + typeInfo.valueType + ' doesn\'t have a type name.');
-                }
-                else {
-                    return type;
-                }
-            }
-        }
-        return undefined;
-    }
-    listSubNames(context, value) {
-        let ret = [];
-        if ((context != null) && (context.valueType != null)) {
-            const typeInfo = this.types.get(context.valueType);
-            if (typeInfo?.children != null) {
-                ret = Object.keys(typeInfo.children);
-            }
-        }
-        if (ret.length == 0) {
-            // We will use the value to extract properties
-            if (value != null) {
-                if (Array.isArray(value)) {
-                    if (value.length > 0) {
-                        const setOfKeys = new Set();
-                        for (const element of value) {
-                            const elementKeys = Object.keys(element);
-                            for (const key of elementKeys) {
-                                setOfKeys.add(key);
-                            }
-                        }
-                        ret = Array.from(setOfKeys.values());
-                    }
-                }
-                else {
-                    ret = Object.keys(value);
-                }
-            }
-        }
-        return ret;
-    }
-}
-class XtBaseTypeHierarchy {
-    constructor(type, parent) {
-        this.type = type;
-        this.parent = parent;
-    }
-    addChild(key, child) {
-        if (this.children == null)
-            this.children = {};
-        this.children[key] = child;
-    }
-}
-function fromDescription(typeHierarchy, name, parent) {
-    let ret = null;
-    if (typeof typeHierarchy == 'string') {
-        ret = new XtBaseTypeHierarchy(typeHierarchy, parent);
-    }
-    else {
-        ret = new XtBaseTypeHierarchy(undefined, parent);
-        for (const key of Object.keys(typeHierarchy)) {
-            const value = typeHierarchy[key];
-            fromDescription(value, key, ret);
-        }
-    }
-    if ((parent != null) && (name != null))
-        parent.addChild(name, ret);
-    else if ((parent != null) && (name == null)) {
-        throw new Error("Cannot add type to parent without a name.");
-    }
-    return ret;
-}
-function updateFormGroupWithValue(formGroup, value) {
-    const toDelete = new Set(Object.keys(formGroup.controls));
-    for (const valueKey in value) {
-        const primitive = isPrimitive(value[valueKey]);
-        if (toDelete.delete(valueKey)) {
-            // Already a control
-            const oldControl = formGroup.get(valueKey);
-            // Is it the right type ?
-            if (primitive) {
-                // Must be an FormControl2
-                if (oldControl.controls === undefined) {
-                    // It's ok, just set the value
-                    oldControl.setValue(value[valueKey]);
-                }
-                else {
-                    formGroup.setControl(valueKey, new FormControl(value[valueKey]));
-                }
-            }
-            else {
-                // Must be a FormGroup
-                if (oldControl.controls === undefined) {
-                    const newFormGroup = new FormGroup({});
-                    formGroup.setControl(valueKey, newFormGroup);
-                    updateFormGroupWithValue(newFormGroup, value[valueKey]);
-                }
-                else {
-                    // It was already a formgroup, so just update it
-                    updateFormGroupWithValue(oldControl, value[valueKey]);
-                }
-            }
-        }
-        else {
-            if (primitive) {
-                formGroup.addControl(valueKey, new FormControl(value[valueKey]));
-            }
-            else {
-                const newFormGroup = new FormGroup({});
-                formGroup.addControl(valueKey, newFormGroup);
-                updateFormGroupWithValue(newFormGroup, value[valueKey]);
-            }
-        }
-    }
-    // Delete controls that are no more used
-    for (const delName of toDelete) {
-        formGroup.removeControl(delName);
-    }
-}
-function isPrimitive(valueElement) {
-    if (typeof valueElement == 'object') {
-        if (valueElement == null)
-            return true;
-        else {
-            return valueElement instanceof Date;
-        }
-    }
-    else
-        return true;
-}
-
 class XtResolverService {
     constructor() {
         this.pluginRegistry = inject(XT_REGISTRY_TOKEN);
@@ -509,8 +399,11 @@ class XtResolverService {
         this.listComponents = computed(() => {
             return this.pluginRegistry.listComponents();
         });
+        this.listPlugins = computed(() => {
+            return this.pluginRegistry.listPlugins();
+        });
         if (this.baseTypeResolver == null) {
-            this.typeResolver = new XtTypeHierarchyResolver();
+            this.typeResolver = xtTypeManager();
         }
         else
             this.typeResolver = this.baseTypeResolver;
@@ -528,23 +421,39 @@ class XtResolverService {
             throw new Error("No components found for this context " + baseContext.toString());
     }
     findTypeOf(baseContext, subName, value) {
-        const ret = this.typeResolver.findType(baseContext, subName, value);
+        const ret = this.typeResolver.findTypeName(baseContext.valueType, subName, value);
+        return ret;
+    }
+    findTypeHandlerOf(baseContext, subName, value) {
+        const ret = this.typeResolver.findTypeHandler(baseContext.valueType, subName, value);
         return ret;
     }
     listSubNamesOf(baseContext, value) {
-        return this.typeResolver.listSubNames(baseContext, value);
+        return this.typeResolver.listSubNames(baseContext.valueType, value);
     }
     registerPlugin(info) {
         this.pluginRegistry.registerPlugin(info);
-        this.registerTypes(info.types);
+        this.registerTypes(info.types, info.typeHandlers);
     }
-    registerTypes(types) {
+    registerTypes(types, handlers) {
         if ((types != null) && (this.typeResolver.canUpdate())) {
             for (const newType in types) {
-                this.typeResolver.addType(newType, types[newType]);
+                let handler = this.handlerDefinedFor(newType, handlers);
+                if (handler == null) {
+                    handler = new ManagedDataHandler();
+                }
+                this.typeResolver.addRootType(newType, types[newType], handler);
             }
         }
     }
+    handlerDefinedFor(newType, handlers) {
+        for (const handler of handlers ?? []) {
+            if (handler.typesHandled.includes(newType)) {
+                return new handler.handlerClass();
+            }
+        }
+        return null;
+    }
     getComponentInfo(type) {
         return XtResolvedComponent.from(this.pluginRegistry.getComponentInfo(type));
     }
@@ -555,16 +464,34 @@ class XtResolverService {
         else
             return XtResolvedComponent.from(ret);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtResolverService, providedIn: 'root' }); }
+    /**
+     * 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.
+     */
+    loadPlugin(url) {
+        return loadRemoteModule({
+            remoteEntry: url.toString(),
+            exposedModule: './Register'
+        }).then((module) => {
+            module.registerPlugin(this);
+            return module;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtResolverService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtResolverService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtResolverService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: () => [] });
 
+class XtBaseOutput {
+}
+
 /**
  * Offers a nice and easy to dynamically embed a component.
  * You set the type, the display mode, and either the value or the formgroup & subName to use.
@@ -581,8 +508,9 @@ class XtRenderComponent {
         // Or we are inside a Form
         this.formGroup = input();
         this.subName = input();
+        this.outputsObject = new XtBaseOutput();
+        this.inputs = input();
         this.outputs = output();
-        this.hasOutputs = false;
         this.outlet = viewChild.required(NgComponentOutlet);
         this.context = computed(() => {
             let form = this.formGroup();
@@ -615,17 +543,32 @@ class XtRenderComponent {
             return type ?? null;
         });
     }
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
     ngAfterViewInit() {
         const instance = this.outlet().componentInstance;
-        if ((instance != null) && (instance.hasOutputs) && (instance.outputs != null)) {
-            instance.outputs.subscribe((out) => this.outputs.emit(out));
-            this.hasOutputs = true;
+        if (instance?.outputsObject != null) {
+            let hasOneOutput = false;
+            for (const key of Object.keys(instance.outputsObject)) {
+                this.outputsObject[key] = instance.outputsObject[key];
+                hasOneOutput = true;
+            }
+            if (hasOneOutput) {
+                this.outputs.emit(this.outputsObject);
+            }
+        }
+        const inputs = this.inputs();
+        if ((inputs != null) && (instance?.inputsObject != null)) {
+            for (const key of Object.keys(inputs)) {
+                instance.inputsObject[key] = inputs[key];
+            }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtRenderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.2.4", 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 } }, 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", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtRenderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.2.10", 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", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtRenderComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtRenderComponent, decorators: [{
             type: Component,
             args: [{ selector: 'xt-render', standalone: true, imports: [
                         NgComponentOutlet,
@@ -641,8 +584,9 @@ class XtRenderSubComponent {
     constructor() {
         this.context = input.required();
         this.componentType = input();
+        this.outputsObject = new XtBaseOutput();
+        this.inputs = input();
         this.outputs = output();
-        this.hasOutputs = false;
         this.outlet = viewChild.required(NgComponentOutlet);
         this.resolverService = inject(XtResolverService);
         this.type = computed(() => {
@@ -660,17 +604,32 @@ class XtRenderSubComponent {
             return type ?? null;
         });
     }
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
     ngAfterViewInit() {
         const instance = this.outlet().componentInstance;
-        if ((instance != null) && (instance.hasOutputs) && (instance.outputs != null)) {
-            instance.outputs.subscribe((out) => this.outputs.emit(out));
-            this.hasOutputs = true;
+        if (instance?.outputsObject != null) {
+            let hasOneOutput = false;
+            for (const key of Object.keys(instance.outputsObject)) {
+                this.outputsObject[key] = instance.outputsObject[key];
+                hasOneOutput = true;
+            }
+            if (hasOneOutput) {
+                this.outputs.emit(this.outputsObject);
+            }
+        }
+        const inputs = this.inputs();
+        if ((inputs != null) && (instance?.inputsObject != null)) {
+            for (const key of Object.keys(inputs)) {
+                instance.inputsObject[key] = inputs[key];
+            }
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtRenderSubComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.2.4", 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 } }, 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:context ()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtRenderSubComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "19.2.10", 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:context ()}\" />\n", styles: [""], dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: ReactiveFormsModule }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtRenderSubComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtRenderSubComponent, decorators: [{
             type: Component,
             args: [{ selector: 'xt-render-sub', standalone: true, imports: [
                         NgComponentOutlet,
@@ -678,18 +637,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImpor
                     ], template: "{{componentType()}}\n<ng-container *ngComponentOutlet=\"type(); inputs: {context:context ()}\" />\n" }]
         }] });
 
-class XtBaseOutput {
-    setNewOutput(name, value) {
-        let ret = false;
-        if (this[name] == null) {
-            this[name] = signal(value);
-            ret = true;
-        }
-        else {
-            this[name].set(value);
-        }
-        return ret;
-    }
+class XtBaseInput {
 }
 
 /**
@@ -699,12 +647,9 @@ class XtBaseOutput {
 class XtSimpleComponent {
     constructor() {
         this.context = input.required();
+        this.outputsObject = new XtBaseOutput();
+        this.inputsObject = new XtBaseInput();
         this.outputs = output();
-        /**
-         * Does the component provides Output or not ?
-         * @protected
-         */
-        this.hasOutputs = false;
         this.isInForm = computed(() => {
             return this.context()?.isInForm() ?? false;
         });
@@ -753,10 +698,12 @@ class XtSimpleComponent {
         this.displayValue = computed(() => {
             return this.context().displayValue();
         });
-        if (this.hasOutputs) {
-            if (this.outputElement == null) {
-                this.outputElement = new XtBaseOutput();
-            }
+    }
+    ngOnInit() {
+        this.setupInputOutput();
+        if (Object.keys(this.outputsObject).length > 0) {
+            // At least one output has been defined
+            this.outputs.emit(this.outputsObject);
         }
     }
     manageFormControl(ctrlName) {
@@ -778,24 +725,17 @@ class XtSimpleComponent {
     componentDescriptor() {
         return "Component with type " + this.constructor.name + " with context " + this.context().toString();
     }
-    emitOutput(outputName, newValue) {
-        if (!this.hasOutputs) {
-            throw new Error("Component without outputs cannot emit output");
-        }
-        let newOutput = false;
-        if (this.outputElement == null) {
-            this.outputElement = new XtBaseOutput();
-            newOutput = true;
-        }
-        newOutput = this.outputElement.setNewOutput(outputName, newValue) || newOutput;
-        if (newOutput) {
-            this.outputs?.emit(this.outputElement);
-        }
+    /**
+     * This is where components can assign their output() and input() into the XtComponent inputs and outputs member
+     * @protected
+     */
+    setupInputOutput() {
+        // Nothing to do here
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.4", 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: "19.2.10", ngImport: i0, type: XtSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.10", 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 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtSimpleComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtSimpleComponent, decorators: [{
             type: Component,
             args: [{
                     standalone: true,
@@ -844,14 +784,93 @@ class XtCompositeComponent extends XtSimpleComponent {
         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: "19.2.4", ngImport: i0, type: XtCompositeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.4", 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: "19.2.10", ngImport: i0, type: XtCompositeComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.10", type: XtCompositeComponent, isStandalone: true, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [""] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: XtCompositeComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: XtCompositeComponent, decorators: [{
             type: Component,
             args: [{ standalone: true, imports: [], template: '' }]
         }] });
 
+class MessageHandler {
+    errorOccurred(error, errorMsg) {
+        console.error(errorMsg, error);
+    }
+    warningOccurred(warningMsg) {
+        console.warn(warningMsg);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: MessageHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: MessageHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: MessageHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class StoreSupport {
+    static isStoreManagerAvailable() {
+        if (this.testStoreManager != null)
+            return true;
+        return (globalThis.xtStoreManager != undefined);
+    }
+    static getStoreManager() {
+        return this.testStoreManager ?? (globalThis.xtStoreManager());
+    }
+    static setTestStoreManager(testStoreManager) {
+        StoreSupport.testStoreManager = testStoreManager;
+    }
+}
+
+function updateFormGroupWithValue(formGroup, value) {
+    const toDelete = new Set(Object.keys(formGroup.controls));
+    for (const valueKey in value) {
+        const primitive = isPrimitive(value[valueKey]);
+        if (toDelete.delete(valueKey)) {
+            // Already a control
+            const oldControl = formGroup.get(valueKey);
+            // Is it the right type ?
+            if (primitive) {
+                // Must be an FormControl2
+                if (oldControl.controls === undefined) {
+                    // It's ok, just set the value
+                    oldControl.setValue(value[valueKey]);
+                }
+                else {
+                    formGroup.setControl(valueKey, new FormControl(value[valueKey]));
+                }
+            }
+            else {
+                // Must be a FormGroup
+                if (oldControl.controls === undefined) {
+                    const newFormGroup = new FormGroup({});
+                    formGroup.setControl(valueKey, newFormGroup);
+                    updateFormGroupWithValue(newFormGroup, value[valueKey]);
+                }
+                else {
+                    // It was already a formgroup, so just update it
+                    updateFormGroupWithValue(oldControl, value[valueKey]);
+                }
+            }
+        }
+        else {
+            if (primitive) {
+                formGroup.addControl(valueKey, new FormControl(value[valueKey]));
+            }
+            else {
+                const newFormGroup = new FormGroup({});
+                formGroup.addControl(valueKey, newFormGroup);
+                updateFormGroupWithValue(newFormGroup, value[valueKey]);
+            }
+        }
+    }
+    // Delete controls that are no more used
+    for (const delName of toDelete) {
+        formGroup.removeControl(delName);
+    }
+}
+
 class XtUnitTestHelper {
 }
 
@@ -865,10 +884,10 @@ class HostTestSimpleComponent {
         this.displayMode = input('FULL_VIEW');
         this.value = input(undefined);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.4", 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"], outputs: ["valueChange", "outputs"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestSimpleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.10", 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"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestSimpleComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestSimpleComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-host',
@@ -914,10 +933,10 @@ class HostTestFormComponent {
         else
             throw new Error("FormGroup not yet created. Did you set formGroup or formDescription property ?");
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.4", 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"], 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: "19.2.10", ngImport: i0, type: HostTestFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.10", 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"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestFormComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestFormComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-form-host',
@@ -942,10 +961,10 @@ class HostTestTypedComponent {
             return ret;
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestTypedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.4", 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"], outputs: ["outputs"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestTypedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.10", 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"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestTypedComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestTypedComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-typed-host',
@@ -1002,10 +1021,10 @@ class HostTestTypedFormComponent {
     retrieveValue(controlName) {
         return this.computedFormGroup().value[controlName];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestTypedFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.4", 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"], outputs: ["outputs"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestTypedFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "19.2.10", 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"] }] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HostTestTypedFormComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: HostTestTypedFormComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'test-typed-form-host',
@@ -1041,6 +1060,94 @@ 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 {
+    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;
+    }
+}
+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) {
+        if (value.__id != null)
+            return value.__id;
+        else if (value.id != null)
+            return value.id;
+        else
+            return value.toString();
+    }
+    storeEntity(name, entity) {
+        this.getOrCreateArray(name).set(this.extractKey(entity), 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) {
+        throw new Error('Method not implemented.');
+    }
+    searchAndPrepareEntities(name, sort, groupBy, transformer, ...criteria) {
+        throw new Error('Method not implemented.');
+    }
+    canStoreDocument() {
+        return true;
+    }
+    storeDocument(toStore) {
+        const ret = new TestDocumentInfo(URL.createObjectURL(toStore), true);
+        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;
+    }
+}
+
 /*
  * Public API Surface of xt-components
  */
@@ -1049,5 +1156,5 @@ function generateFormControl(formDescription) {
  * Generated bundle index. Do not edit.
  */
 
-export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, XT_REGISTRY, XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN, XtBaseContext, XtBaseTypeHierarchy, XtCompositeComponent, XtPluginRegistry, XtRenderComponent, XtRenderSubComponent, XtResolvedComponent, XtResolverService, XtSimpleComponent, XtTypeHierarchyResolver, XtUnitTestHelper, fromDescription, updateFormGroupWithValue };
+export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, MessageHandler, StoreSupport, StoreTestHelper, TestDocumentInfo, TestStoreManager, TestStoreProvider, XT_REGISTRY_TOKEN, XT_RESOLVER_TOKEN, XT_TYPE_RESOLVER_TOKEN, XtBaseContext, XtCompositeComponent, XtPluginRegistry, XtRenderComponent, XtRenderSubComponent, XtResolvedComponent, XtResolverService, XtSimpleComponent, XtUnitTestHelper, initXtPluginRegistry, updateFormGroupWithValue, xtPluginRegistry };
 //# sourceMappingURL=xt-components.mjs.map