xt-components 0.5.0 → 0.6.0

package/index.d.ts

@@ -1,10 +1,48 @@
 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 { XtTypeResolver, XtTypeInfo, XtTypeHandler } from 'xt-type';
+import { XtTypeInfo, XtTypeReference, XtTypeResolver, XtTypeHandler, MappingHelper } from 'xt-type';
 import * as xt_components from 'xt-components';
-import { NgComponentOutlet } from '@angular/common';
 import { Observable } from 'rxjs';
+import { NgComponentOutlet } from '@angular/common';
+
+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);
+}
 
 /**
  * A XtContext provides all the necessary information for an ng-extended component to operate. It is passed from parent to child component and pass
@@ -19,6 +57,24 @@ type XtContext<T> = {
     subName?: string;
     parentFormGroup?: FormGroup;
     localFormGroup?: FormGroup;
+    /**
+     * When the value in the context is a reference to another type
+     */
+    reference?: XtTypeReference;
+    /**
+     * If it's a reference, we keep the context referenced
+     */
+    referencedContext?: XtContext<any>;
+    /**
+     * creates the referencedContext by using this referenced value
+     * @param val
+     *
+    updateReferencedContext(val: any, valueType?:string): void;*/
+    /**
+     * Signal when all the asynchronously defined subreferences are resolved.
+     *
+    subReferencesResolved: WritableSignal<boolean>;
+  */
     parentContext?: XtContext<any>;
     isInForm(): boolean;
     formGroup(): FormGroup | undefined;
@@ -33,6 +89,9 @@ type XtContext<T> = {
     value(): T | null | undefined;
     valueType?: string;
     toString(): string;
+    listActions: WritableSignal<XtAction<T>[] | null>;
+    isReference(): boolean;
+    setReferenceInfo(ref: XtTypeReference): void;
 };
 type XtDisplayMode = 'INLINE_VIEW' | 'FULL_VIEW' | 'FULL_EDITABLE' | 'LIST_VIEW';
 declare class XtBaseContext<T> implements XtContext<T> {
@@ -59,6 +118,19 @@ declare class XtBaseContext<T> implements XtContext<T> {
      */
     nonFormValue?: WritableSignal<T | null>;
     valueType?: string;
+    /**
+     * When the value in the context is a reference to another type
+     */
+    reference?: XtTypeReference;
+    /**
+     * If it's a reference, we keep the context referenced
+     *
+    referencedContext?:XtContext<any>;*/
+    /**
+     * Keeps track of all the possible actions for this context
+     * @protected
+     */
+    listActions: WritableSignal<XtAction<T>[] | null>;
     /**
      *
      * @param displayMode
@@ -87,6 +159,23 @@ declare class XtBaseContext<T> implements XtContext<T> {
     elementSetContext(elementIndex: number): XtContext<any>;
     subContext(subName: string | undefined | null, subType?: string, typeResolver?: XtTypeResolver | null): XtContext<any>;
     formGroup(): FormGroup | undefined;
+    isReference(): boolean;
+    setReferenceInfo(reference: XtTypeReference): void;
+    /**
+     * creates the referencedContext by using this referenced value
+     * @param val
+     *
+    updateReferencedContext(val: any, valueType?:string): void {
+      if (!this.isReference()) throw new Error ('This context '+this.toString()+' is not a reference.');
+  
+      if( this.referencedContext==null) {
+        let refDisplayMode = 'INLINE_VIEW' as XtDisplayMode;
+        if (this.displayMode=='FULL_VIEW') refDisplayMode = 'FULL_VIEW';
+        this.referencedContext = new XtBaseContext(refDisplayMode);
+      }
+      this.referencedContext.setDisplayValue(val);
+      if( valueType!=null) this.referencedContext.valueType=valueType;
+    }*/
     toString(): string;
 }
 
@@ -110,24 +199,6 @@ type XtComponentInput = {
     [key in XtInputType]: InputSignal<any> | undefined;
 };
 
-type XtComponentInfo<T> = {
-    componentName: string;
-    componentClass: T;
-    typesHandled: string[];
-    outputs?: XtOutputType[];
-};
-type XtTypeHandlerInfo<T> = {
-    typesHandled: string[];
-    handlerClass: T;
-};
-type XtPluginInfo = {
-    name: string;
-    uriLogo?: string;
-    components?: XtComponentInfo<any>[];
-    types?: XtTypeInfo;
-    typeHandlers?: XtTypeHandlerInfo<any>[];
-};
-
 declare class XtResolvedComponent {
     componentName: string;
     componentClass: any;
@@ -144,6 +215,7 @@ 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[]>;
     /**
@@ -164,29 +236,97 @@ declare class XtPluginRegistry {
     static readonly ANY_OBJECT_TYPE = "ANY_OBJECT_TYPE";
     static readonly ANY_PRIMITIVE_SET = "ANY_PRIMITIVE_SET";
     static readonly ANY_OBJECT_SET = "ANY_OBJECT_SET";
+    /**
+     * Whenever a component can handle any type of reference to a single entity or to multiple entities.
+     */
+    static readonly ANY_SINGLE_REFERENCE = "ANY_SINGLE_REFERENCE";
+    static readonly ANY_MULTIPLE_REFERENCE = "ANY_MULTIPLE_REFERENCE";
     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>;
+    }[];
 }
 
 /**
- * The global plugin registry.
- * Plugins will register to this when loaded.
+ * Wrapper around xt-store manager: You can use it to check if xt-store is included or not, and decide what to do
+ *
+ * This allows plugins to potentially use xt-store whenever included in the applications running the plugin
  */
 
