@asor-studio/asor-core 1.1.7 → 1.1.9

package/index.d.ts

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { OnInit, OnDestroy, QueryList, Type, PipeTransform } from '@angular/core';
-import { ActivatedRoute, CanActivate, Data, Router, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, RedirectCommand } from '@angular/router';
+import { ActivatedRoute, Data, CanActivate, Router, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, RedirectCommand } from '@angular/router';
 import { Location } from '@angular/common';
 import { Observable, BehaviorSubject, ReplaySubject } from 'rxjs';
 import { HttpParams, HttpHeaders, HttpResponse, HttpRequest, HttpErrorResponse, HttpStatusCode, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
@@ -778,6 +778,248 @@ declare abstract class BaseComponent implements IComp, OnInit, OnDestroy {
     static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent, never, never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Base abstract class for Atom components following the Atomic Design pattern.
+ * Atoms are the smallest functional units of the UI.
+ * Automatically extracts atom configuration from route data and sets up i18n paths.
+ *
+ * This class provides foundational functionality for all atom-level components,
+ * including access to route data, current atom configuration, and translation paths.
+ *
+ * @Directive - Can be extended by Angular components
+ * @abstract - Must be extended, cannot be instantiated directly
+ *
+ * @example
+ * // Create an atom component
+ * @Component({
+ *   selector: 'app-base-button',
+ *   templateUrl: './base-button.component.html'
+ * })
+ * export class BaseButtonComponent extends BaseAtom implements OnInit {
+ *   ngOnInit() {
+ *     // Access atom configuration
+ *     console.log(this.currentAtom.I18nPath);
+ *     // Use inherited i18n paths
+ *     console.log(this.I18nPath);
+ *   }
+ * }
+ */
+declare abstract class BaseAtom implements IBaseAtom, IConsoleLoggable, OnInit, OnDestroy {
+    static readonly className: string;
+    /**
+     * Injected ActivatedRoute for accessing route data and parameters.
+     */
+    protected route: ActivatedRoute;
+    /**
+     * Configuration object for the current atom component.
+     * Contains metadata like component name, i18n paths, and other atom-specific settings.
+     */
+    protected currentAtom: IAtom;
+    /**
+     * Array of i18n translation paths for this atom.
+     * Inherited from the atom configuration in route data.
+     * Used by translation utilities to load appropriate language files.
+     *
+     * @example
+     * // I18nPath might contain: ['/common', '/atoms']
+     * this.translateUtility.getTranslation$('SUBMIT', this.I18nPath, 'en');
+     */
+    I18nPath: string[];
+    /**
+     * Initializes the base atom by extracting configuration from route data.
+     * Automatically finds the matching atom configuration based on component class name
+     * and sets up i18n translation paths.
+     *
+     * @example
+     * // Route configuration with atom data:
+     * {
+     *   path: 'users',
+     *   component: UserListComponent,
+     *   data: {
+     *     Atoms: [
+     *       {
+     *         Component: BaseButtonComponent,
+     *         I18nPath: ['/common', '/buttons']
+     *       }
+     *     ]
+     *   } as IAsorRoute
+     * }
+     */
+    constructor();
+    /**
+     * Lifecycle hook called when the component view is about to enter.
+     * Must be implemented by derived classes to define component-specific initialization logic.
+     */
+    baseCompViewEnter(): void;
+    /**
+     * Lifecycle hook called when the component view is about to leave.
+     * Must be implemented by derived classes to define component-specific cleanup logic.
+     */
+    baseCompViewLeave(): void;
+    /**
+     * Lifecycle hook called when the component view is about to enter.
+     * Must be implemented by derived classes to define component-specific initialization logic.
+     */
+    baseAtomViewWillEnter(): void;
+    /**
+     * Lifecycle hook called when the component view is about to leave.
+     * Must be implemented by derived classes to define component-specific cleanup logic.
+     */
+    baseAtomViewWillLeave(): void;
+    /**
+     * Returns the name of the current component class.
+     * Used internally to match the component with its configuration in route data.
+     *
+     * @returns The class name of the component as a string
+     */
+    getClassName(): string;
+    /**
+     * Lifecycle hook called when the component is initialized.
+     * Calls the baseAtomViewWillEnter() method.
+     */
+    ngOnInit(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Calls the baseAtomViewWillLeave() method.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Ionic lifecycle hook called when the view is about to enter and become the active view.
+     * This is called regardless of whether it is the first load or cached view.
+     * Delegates to baseAtomViewWillEnter() for consistency across Angular and Ionic.
+     */
+    ionViewWillEnter(): void;
+    /**
+     * Ionic lifecycle hook called when the view is about to leave and no longer be the active view.
+     * This is called when navigating away from the current view.
+     * Delegates to baseAtomViewWillLeave() for consistency across Angular and Ionic.
+     */
+    ionViewWillLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseAtom, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseAtom, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Base abstract class for Organism components following the Atomic Design pattern.
+ * Organisms are complex UI components made up of molecules and/or atoms.
+ * Automatically extracts organism configuration from route data and sets up i18n paths.
+ *
+ * This class provides foundational functionality for all organism-level components,
+ * including access to route data, current organism configuration, and translation paths.
+ *
+ * @Directive - Can be extended by Angular components
+ * @abstract - Must be extended, cannot be instantiated directly
+ *
+ * @example
+ * // Create an organism component
+ * @Component({
+ *   selector: 'app-user-profile',
+ *   templateUrl: './user-profile.component.html'
+ * })
+ * export class UserProfileComponent extends BaseOrganism implements OnInit {
+ *   ngOnInit() {
+ *     // Access organism configuration
+ *     console.log(this.currentOrganism.I18nPath);
+ *     // Use inherited i18n paths
+ *     console.log(this.I18nPath);
+ *   }
+ * }
+ */
+declare abstract class BaseOrganism implements IBaseOrganism, IConsoleLoggable, OnInit, OnDestroy {
+    static readonly className: string;
+    /**
+     * Injected ActivatedRoute for accessing route data and parameters.
+     */
+    protected route: ActivatedRoute;
+    /**
+     * Configuration object for the current organism component.
+     * Contains metadata like component name, i18n paths, and other organism-specific settings.
+     */
+    protected currentOrganism: IOrganism;
+    /**
+     * Array of i18n translation paths for this organism.
+     * Inherited from the organism configuration in route data.
+     * Used by translation utilities to load appropriate language files.
+     *
+     * @example
+     * // I18nPath might contain: ['/common', '/organisms']
+     * this.translateUtility.getTranslation$('HEADER', this.I18nPath, 'en');
+     */
+    I18nPath: string[];
+    /**
+     * Initializes the base organism by extracting configuration from route data.
+     * Automatically finds the matching organism configuration based on component class name
+     * and sets up i18n translation paths.
+     *
+     * @example
+     * // Route configuration with organism data:
+     * {
+     *   path: 'users',
+     *   component: UserListComponent,
+     *   data: {
+     *     Organisms: [
+     *       {
+     *         Component: UserProfileComponent,
+     *         I18nPath: ['/common', '/profile']
+     *       }
+     *     ]
+     *   } as IAsorRoute
+     * }
+     */
+    constructor();
+    /**
+     * Lifecycle hook called when the component view is about to enter.
+     * Must be implemented by derived classes to define component-specific initialization logic.
+     */
+    baseCompViewEnter(): void;
+    /**
+     * Lifecycle hook called when the component view is about to leave.
+     * Must be implemented by derived classes to define component-specific cleanup logic.
+     */
+    baseCompViewLeave(): void;
+    /**
+     * Lifecycle hook called when the component view is about to enter.
+     * Must be implemented by derived classes to define component-specific initialization logic.
+     */
+    baseOrganismViewWillEnter(): void;
+    /**
+     * Lifecycle hook called when the component view is about to leave.
+     * Must be implemented by derived classes to define component-specific cleanup logic.
+     */
+    baseOrganismViewWillLeave(): void;
+    /**
+     * Returns the name of the current component class.
+     * Used internally to match the component with its configuration in route data.
+     *
+     * @returns The class name of the component as a string
+     */
+    getClassName(): string;
+    /**
+     * Lifecycle hook called when the component is initialized.
+     * Calls the baseOrganismViewWillEnter() method.
+     */
+    ngOnInit(): void;
+    /**
+     * Lifecycle hook called when the component is destroyed.
+     * Calls the baseOrganismViewWillLeave() method.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Ionic lifecycle hook called when the view is about to enter and become the active view.
+     * This is called regardless of whether it is the first load or cached view.
+     * Delegates to baseOrganismViewWillEnter() for consistency across Angular and Ionic.
+     */
+    ionViewWillEnter(): void;
+    /**
+     * Ionic lifecycle hook called when the view is about to leave and no longer be the active view.
+     * This is called when navigating away from the current view.
+     * Delegates to baseOrganismViewWillLeave() for consistency across Angular and Ionic.
+     */
+    ionViewWillLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseOrganism, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseOrganism, never, never, {}, {}, never, never, true, never>;
+}
+
 /**
  * Interface for route guard configuration with authentication and molecule support.
  * Used in route data configuration to define page-level authentication, child guards, and molecule components.
@@ -810,6 +1052,10 @@ interface IAsorRoute {
     I18nPath: string[];
     /** Array of molecule components to be used in this route */
     Molecules?: IMolecule[];
+    /** Array of atom components to be used in this route */
+    Atoms?: IAtom[];
+    /** Array of organism components to be used in this route */
+    Organisms?: IOrganism[];
     /** Array of component to be used in this route */
     Components?: IComponent[];
     /** Optional dataset creation configuration */
@@ -856,6 +1102,20 @@ interface ICreateDataSet {
     /** Optional creation options (encryption, storage type, etc.) */
     option?: CreateDataSetOption;
 }
+/**
+ * Interface representing an Atom component in the Atomic Design pattern.
+ * Atoms are the smallest UI components.
+ */
+interface IAtom {
+    /** Array of i18n translation paths for this atom */
+    I18nPath: string[];
+    /** Optional state handler configuration */
+    ConnectDataSet?: IConnectDataSet;
+    /** The Angular component class extending BaseAtom */
+    Atom: Type<BaseAtom> & ICompStatic;
+    /** Optional extra data to pass to the atom component */
+    ExtraData?: Data;
+}
 /**
  * Interface representing a Molecule component in the Atomic Design pattern.
  * Molecules are composite UI components made up of smaller atoms.
@@ -877,6 +1137,20 @@ interface IMolecule {
     /** Optional extra data to pass to the molecule component */
     ExtraData?: Data;
 }
+/**
+ * Interface representing an Organism component in the Atomic Design pattern.
+ * Organisms are composite UI components made up of molecules and atoms.
+ */
+interface IOrganism {
+    /** Array of i18n translation paths for this organism */
+    I18nPath: string[];
+    /** Optional state handler configuration */
+    ConnectDataSet?: IConnectDataSet;
+    /** The Angular component class extending BaseOrganism */
+    Organism: Type<BaseOrganism> & ICompStatic;
+    /** Optional extra data to pass to the organism component */
+    ExtraData?: Data;
+}
 /**
  * Interface representing a Component in the Atomic Design pattern.
  * Components are the smallest UI components.
@@ -935,6 +1209,19 @@ interface IComp {
     /** Called when the component view is about to leave/destroy */
     baseCompViewLeave(): void;
 }
+/**
+ * Interface for BaseAtom
+ */
+interface IBaseAtom extends IComp {
+    /**
+     * Called when the atom view is about to enter/initialize
+     */
+    baseAtomViewWillEnter(): void;
+    /**
+     * Called when the atom view is about to leave/destroy
+     */
+    baseAtomViewWillLeave(): void;
+}
 /**
  * Interface for BaseMolecule
  */
@@ -948,6 +1235,19 @@ interface IBaseMolecule extends IComp {
      */
     baseMoleculeViewWillLeave(): void;
 }
+/**
+ * Interface for BaseOrganism
+ */
+interface IBaseOrganism extends IComp {
+    /**
+     * Called when the organism view is about to enter/initialize
+     */
+    baseOrganismViewWillEnter(): void;
+    /**
+     * Called when the organism view is about to leave/destroy
+     */
+    baseOrganismViewWillLeave(): void;
+}
 /**
  * Interface for authorization response from the backend API.
  * Contains the authorization status indicating if the user is allowed to perform an action.
@@ -2127,69 +2427,19 @@ declare function BaseHandlerMixin<T extends object = any, TBase extends Construc
  */
 declare function createFlattenedReactiveProxy<T>(propsStore: Record<string, any>): T;
 
-declare const BaseStorageComponent_base: _asor_studio_asor_core.Constructor<IStorageHandler<any> & {
+declare const BaseStorageAtom_base: _asor_studio_asor_core.Constructor<IStorageHandler<any> & {
     propsStore: any;
     registryElement: _asor_studio_asor_core.RegistryElement;
     storageHandlerDataChanges(prev: any, curr: any): void;
-}> & typeof BaseComponent;
+}> & typeof BaseAtom;
 /**
- * Base abstract class for Page/Component-level components with integrated storage handler functionality.
- * Extends BaseComponent with automatic state management, reactive props, and store synchronization.
+ * Base abstract class for Atom-level components with integrated storage handler functionality.
+ * Extends BaseAtom with automatic state management, reactive props, and store synchronization.
  *
- * This class combines the lifecycle management and i18n capabilities of BaseComponent
+ * This class combines the Atomic Design atom structure and i18n capabilities of BaseAtom
  * with the storage handling features from BaseHandlerMixin.
- *
- * Storage features:
- * - Automatic dataset creation from route configuration
- * - Reactive connection to state store
- * - Proxy-based prop-to-store synchronization
- * - Support for nested object updates
- * - Full object/array assignment reactivity (e.g. this.props.list = [...])
- *
- * @Directive - Can be extended by Angular components
- * @abstract - Must be extended, cannot be instantiated directly
- *
- * @example
- * // Route configuration with storage:
- * {
- *   path: 'user-profile',
- *   component: UserProfileComponent,
- *   data: {
- *     I18nPath: ['/common', '/user'],
- *     CreateDataSet: {
- *       name: 'userProfile',
- *       data: { name: '', email: '' },
- *       option: CreateDataSetOption.CREATE_IF_NOT_EXISTS
- *     },
- *     ConnectDataSet: {
- *       propStructure: {
- *         name: ['userProfile', 'name'],
- *         email: ['userProfile', 'email']
- *       }
- *     }
- *   } as IAsorRoute
- * }
- *
- * @example
- * // Component implementation:
- * @Component({
- *   selector: 'app-user-profile',
- *   templateUrl: './user-profile.component.html'
- * })
- * export class UserProfileComponent extends BaseStorageHandlerComp {
- *
- *   storageHandlerDataChanges(data: any): void {
- *     console.log('Store data updated:', data);
- *     // React to store changes
- *   }
- *
- *   updateUserName(newName: string): void {
- *     // This automatically updates the store
- *     this.props.name = newName;
- *   }
- * }
  */
-declare abstract class BaseStorageComponent<T extends object = Record<string, any>> extends BaseStorageComponent_base implements IStorageHandler<T> {
+declare abstract class BaseStorageAtom<T extends object = Record<string, any>> extends BaseStorageAtom_base implements IStorageHandler<T> {
     /**
      * Typed props object for type-safe state management.
      * Returns a flattened reactive proxy over propsStore so that both
@@ -2201,9 +2451,13 @@ declare abstract class BaseStorageComponent<T extends object = Record<string, an
      * Override baseCompViewLeave to unregister from store
      */
     baseCompViewLeave(): void;
+    /**
+     * Override baseAtomViewWillLeave to unregister from store
+     */
+    baseAtomViewWillLeave(): void;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStorageComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStorageComponent<any>, never, never, {}, {}, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStorageAtom<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStorageAtom<any>, never, never, {}, {}, never, never, true, never>;
 }
 
 declare const BaseStorageMolecule_base: _asor_studio_asor_core.Constructor<IStorageHandler<any> & {
@@ -2303,6 +2557,118 @@ declare abstract class BaseStorageMolecule<T extends object = Record<string, any
     static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStorageMolecule<any>, never, never, {}, {}, never, never, true, never>;
 }
 
+declare const BaseStorageOrganism_base: _asor_studio_asor_core.Constructor<IStorageHandler<any> & {
+    propsStore: any;
+    registryElement: _asor_studio_asor_core.RegistryElement;
+    storageHandlerDataChanges(prev: any, curr: any): void;
+}> & typeof BaseOrganism;
+/**
+ * Base abstract class for Organism-level components with integrated storage handler functionality.
+ * Extends BaseOrganism with automatic state management, reactive props, and store synchronization.
+ *
+ * This class combines the Atomic Design organism structure and i18n capabilities of BaseOrganism
+ * with the storage handling features from BaseHandlerMixin.
+ */
+declare abstract class BaseStorageOrganism<T extends object = Record<string, any>> extends BaseStorageOrganism_base implements IStorageHandler<T> {
+    /**
+     * Typed props object for type-safe state management.
+     * Returns a flattened reactive proxy over propsStore so that both
+     * read and write operations (including full object/array assignment)
+     * are forwarded through the reactive proxy, triggering state updates.
+     */
+    get props(): T;
+    /**
+     * Override baseCompViewLeave to unregister from store
+     */
+    baseCompViewLeave(): void;
+    /**
+     * Override baseOrganismViewWillLeave to unregister from store
+     */
+    baseOrganismViewWillLeave(): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStorageOrganism<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStorageOrganism<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const BaseStorageComponent_base: _asor_studio_asor_core.Constructor<IStorageHandler<any> & {
+    propsStore: any;
+    registryElement: _asor_studio_asor_core.RegistryElement;
+    storageHandlerDataChanges(prev: any, curr: any): void;
+}> & typeof BaseComponent;
+/**
+ * Base abstract class for Page/Component-level components with integrated storage handler functionality.
+ * Extends BaseComponent with automatic state management, reactive props, and store synchronization.
+ *
+ * This class combines the lifecycle management and i18n capabilities of BaseComponent
+ * with the storage handling features from BaseHandlerMixin.
+ *
+ * Storage features:
+ * - Automatic dataset creation from route configuration
+ * - Reactive connection to state store
+ * - Proxy-based prop-to-store synchronization
+ * - Support for nested object updates
+ * - Full object/array assignment reactivity (e.g. this.props.list = [...])
+ *
+ * @Directive - Can be extended by Angular components
+ * @abstract - Must be extended, cannot be instantiated directly
+ *
+ * @example
+ * // Route configuration with storage:
+ * {
+ *   path: 'user-profile',
+ *   component: UserProfileComponent,
+ *   data: {
+ *     I18nPath: ['/common', '/user'],
+ *     CreateDataSet: {
+ *       name: 'userProfile',
+ *       data: { name: '', email: '' },
+ *       option: CreateDataSetOption.CREATE_IF_NOT_EXISTS
+ *     },
+ *     ConnectDataSet: {
+ *       propStructure: {
+ *         name: ['userProfile', 'name'],
+ *         email: ['userProfile', 'email']
+ *       }
+ *     }
+ *   } as IAsorRoute
+ * }
+ *
+ * @example
+ * // Component implementation:
+ * @Component({
+ *   selector: 'app-user-profile',
+ *   templateUrl: './user-profile.component.html'
+ * })
+ * export class UserProfileComponent extends BaseStorageHandlerComp {
+ *
+ *   storageHandlerDataChanges(data: any): void {
+ *     console.log('Store data updated:', data);
+ *     // React to store changes
+ *   }
+ *
+ *   updateUserName(newName: string): void {
+ *     // This automatically updates the store
+ *     this.props.name = newName;
+ *   }
+ * }
+ */
+declare abstract class BaseStorageComponent<T extends object = Record<string, any>> extends BaseStorageComponent_base implements IStorageHandler<T> {
+    /**
+     * Typed props object for type-safe state management.
+     * Returns a flattened reactive proxy over propsStore so that both
+     * read and write operations (including full object/array assignment)
+     * are forwarded through the reactive proxy, triggering state updates.
+     */
+    get props(): T;
+    /**
+     * Override baseCompViewLeave to unregister from store
+     */
+    baseCompViewLeave(): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStorageComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseStorageComponent<any>, never, never, {}, {}, never, never, true, never>;
+}
+
 /**
  * Service for managing and distributing HTTP error notifications across the application.
  * Implements a centralized error notification system using RxJS observables.
@@ -2681,5 +3047,5 @@ declare class AsorWidgetComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<AsorWidgetComponent, "asor-core-widget", never, { "mode": { "alias": "mode"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { GlobalEnum_d as AsorGlobalEnum, StateConstants_d as AsorStorage, AsorWidgetComponent, AuthGuard, AuthUtility, BaseComponent, BaseHandlerMixin, BaseMolecule, BaseStorageComponent, BaseStorageMolecule, CacheInterceptor, CachePathUtility, CacheUtility, CollectionUtils, ConfigCache, ConfigConst, ConsoleLogsConfig, ConsoleLogsUtility, CookieUtils, ErrorInterceptor, HttpRequestHandler, MockHttpInterceptor, MockOrchestratorService, MockRequestMapping, NotifyErrorService, ObjectUtils, RandomUtils, RoutingUtility, StateConst, StateService, StringUtils, TranslatePipe, TranslateUtility, createFlattenedReactiveProxy };
-export type { AsorWidgetMode, Constructor, CreateDataSetOption, DataElement, DataMethod, EncryptType, GenerateType, IAsorRoute, IAuth, IBaseMolecule, IComp, ICompStatic, IComponent, IConnectDataSet, IConsoleLoggable, ICreateDataSet, IHttpAuthSubscribe, IHttpFormError, IHttpRequest, IHttpRequestHandlerConfig, IHttpResponseError, IHttpSubscribe, IMolecule, IPath, IRequestMapping, IStorageHandler, LogClassConfig, LogEntry, LogLevel, RegistryElement, RegistryEntry, StateHandlerConfig, StoreType, UpdateDataSetOption };
+export { GlobalEnum_d as AsorGlobalEnum, StateConstants_d as AsorStorage, AsorWidgetComponent, AuthGuard, AuthUtility, BaseAtom, BaseComponent, BaseHandlerMixin, BaseMolecule, BaseOrganism, BaseStorageAtom, BaseStorageComponent, BaseStorageMolecule, BaseStorageOrganism, CacheInterceptor, CachePathUtility, CacheUtility, CollectionUtils, ConfigCache, ConfigConst, ConsoleLogsConfig, ConsoleLogsUtility, CookieUtils, ErrorInterceptor, HttpRequestHandler, MockHttpInterceptor, MockOrchestratorService, MockRequestMapping, NotifyErrorService, ObjectUtils, RandomUtils, RoutingUtility, StateConst, StateService, StringUtils, TranslatePipe, TranslateUtility, createFlattenedReactiveProxy };
+export type { AsorWidgetMode, Constructor, CreateDataSetOption, DataElement, DataMethod, EncryptType, GenerateType, IAsorRoute, IAtom, IAuth, IBaseAtom, IBaseMolecule, IBaseOrganism, IComp, ICompStatic, IComponent, IConnectDataSet, IConsoleLoggable, ICreateDataSet, IHttpAuthSubscribe, IHttpFormError, IHttpRequest, IHttpRequestHandlerConfig, IHttpResponseError, IHttpSubscribe, IMolecule, IOrganism, IPath, IRequestMapping, IStorageHandler, LogClassConfig, LogEntry, LogLevel, RegistryElement, RegistryEntry, StateHandlerConfig, StoreType, UpdateDataSetOption };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asor-studio/asor-core",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "keywords": [
     "angular",
     "library",
@@ -24,6 +24,7 @@
     "tslib": "^2.3.0"
   },
   "sideEffects": false,
+  "author": "robrosc",
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public",