xt-components 0.4.8 → 0.5.5

package/index.d.ts

@@ -1,5 +1,592 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, InputSignal, OutputEmitterRef, Type, InjectionToken, AfterViewInit, OnInit } from '@angular/core';
+import { FormGroup, AbstractControl, FormBuilder } from '@angular/forms';
+import { XtTypeInfo, XtTypeResolver, XtTypeHandler, MappingHelper } from 'xt-type';
+import * as xt_components from 'xt-components';
+import { NgComponentOutlet } from '@angular/common';
+import { Observable } from 'rxjs';
+
+type XtComponentInfo<T> = {
+    componentName: string;
+    componentClass: T;
+    typesHandled: string[];
+    outputs?: XtOutputType[];
+};
+type XtTypeHandlerInfo<T> = {
+    typesHandled: string[];
+    handlerClass: T;
+};
+type XtActionInfo<T> = {
+    description: string;
+    visible: boolean;
+    handlerClass: any;
+    iconUrl?: string;
+};
+type XtActionHandlerInfo<T> = {
+    types: string[];
+    actions: {
+        [name: string]: XtActionInfo<T>;
+    };
+};
+type XtPluginInfo = {
+    name: string;
+    uriLogo?: string;
+    components?: XtComponentInfo<any>[];
+    types?: XtTypeInfo;
+    typeHandlers?: XtTypeHandlerInfo<any>[];
+    actionHandlers?: XtActionHandlerInfo<any>[];
+};
+
+declare class XtAction<T> {
+    name: string;
+    info: XtActionInfo<T>;
+    enabled: _angular_core.WritableSignal<boolean>;
+    constructor(name: string, info: XtActionInfo<T>, enabled?: boolean);
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * A XtContext provides all the necessary information for an ng-extended component to operate. It is passed from parent to child component and pass
+ * - The display mode - View, Inline view or Edit
+ * - The value, either directly as a signal or in a formgroup when editing.
+ * - The valueType, necessary to find the right ng-extended component to display
+ *
+ * To do this, it maintains a hierarchy of context and subContexts by name.
  */
-/// <amd-module name="xt-components" />
-export * from './public-api';
+type XtContext<T> = {
+    displayMode: XtDisplayMode;
+    subName?: string;
+    parentFormGroup?: FormGroup;
+    localFormGroup?: FormGroup;
+    parentContext?: XtContext<any>;
+    isInForm(): boolean;
+    formGroup(): FormGroup | undefined;
+    formControlNameOrNull(): string | null;
+    formControlValue(): any | null;
+    subValue(subName?: string): T | null | undefined;
+    subContext(subName: string | undefined | null, subType?: string, typeResolver?: XtTypeResolver | null): XtContext<any>;
+    elementSetContext(subElement: any): XtContext<any>;
+    displayValue: Signal<T | null>;
+    setDisplayValue(newValue: T | null | undefined, type?: string): XtContext<T>;
+    setFormValue(newValue: T | null | undefined, markAsDirty?: boolean): boolean;
+    value(): T | null | undefined;
+    valueType?: string;
+    toString(): string;
+    listActions: WritableSignal<XtAction<T>[] | null>;
+};
+type XtDisplayMode = 'INLINE_VIEW' | 'FULL_VIEW' | 'FULL_EDITABLE' | 'LIST_VIEW';
+declare class XtBaseContext<T> implements XtContext<T> {
+    displayMode: XtDisplayMode;
+    /**
+     * When editable, the value is stored in a parent formGroup
+     */
+    subName?: string;
+    parentFormGroup?: FormGroup<any>;
+    /**
+     * When the context is a child, it potentially needs to update its parent value
+     */
+    parentContext?: XtBaseContext<any>;
+    /**
+     * All child contexts are kept in this map
+     */
+    protected childContexts?: Map<string, XtBaseContext<any>>;
+    /**
+     * localFormGroup exists only for composite components: it's children are all gathered in a form group
+     */
+    localFormGroup?: FormGroup<any>;
+    /**
+     * When not managed by a form, the value is here
+     */
+    nonFormValue?: WritableSignal<T | null>;
+    valueType?: string;
+    /**
+     * Keeps track of all the possible actions for this context
+     * @protected
+     */
+    listActions: WritableSignal<XtAction<T>[] | null>;
+    /**
+     *
+     * @param displayMode
+     * @param readOnly
+     * @param parentGroup
+     * @param controlName
+     */
+    constructor(displayMode: XtDisplayMode, subName?: string, parentGroup?: FormGroup, parentContext?: XtBaseContext<any>);
+    setDisplayValue(newValue: T | null | undefined, type?: string, updateParent?: boolean): XtBaseContext<T>;
+    displayValue: Signal<T | null>;
+    isInForm(): boolean;
+    formControlNameOrNull(): string | null;
+    value(): T | null | undefined;
+    subValue(subsubName?: string): any | null | undefined;
+    /**
+     * Enable child contexts to update its own value in the parent context whenever it's value changes
+     */
+    protected updateSubDisplayValue(subName: string, subValue: any): void;
+    formControlValue(): T | null | undefined;
+    setFormValue(newValue: T | null | undefined, markAsDirty?: boolean): boolean;
+    /**
+     * Returns the context associated with a specific element in a set.
+     * Value must be an array.
+     * @param elementIndex
+     */
+    elementSetContext(elementIndex: number): XtContext<any>;
+    subContext(subName: string | undefined | null, subType?: string, typeResolver?: XtTypeResolver | null): XtContext<any>;
+    formGroup(): FormGroup | undefined;
+    toString(): string;
+}
+
+type XtComponent<T = any> = {
+    context: InputSignal<XtContext<T>>;
+    inputsObject?: XtComponentInput;
+    outputsObject?: XtComponentOutput;
+    inputs?: InputSignal<XtComponentInput>;
+    outputs?: OutputEmitterRef<XtComponentOutput>;
+    isInForm(): boolean;
+    formControlName(): string | undefined;
+    formGroup(): FormGroup;
+    formGroupIfAny(): FormGroup | undefined;
+};
+type XtOutputType = 'valueSelected';
+type XtInputType = 'valueSelected';
+type XtComponentOutput = {
+    [key in XtOutputType]: OutputEmitterRef<any> | undefined;
+};
+type XtComponentInput = {
+    [key in XtInputType]: InputSignal<any> | undefined;
+};
+
+declare class XtResolvedComponent {
+    componentName: string;
+    componentClass: any;
+    outputs: boolean;
+    constructor(componantName: string, componentClass: any, outputs?: boolean);
+    static from(info: XtComponentInfo<any>): XtResolvedComponent;
+}
+
+type XtResolver = {
+    resolve<T>(baseContext: XtContext<T>, subName?: string): XtResolvedComponent | null;
+};
+
+declare class XtPluginRegistry {
+    pluginRegistry: Map<string, XtPluginInfo>;
+    componentRegistry: Map<string, XtComponentInfo<any>>;
+    componentByTypeCache: Map<string, XtComponentInfo<any>[]>;
+    protected actionByTypeRegistry: Map<string, Map<string, XtActionInfo<any>>>;
+    listComponents: _angular_core.WritableSignal<XtComponentInfo<any>[]>;
+    listPlugins: _angular_core.WritableSignal<XtPluginInfo[]>;
+    /**
+     * The component can manage any standard javascript primitives types. That's usually the default whenever we don't know any particular type
+     * string
+     * number
+     * bigint
+     * boolean
+     * undefined
+     * null
+     * symbol is not managed
+     * Date, while an object and not a primitive, is managed
+     */
+    static readonly ANY_PRIMITIVE_TYPE = "ANY_PRIMITIVE_TYPE";
+    /**
+     * 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 readonly ANY_OBJECT_TYPE = "ANY_OBJECT_TYPE";
+    static readonly ANY_PRIMITIVE_SET = "ANY_PRIMITIVE_SET";
+    static readonly ANY_OBJECT_SET = "ANY_OBJECT_SET";
+    registerPlugin(info: XtPluginInfo): void;
+    registerComponent<T>(info: XtComponentInfo<T>): void;
+    findComponentsForType<T>(valueType: string | null | undefined, value?: T): XtComponentInfo<any>[];
+    static registry(): XtPluginRegistry;
+    findComponentInfo(type: Type<XtComponent<any>>): XtComponentInfo<any> | null;
+    getComponentInfo(type: Type<XtComponent<any>>): XtComponentInfo<any>;
+    registerActionHandler<T>(handlerInfo: XtActionHandlerInfo<T>): void;
+    findActionInfo<T>(type: string, actionName: string): XtActionInfo<T> | undefined;
+    listActionInfos<T>(type: string): {
+        name: string;
+        info: XtActionInfo<T>;
+    }[];
+}
+
+/**
+ * An all in one helper class, enabling manipulation of the context, with data and type associated with it.
+ */
+declare class XtResolverService {
+    pluginRegistry: xt_components.XtPluginRegistry;
+    protected baseResolver: XtResolver | null;
+    protected baseTypeResolver: XtTypeResolver | null;
+    resolver: XtResolver;
+    typeResolver: XtTypeResolver;
+    constructor();
+    findBestComponent<T>(baseContext: XtContext<T>, subName?: string): XtResolvedComponent;
+    findTypeOf<T>(baseContext: XtContext<T>, subName?: string, value?: T): string | null | undefined;
+    findTypeHandlerOf<T>(baseContext: XtContext<T>, subName?: string, value?: T): {
+        typeName?: string | null;
+        handler?: XtTypeHandler<any>;
+    };
+    listSubNamesOf<T>(baseContext: XtContext<T>, value?: T): string[];
+    listSubNamesOfType<T>(valueType: string, value?: T): string[];
+    registerPlugin(info: XtPluginInfo): void;
+    registerTypes(types: XtTypeInfo | undefined, handlers?: XtTypeHandlerInfo<any>[]): void;
+    /**
+     * Calculates all the possible actions for a given context
+     * @param context
+     * @param onlyVisible
+     */
+    possibleActions<T>(context: XtContext<T>, onlyVisible?: boolean): Array<XtAction<T>>;
+    /**
+     * Finds the possible action with the given name for the current type, and runs it in the current value.
+     * If the action is not possible in this context, try a parent context
+     * @param actionName
+     */
+    runAction<T>(context: XtContext<T>, actionName: string, storeMgr?: any): Promise<XtActionResult<any>>;
+    protected handlerDefinedFor(newType: string, handlers: XtTypeHandlerInfo<any>[] | undefined): any;
+    getComponentInfo<T>(type: Type<XtComponent<T>>): XtResolvedComponent;
+    findComponentInfo<T>(type: Type<XtComponent<T>>): XtResolvedComponent | null;
+    listComponents: _angular_core.Signal<XtComponentInfo<any>[]>;
+    listPlugins: _angular_core.Signal<XtPluginInfo[]>;
+    /**
+     * 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: URL | string): Promise<any>;
+    /**
+     * Based on the type & value of the element, find which property is on its type and returns it's value
+     * @param context
+     * @param subPropertyType
+     * @param value
+     */
+    findSubPropertyWithType<T>(context: XtContext<T>, subPropertyType: string, value: T): any;
+    /**
+     * Creates a duplicate of an object, using our knowledge on its type given by the context
+     * @param context
+     * @param value
+     */
+    safeDuplicate<T>(context: XtContext<T>, value: T): T;
+    resolveMappingOf<U, T>(context: XtContext<T>, targetType: string, value?: T): MappingHelper<U, T> | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtResolverService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XtResolverService>;
+}
+
+type XtActionResult<Type> = {
+    status: 'success' | 'error' | 'none';
+    warnings?: string[];
+    errors?: string[];
+    value?: Type | null;
+};
+type XtActionHandler<Type> = {
+    /**
+     * Runs an action on a item under the context
+     * @param context
+     * @param actionName
+     * @param store
+     */
+    runAction(context: XtContext<Type>, actionName: string, resolver: XtResolverService, storeMgr?: any): Promise<XtActionResult<Type>>;
+};
+
+/**
+ * The global plugin registry.
+ * Plugins will register to this when loaded.
+ */
+
+declare global {
+    var XT_REGISTRY: XtPluginRegistry;
+}
+declare function initXtPluginRegistry(): void;
+declare function xtPluginRegistry(): XtPluginRegistry;
+
+declare const XT_RESOLVER_TOKEN: InjectionToken<XtResolver>;
+declare const XT_TYPE_RESOLVER_TOKEN: InjectionToken<XtTypeResolver>;
+declare const XT_REGISTRY_TOKEN: InjectionToken<XtPluginRegistry>;
+
+declare class XtBaseOutput implements XtComponentOutput {
+    valueSelected: OutputEmitterRef<any> | undefined;
+}
+
+declare class XtBaseInput implements XtComponentInput {
+    valueSelected: InputSignal<any> | undefined;
+}
+
+/**
+ * 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.
+ * XtRender will then instantiate the component, bind it to the value or form, and display it.
+ */
+declare class XtRenderComponent<T> implements AfterViewInit {
+    resolverService: XtResolverService;
+    componentType: _angular_core.InputSignal<Type<XtComponent<T>> | undefined>;
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    valueType: _angular_core.InputSignal<string | undefined>;
+    value: _angular_core.ModelSignal<T | undefined>;
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    subName: _angular_core.InputSignal<string | undefined>;
+    outputsObject: XtBaseOutput;
+    inputs: _angular_core.InputSignal<XtBaseInput | undefined>;
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    outlet: Signal<NgComponentOutlet<any>>;
+    constructor();
+    context: Signal<XtContext<any>>;
+    type: Signal<Type<XtComponent<T>> | null>;
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtRenderComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtRenderComponent<any>, "xt-render", never, { "componentType": { "alias": "componentType"; "required": false; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": true; "isSignal": true; }; "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "subName": { "alias": "subName"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "outputs": "outputs"; }, never, never, true, never>;
+}
+
+/**
+ * Dynamically render a component that will display the given subValue.
+ * To be used only inside an XtSimpleComponent or XtCompositeComponent
+ */
+declare class XtRenderSubComponent<T> implements AfterViewInit {
+    context: _angular_core.InputSignal<XtContext<T>>;
+    componentType: _angular_core.InputSignal<Type<XtComponent<T>> | undefined>;
+    outputsObject: XtBaseOutput;
+    inputs: _angular_core.InputSignal<XtBaseInput | undefined>;
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    outlet: Signal<NgComponentOutlet<any>>;
+    resolverService: XtResolverService;
+    type: Signal<Type<XtComponent<T>> | null>;
+    /**
+     * Transfers the input and outputs from the host to the rendered component
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtRenderSubComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtRenderSubComponent<any>, "xt-render-sub", never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; "componentType": { "alias": "componentType"; "required": false; "isSignal": true; }; "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+
+/**
+ * An XtSimpleComponent just displays the given value or element in a form.
+ * If you need to dynamically embed other XtComponents to display sub elements, then please use the XtCompositeComponent
+ */
+declare class XtSimpleComponent<T = any> implements XtComponent<T>, OnInit {
+    context: _angular_core.InputSignal<XtContext<T>>;
+    outputsObject: XtBaseOutput;
+    inputsObject: XtBaseInput;
+    outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
+    isInForm: _angular_core.Signal<boolean>;
+    formControlNameIfAny: _angular_core.Signal<string | undefined>;
+    formGroupIfAny: _angular_core.Signal<FormGroup<any> | undefined>;
+    formGroup: _angular_core.Signal<FormGroup<any>>;
+    /**
+     * Returns the component form name, which is for now the subName
+     */
+    componentNameInForm: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    manageFormControl<T>(ctrlName: string, create?: boolean): AbstractControl<T> | undefined;
+    safelyGetSubName: _angular_core.Signal<string>;
+    /**
+     * Returns the form control name and create a form control behind the scene
+     */
+    formControlName: _angular_core.Signal<string>;
+    formControl: _angular_core.Signal<AbstractControl<any, any, any>>;
+    componentDescriptor(): string;
+    getValue: _angular_core.Signal<T | null | undefined>;
+    displayValue: _angular_core.Signal<T | null>;
+    /**
+     * This is where components can assign their output() and input() into the XtComponent inputs and outputs member
+     * @protected
+     */
+    protected setupInputOutput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtSimpleComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtSimpleComponent<any>, "ng-component", never, { "context": { "alias": "context"; "required": true; "isSignal": true; }; }, { "outputs": "outputs"; }, never, never, true, never>;
+}
+
+declare class XtCompositeComponent<T = any> extends XtSimpleComponent<T> {
+    resolverService: XtResolverService;
+    formGroupIfAny: _angular_core.Signal<FormGroup<any> | undefined>;
+    /**
+     * We need to create a new form group to manage the sub elements.
+     */
+    formGroup: _angular_core.Signal<FormGroup<any>>;
+    /**
+     * Helper function to calculate the sub context
+     * @param subName
+     * @param subType
+     */
+    subContext(subName: string, subType?: string): XtContext<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtCompositeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtCompositeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare class XtMessageHandler {
+    errorOccurred(error: any, errorMsg?: string): void;
+    warningOccurred(warningMsg?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtMessageHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XtMessageHandler>;
+}
+
+/**
+ * Wrapper around xt-store manager: You can use it to check if xt-store is included or not, and decide what to do
+ *
+ * This allow plugins to potentially use xt-store whenever included in the applications running the plugin
+ */
+
+declare class StoreSupport {
+    protected static testStoreManager?: IStoreManager;
+    static isStoreManagerAvailable(): boolean;
+    static getStoreManager(): IStoreManager;
+    static setTestStoreManager(testStoreManager: IStoreManager): void;
+}
+/**
+ * Interface definition for xt-store component.
+ * We re-define them here to avoid importing xt-store in all plugins that don't need it.
+ */
+interface IDataTransformer<T> {
+    /**
+     * Enable transformation of data right after it has been loaded from the store
+     * @param source
+     */
+    postLoadingTransformation(source: any[]): T[];
+}
+interface IDocumentInfo {
+    documentName: string;
+    isUrl: boolean;
+    documentId?: string;
+}
+interface IStoreProvider<T> {
+    storeEntity(name: string, entity: T): Promise<T>;
+    /**
+     * Rejects the promise if the entity is not found
+     * @param name
+     * @param key
+     */
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    searchEntities(name: string, ...criteria: any[]): Observable<Array<T>>;
+    searchAndPrepareEntities(name: string, sort?: any, groupBy?: any, transformer?: IDataTransformer<T>, ...criteria: any[]): Observable<any>;
+    canStoreDocument(): boolean;
+    /**
+     * Upload one document to a server store and returns the url or the id needed to retrieve them.
+     * @param toStore
+     * @param position
+     */
+    storeDocument(toStore: File): Promise<IDocumentInfo>;
+    /**
+     * Upload documents to a server store and returns the url or the id needed to retrieve them.
+     * @param toStore
+     * @param position
+     */
+    storeDocuments(toStore: File[]): Observable<IDocumentInfo>;
+}
+interface IStoreManager {
+    getProvider<T = never>(name?: string): IStoreProvider<T> | undefined;
+    getProviderSafe<T = never>(name?: string): IStoreProvider<T>;
+    getDefaultProvider<T = never>(): IStoreProvider<T> | undefined;
+    getDefaultProviderSafe<T = never>(): IStoreProvider<T>;
+}
+
+declare function attachToFormGroup(formGroup: FormGroup, controlName: string, value: any, valueType?: string, resolver?: XtTypeResolver): void;
+declare function updateFormGroupWithValue(formGroup: FormGroup, value: {
+    [key: string]: any;
+}, valueType?: string, resolver?: XtTypeResolver): void;
+
+declare class XtUnitTestHelper {
+}
+
+/**
+ * Component that can be used to bootstrap tests.
+ * Just set the value and component type, and it will be injected in your test.
+ */
+declare class HostTestSimpleComponent {
+    type: _angular_core.InputSignal<Type<XtComponent<any>>>;
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    value: _angular_core.InputSignal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestSimpleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestSimpleComponent, "test-host", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Same as HostTestSimpleComponent but it includes everything in a form.
+ * Just set the component type, the formGroup and the component  name, and your component will be run.
+ * You can as well easily read and set the value.
+ */
+declare class HostTestFormComponent {
+    builder: FormBuilder;
+    type: _angular_core.InputSignal<Type<XtComponent<any>>>;
+    controlName: _angular_core.InputSignal<string>;
+    formDescription: _angular_core.InputSignal<any>;
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    createdFormGroup: FormGroup | null;
+    computedFormGroup(): FormGroup<any>;
+    patchValue(newVal: any): void;
+    retrieveValue(): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestFormComponent, "test-form-host", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": true; "isSignal": true; }; "formDescription": { "alias": "formDescription"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Component that can be used to test your component based on the type it handles
+ * Just set the type hierarchy to register, the value, and it will instantiate the right component in your plugin
+ */
+declare class HostTestTypedComponent {
+    displayMode: _angular_core.InputSignal<XtDisplayMode>;
+    value: _angular_core.InputSignal<any>;
+    valueType: _angular_core.InputSignal<string | undefined>;
+    context: _angular_core.Signal<XtBaseContext<unknown>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestTypedComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestTypedComponent, "test-typed-host", never, { "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Same as HostTestSimpleComponent but it includes everything in a form.
+ * Just set the component type, the formGroup and the component  name, and your component will be run.
+ * You can as well easily read and set the value.
+ */
+declare class HostTestTypedFormComponent implements OnInit {
+    builder: FormBuilder;
+    resolver: XtResolverService;
+    static readonly CONTROL_NAME = "ForTest";
+    valueType: _angular_core.InputSignal<string | undefined>;
+    controlName: _angular_core.InputSignal<string | undefined>;
+    formDescription: _angular_core.InputSignal<any>;
+    formGroup: _angular_core.InputSignal<FormGroup<any> | undefined>;
+    parentFormGroup: FormGroup<{
+        [x: string]: AbstractControl<any, any, any>;
+    }>;
+    createdFormGroup: FormGroup | null;
+    ngOnInit(): void;
+    computeFormGroup(): FormGroup<any>;
+    subContext(): XtBaseContext<any>;
+    patchValue(controlName: string, newVal: any): void;
+    retrieveValue(controlName: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HostTestTypedFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HostTestTypedFormComponent, "test-typed-form-host", never, { "valueType": { "alias": "valueType"; "required": false; "isSignal": true; }; "controlName": { "alias": "controlName"; "required": false; "isSignal": true; }; "formDescription": { "alias": "formDescription"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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
+ */
+declare class StoreTestHelper {
+    static ensureTestProviderOnly(): void;
+}
+declare class TestStoreManager implements IStoreManager {
+    protected defaultProvider: TestStoreProvider<never>;
+    getProvider<T = never>(name?: string): IStoreProvider<T> | undefined;
+    getProviderSafe<T = never>(name?: string): IStoreProvider<T>;
+    getDefaultProvider<T = never>(): IStoreProvider<T> | undefined;
+    getDefaultProviderSafe<T = never>(): IStoreProvider<T>;
+}
+declare class TestStoreProvider<T = never> implements IStoreProvider<T> {
+    protected data: Map<string, Map<string, any>>;
+    protected getOrCreateArray(name: string): Map<string, T>;
+    protected extractKey(value: any, create?: boolean): string;
+    storeEntity(name: string, entity: T): Promise<T>;
+    safeLoadEntity(name: string, key: any): Promise<T>;
+    loadEntity(name: string, key: any): Promise<T | undefined>;
+    deleteEntity(name: string, key: any): Promise<boolean>;
+    searchEntities(name: string, ...criteria: any[]): Observable<T[]>;
+    searchAndPrepareEntities(name: string, sort?: any, groupBy?: any, transformer?: IDataTransformer<T> | undefined, ...criteria: any[]): Observable<any>;
+    canStoreDocument(): boolean;
+    storeDocument(toStore: File): Promise<IDocumentInfo>;
+    storeDocuments(toStore: File[]): Observable<IDocumentInfo>;
+}
+declare class TestDocumentInfo implements IDocumentInfo {
+    documentName: string;
+    isUrl: boolean;
+    documentId?: string;
+    constructor(documentName: string, isUrl: boolean, documentId?: string);
+}
+
+export { HostTestFormComponent, HostTestSimpleComponent, HostTestTypedComponent, HostTestTypedFormComponent, StoreSupport, StoreTestHelper, TestDocumentInfo, 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 type { IDataTransformer, IDocumentInfo, IStoreManager, IStoreProvider, XtActionHandler, XtActionHandlerInfo, XtActionInfo, XtActionResult, XtComponent, XtComponentInfo, XtComponentInput, XtComponentOutput, XtContext, XtDisplayMode, XtInputType, XtOutputType, XtPluginInfo, XtResolver, XtTypeHandlerInfo };

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "xt-components",
-  "version": "0.4.8",
+  "version": "0.5.5",
   "peerDependencies": {
-    "@angular/animations": "^18.1.2",
-    "@angular/common": "^18.1.2",
-    "@angular/compiler": "^18.1.2",
-    "@angular/core": "^18.1.2",
-    "@angular/forms": "^18.1.2",
-    "@angular/platform-browser": "^18.1.2",
-    "@angular/platform-browser-dynamic": "^18.1.2",
-    "@angular/router": "~18.1.2",
-    "rxjs": "~7.8.0",
-    "primeng": "~17.18.6",
-    "primeicons": "~7.0.0"
+    "@angular/animations": "^20.2.3",
+    "@angular/common": "^20.2.3",
+    "@angular/compiler": "^20.2.3",
+    "@angular/core": "^20.2.3",
+    "@angular/forms": "^20.2.3",
+    "@angular/platform-browser": "^20.2.3",
+    "@angular/platform-browser-dynamic": "^20.2.3",
+    "@angular/router": "^20.2.3",
+    "rxjs": "~7.8.2",
+    "primeng": "^20.0.1",
+    "primeicons": "^7.0.0"
   },
   "dependencies": {
-    "tslib": "^2.3.0"
+    "tslib": "^2.8.1"
   },
   "module": "fesm2022/xt-components.mjs",
   "typings": "index.d.ts",

package/globals.d.ts

@@ -1,10 +0,0 @@
-/**
- * The global plugin registry.
- * Plugins will register to this when loaded.
- */
-import { XtPluginRegistry } from './lib/registry/xt-plugin-registry';
-declare global {
-    var XT_REGISTRY: XtPluginRegistry;
-}
-export declare function initXtPluginRegistry(): void;
-export declare function xtPluginRegistry(): XtPluginRegistry;

package/lib/angular/message-handler.d.ts

@@ -1,7 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class MessageHandler {
-    errorOccurred(error: any, errorMsg?: string): void;
-    warningOccurred(warningMsg?: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MessageHandler, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MessageHandler>;
-}