-declare global {
-    var XT_REGISTRY: XtPluginRegistry;
+declare class StoreSupport {
+    protected static testStoreManager?: IStoreManager;
+    static isStoreManagerAvailable(): boolean;
+    static getStoreManager(): IStoreManager;
+    static setTestStoreManager(testStoreManager: IStoreManager): void;
+    static newStoreCriteria(name: string, value: any, operator?: IStoreCriteriaOperator): IStoreCriteria;
+}
+/**
+ * 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;
+}
+type IStoreCriteriaOperator = '=' | '<' | '<=';
+interface IStoreCriteria {
+    name: string;
+    value: any;
+    operator: IStoreCriteriaOperator;
+}
+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: IStoreCriteria[]): 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>;
+    newStoreCriteria(name: string, value: any, operator: IStoreCriteriaOperator): IStoreCriteria;
 }
-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>;
 
+/**
+ * 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;
@@ -204,6 +344,18 @@ declare class XtResolverService {
     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;
@@ -216,10 +368,62 @@ declare class XtResolverService {
      * @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;
+    resolveReferencedValue<T, U>(context: XtContext<T>, storeMgr: IStoreManager): Promise<U | U[] | null | undefined>;
+    resolvePendingReferences(): void;
+    /**
+     * Calculates the values that can be referenced by the reference & value of this context
+     * @param context
+     */
+    findPossibleReferences<T, U>(context: XtContext<T>): Observable<U[]>;
     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;
 }
@@ -247,6 +451,7 @@ declare class XtRenderComponent<T> implements AfterViewInit {
     outlet: Signal<NgComponentOutlet<any>>;
     constructor();
     context: Signal<XtContext<any>>;
+    realContext: Signal<XtContext<any>>;
     type: Signal<Type<XtComponent<T>> | null>;
     /**
      * Transfers the input and outputs from the host to the rendered component
@@ -268,6 +473,7 @@ declare class XtRenderSubComponent<T> implements AfterViewInit {
     outputs: _angular_core.OutputEmitterRef<XtComponentOutput>;
     outlet: Signal<NgComponentOutlet<any>>;
     resolverService: XtResolverService;
+    realContext: Signal<XtContext<T>>;
     type: Signal<Type<XtComponent<T>> | null>;
     /**
      * Transfers the input and outputs from the host to the rendered component
@@ -332,72 +538,11 @@ declare class XtCompositeComponent<T = any> extends XtSimpleComponent<T> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<XtCompositeComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
 }
 
-declare class MessageHandler {
+declare class XtMessageHandler {
     errorOccurred(error: any, errorMsg?: string): void;
     warningOccurred(warningMsg?: string): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageHandler, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MessageHandler>;
-}
-
-/**
- * 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>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XtMessageHandler, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<XtMessageHandler>;
 }
 
 declare function attachToFormGroup(formGroup: FormGroup, controlName: string, value: any, valueType?: string, resolver?: XtTypeResolver): void;
@@ -488,16 +633,17 @@ declare class TestStoreManager implements IStoreManager {
     getProviderSafe<T = never>(name?: string): IStoreProvider<T>;
     getDefaultProvider<T = never>(): IStoreProvider<T> | undefined;
     getDefaultProviderSafe<T = never>(): IStoreProvider<T>;
+    newStoreCriteria(name: string, value: any, operator: IStoreCriteriaOperator): IStoreCriteria;
 }
 declare class TestStoreProvider<T = never> implements IStoreProvider<T> {
     protected data: Map<string, Map<string, any>>;
-    protected getOrCreateArray(name: string): Map<string, any>;
-    protected extractKey(value: any): string;
+    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[]>;
+    searchEntities(name: string, ...criteria: TestStoreCriteria[]): Observable<T[]>;
     searchAndPrepareEntities(name: string, sort?: any, groupBy?: any, transformer?: IDataTransformer<T> | undefined, ...criteria: any[]): Observable<any>;
     canStoreDocument(): boolean;
     storeDocument(toStore: File): Promise<IDocumentInfo>;
@@ -509,6 +655,13 @@ declare class TestDocumentInfo implements IDocumentInfo {
     documentId?: string;
     constructor(documentName: string, isUrl: boolean, documentId?: string);
 }
+declare class TestStoreCriteria implements IStoreCriteria {
+    name: string;
+    value: any;
+    operator: '=' | '<=' | '<';
+    constructor(name: string, value: any, operator?: IStoreCriteriaOperator);
+    filter(toFilter: any): boolean;
+}
 
-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, attachToFormGroup, initXtPluginRegistry, updateFormGroupWithValue, xtPluginRegistry };
-export type { IDataTransformer, IDocumentInfo, IStoreManager, IStoreProvider, XtComponent, XtComponentInfo, XtComponentInput, XtComponentOutput, XtContext, XtDisplayMode, XtInputType, XtOutputType, XtPluginInfo, XtResolver, XtTypeHandlerInfo };
+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 type { IDataTransformer, IDocumentInfo, IStoreCriteria, IStoreCriteriaOperator, IStoreManager, IStoreProvider, XtActionHandler, XtActionHandlerInfo, XtActionInfo, XtActionResult, XtComponent, XtComponentInfo, XtComponentInput, XtComponentOutput, XtContext, XtDisplayMode, XtInputType, XtOutputType, XtPluginInfo, XtResolver, XtTypeHandlerInfo };

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "xt-components",
-  "version": "0.5.0",
+  "version": "0.6.0",
+  "repository": {
+    "url": "https://github.com/dont-code/ng-xtend.git"
+  },
   "peerDependencies": {
     "@angular/animations": "^20.2.3",
     "@angular/common": "^20.2.3",