http-request-manager 0.0.2 → 4.1.2

package/lib/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from './database-storage.model';
+export * from './retry-options.model';
+export * from './data-type.enum';
+export * from './config-http-options.model';
+export * from './config-local-storage-options.model';
+export * from './config-options.model';

package/lib/models/retry-options.model.d.ts

@@ -0,0 +1,10 @@
+export interface RetryOptionsInterface {
+    times?: number;
+    delay?: number;
+}
+export declare class RetryOptions implements RetryOptionsInterface {
+    times: number;
+    delay: number;
+    constructor(times?: number, delay?: number);
+    static adapt(item?: any): RetryOptions;
+}

package/lib/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./local-storage-manager-service/index";
+export * from "./request-manager-services/index";
+export * from "./request-manager-state-service/index";
+export * from "./utils/index";

package/lib/services/local-storage-manager-service/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./models/index";
+export * from "./local-storage-manager.service";

package/lib/services/local-storage-manager-service/local-storage-manager.service.d.ts

@@ -0,0 +1,86 @@
+import { OnDestroy } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { UtilsService } from '../utils/utils.service';
+import { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';
+import { StorageOption } from './models';
+import { SettingOptions } from './models/setting-options.model';
+import { StorageData } from './models/storage-data.model';
+import { EncryptionTestService } from '../utils/encryption/encryption-test.service';
+import { AppService } from '../utils/app.service';
+import { ConfigOptions } from '../request-manager-services';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import * as i0 from "@angular/core";
+export interface State {
+    localStores: StorageData[];
+    sessionStores: StorageData[];
+    settings: StorageOption[];
+}
+export declare class LocalStorageManagerService extends ComponentStore<State> implements OnDestroy {
+    private config;
+    storageName: string;
+    storageSettingsName: string;
+    defaultOptions: SettingOptions;
+    stateRetrieved: boolean;
+    encrypted: boolean;
+    app: AppService;
+    utils: UtilsService;
+    objectMergerService: ObjectMergerService;
+    encryption: SymmetricalEncryptionService;
+    encryptionTest: EncryptionTestService;
+    private readonly data$;
+    readonly stores$: import("rxjs").Observable<StorageOption[]>;
+    readonly storeExists$: (store: string) => import("rxjs").Observable<boolean>;
+    readonly store$: (store: string) => import("rxjs").Observable<any>;
+    readonly settings$: import("rxjs").Observable<StorageOption[]>;
+    readonly setting$: (store: string) => import("rxjs").Observable<StorageOption | null>;
+    persistence$: import("rxjs").Subscription;
+    startTimer(): void;
+    private updateState;
+    constructor(config: ConfigOptions);
+    readonly setStore: (observableOrValue: {
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | import("rxjs").Observable<{
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => import("rxjs").Subscription;
+    readonly createStore: (observableOrValue: {
+        id?: string | undefined;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | import("rxjs").Observable<{
+        id?: string | undefined;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => import("rxjs").Subscription;
+    readonly updateStore: (observableOrValue: {
+        name: string;
+        data: any;
+    } | import("rxjs").Observable<{
+        name: string;
+        data: any;
+    }>) => import("rxjs").Subscription;
+    readonly deleteStore: (observableOrValue: {
+        name: string;
+    } | import("rxjs").Observable<{
+        name: string;
+    }>) => import("rxjs").Subscription;
+    resetStore(): void;
+    private persistState;
+    private expired;
+    retrieveState(): void;
+    private isObjectOrArray;
+    private isString;
+    private fixAndParseJSON;
+    private validStoreName;
+    private hasGlobalStorage;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
+}

package/lib/services/local-storage-manager-service/models/global-store-options.model.d.ts

@@ -0,0 +1,15 @@
+import { StorageOption } from "./storage-option.model";
+export interface GlobalStoreOptionsInterface {
+    encryption?: boolean;
+    expiresIn?: string;
+    expires?: number;
+    stores: StorageOption[] | null;
+}
+export declare class GlobalStoreOptions implements GlobalStoreOptionsInterface {
+    encryption: boolean;
+    expiresIn?: string | undefined;
+    expires?: number | undefined;
+    stores: StorageOption[] | null;
+    constructor(encryption?: boolean, expiresIn?: string | undefined, expires?: number | undefined, stores?: StorageOption[] | null);
+    static adapt(item?: any): GlobalStoreOptions;
+}

package/lib/services/local-storage-manager-service/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./global-store-options.model";
+export * from "./setting-options.model";
+export * from "./storage-data.model";
+export * from "./storage-option.model";
+export * from "./storage-type.enum";

package/lib/services/local-storage-manager-service/models/setting-options.model.d.ts

@@ -0,0 +1,15 @@
+import { StorageType } from "./storage-type.enum";
+export interface SettingOptionsInterface {
+    storage?: StorageType;
+    expires?: number;
+    expiresIn?: string;
+    encrypted?: boolean;
+}
+export declare class SettingOptions implements SettingOptionsInterface {
+    storage?: StorageType | undefined;
+    expires?: number | undefined;
+    expiresIn?: string | undefined;
+    encrypted?: boolean | undefined;
+    constructor(storage?: StorageType | undefined, expires?: number | undefined, expiresIn?: string | undefined, encrypted?: boolean | undefined);
+    static adapt(item?: any): SettingOptions;
+}

package/lib/services/local-storage-manager-service/models/storage-data.model.d.ts

@@ -0,0 +1,10 @@
+export interface StorageDataInterface {
+    id?: string;
+    data?: any;
+}
+export declare class StorageData implements StorageDataInterface {
+    id?: string | undefined;
+    data?: any;
+    constructor(id?: string | undefined, data?: any);
+    static adapt(item?: any): StorageData;
+}

package/lib/services/local-storage-manager-service/models/storage-option.model.d.ts

@@ -0,0 +1,13 @@
+import { SettingOptions } from "./setting-options.model";
+export interface StorageOptionInterface {
+    id?: string;
+    name: string;
+    options?: SettingOptions;
+}
+export declare class StorageOption implements StorageOptionInterface {
+    id?: string | undefined;
+    name: string;
+    options?: SettingOptions | undefined;
+    constructor(id?: string | undefined, name?: string, options?: SettingOptions | undefined);
+    static adapt(item?: any): StorageOption;
+}

package/lib/services/local-storage-manager-service/models/storage-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum StorageType {
+    GLOBAL = 0,
+    SESSION = 1,
+    DB = 2
+}

package/lib/services/request-manager-services/http-manager.service.d.ts

@@ -0,0 +1,40 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { RequestService } from './request.service';
+import { ConfigOptions } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { ToastMessageService } from 'toast-message-display';
+import * as i0 from "@angular/core";
+export declare class HTTPManagerService<T> extends RequestService {
+    private configOptions?;
+    toastMessage: ToastMessageService;
+    ng_injector: Injector;
+    objectMergerService: ObjectMergerService;
+    private countdown;
+    countdown$: Observable<number>;
+    private error;
+    error$: Observable<boolean>;
+    private data;
+    data$: Observable<any>;
+    private polling$;
+    config: ConfigOptions;
+    constructor(configOptions?: ConfigOptions | undefined);
+    getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
+    postRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    putRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
+    downloadRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
+    private createObservable;
+    private createRequest;
+    private prepareRequestData;
+    private handleError;
+    private handleErrorWithSnackBar;
+    private stopPolling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerService<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerService<any>>;
+}

package/lib/services/request-manager-services/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./http-manager.service";
+export * from "../../models/index";
+export * from "./rxjs-operators/index";

package/lib/services/request-manager-services/request.service.d.ts

@@ -0,0 +1,28 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import * as i0 from "@angular/core";
+export declare class RequestService {
+    private http;
+    private pathQueryService;
+    private headersService;
+    isPending: BehaviorSubject<boolean>;
+    isPending$: Observable<boolean>;
+    progress: BehaviorSubject<number>;
+    progress$: Observable<number>;
+    getRecordRequest<T>(options: ApiRequest): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    deleteRecordRequest<T>(options: ApiRequest): Observable<T>;
+    private buildUrlPath;
+    private buildHeaders;
+    private buildCombinedHeaders;
+    private request;
+    downloadFileRequest(options: ApiRequest): Observable<any>;
+    private fileDetails;
+    private handleFinalize;
+    private downloadFile;
+    private createFileType;
+    private combineHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestService>;
+}

package/lib/services/request-manager-services/rxjs-operators/countdown.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function countdown(duration: number): Observable<number>;

package/lib/services/request-manager-services/rxjs-operators/delay-retry.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function delayedRetry<T>(delayMs: number, maxRetry?: number): (src: Observable<T>) => Observable<T>;

package/lib/services/request-manager-services/rxjs-operators/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./countdown";
+export * from "./delay-retry";
+export * from "./request-polling";
+export * from "./request-streaming";

package/lib/services/request-manager-services/rxjs-operators/request-polling.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+/**
+ * @param pollInterval
+ * @param stopCondition$
+ * @param isPending$
+ */
+export declare function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: BehaviorSubject<boolean>): (source: Observable<T>) => Observable<T>;

package/lib/services/request-manager-services/rxjs-operators/request-streaming.d.ts

@@ -0,0 +1,2 @@
+import { OperatorFunction } from 'rxjs';
+export declare function requestStreaming(): OperatorFunction<any, any>;

package/lib/services/request-manager-state-service/http-manager-state.store.d.ts

@@ -0,0 +1,51 @@
+import { ComponentStore } from '@ngrx/component-store';
+import { DatabaseStorage } from '../../models/database-storage.model';
+import { HTTPManagerService, DataType } from '../request-manager-services';
+import { ApiRequest, RequestOptions } from './models';
+import * as i0 from "@angular/core";
+export interface APIStateManagerData<T> {
+    data: T[];
+    dataObject: T | null;
+}
+export declare class HTTPManagerStateService<T extends {
+    id: number;
+}> extends ComponentStore<APIStateManagerData<T>> {
+    private apiOptions;
+    private dataType;
+    private database?;
+    httpManagerService: HTTPManagerService<any>;
+    error$: import("rxjs").Observable<boolean>;
+    isPending$: import("rxjs").Observable<boolean>;
+    private page;
+    page$: import("rxjs").Observable<number>;
+    private totalPages;
+    totalPages$: import("rxjs").Observable<number>;
+    private percentage;
+    percentage$: import("rxjs").Observable<number>;
+    private hasDatabase;
+    streamedResponse: never[];
+    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage | undefined);
+    setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage): void;
+    get ApiRequestOptions(): ApiRequest;
+    initStorage(): void;
+    initializeState(data: any): void;
+    readonly data$: import("rxjs").Observable<T | T[] | null>;
+    readonly selectRecord$: (id: number) => import("rxjs").Observable<T | T[] | null>;
+    private readonly setData$;
+    private updateArrayState;
+    private readonly addData$;
+    private readonly deleteData$;
+    private readonly updateData$;
+    readonly clearRecords: (observableOrValue?: void | import("rxjs").Observable<void> | undefined) => import("rxjs").Subscription;
+    readonly refreshData: (observableOrValue?: void | import("rxjs").Observable<void> | undefined) => import("rxjs").Subscription;
+    readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly createRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly updateRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly deleteRecord: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly createStream: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly fetchStream: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    private isEmpty;
+    private updateRequestOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateService<any>>;
+}

package/lib/services/request-manager-state-service/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./http-manager-state.store";
+export * from "./models/index";

package/lib/services/request-manager-state-service/models/api-request.model.d.ts

@@ -0,0 +1,25 @@
+import { RetryOptions } from "../../request-manager-services";
+export interface ApiRequestInterface {
+    server: string;
+    path: any[];
+    headers: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number;
+    retry: RetryOptions;
+    stream?: boolean;
+    displayError: boolean;
+}
+export declare class ApiRequest implements ApiRequestInterface {
+    server: string;
+    path: any[];
+    headers: {};
+    adapter?: any;
+    mapper?: any;
+    polling?: number | undefined;
+    retry: RetryOptions;
+    stream: boolean;
+    displayError: boolean;
+    constructor(server?: string, path?: any[], headers?: {}, adapter?: any, mapper?: any, polling?: number | undefined, retry?: RetryOptions, stream?: boolean, displayError?: boolean);
+    static adapt(item?: any): ApiRequest;
+}

package/lib/services/request-manager-state-service/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./api-request.model";
+export * from "./request-options.model";

package/lib/services/request-manager-state-service/models/request-options.model.d.ts

@@ -0,0 +1,10 @@
+export interface RequestOptionsInterface {
+    path: any[];
+    headers: any;
+}
+export declare class RequestOptions implements RequestOptionsInterface {
+    path: any[];
+    headers: {};
+    constructor(path?: any[], headers?: {});
+    static adapt(item?: any): RequestOptions;
+}

package/lib/services/utils/app.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class AppService {
+    private id;
+    appID: string;
+    constructor(id: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}

package/lib/services/utils/encryption/asymmetrical-encryption.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AsymmetricalEncryptionService {
+    constructor();
+    generateKeyPair(modulusLength?: number): Observable<CryptoKeyPair>;
+    encryptData(publicKey: CryptoKey, data: string): Observable<string>;
+    decryptData(privateKey: CryptoKey, encryptedData: string): Observable<string>;
+    pemToArrayBuffer(pem: string): ArrayBuffer;
+    base64ToArrayBuffer(base64: string): ArrayBuffer;
+    arrayBufferToBase64(buffer: ArrayBuffer): string;
+    base64ToPEM(base64Key: string, publicKey?: boolean): string;
+    pemToCryptoKey(pem: string, algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[], format?: any): Observable<CryptoKey>;
+    testGenerateKeys(): Observable<string>;
+    testDecryptionWithKeys(): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsymmetricalEncryptionService>;
+}

package/lib/services/utils/encryption/encryption-test.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class EncryptionTestService {
+    constructor();
+    private isBase64;
+    private isHexadecimal;
+    private hasHighEntropy;
+    isEncrypted(str: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncryptionTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EncryptionTestService>;
+}

package/lib/services/utils/encryption/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./asymmetrical-encryption.service";
+export * from './symmetrical-encryption.service';
+export * from './random';

package/lib/services/utils/encryption/random.d.ts

@@ -0,0 +1,7 @@
+export declare const Random: () => number;
+export declare const RandomNumber: (min: number, max: number) => number;
+export declare const RandomNumbers: (min: number, max: number, length: number) => number[];
+export declare const RandomNumbersUnique: (min: number, max: number, length: number) => number[];
+export declare const RandomStr: () => string;
+export declare const RandomSignature: () => number;
+export declare const UUID: () => `${string}-${string}-${string}-${string}-${string}`;

package/lib/services/utils/encryption/symmetrical-encryption.service.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class SymmetricalEncryptionService {
+    appID: string;
+    private appService;
+    constructor();
+    generateCipherKey(): string;
+    encrypt(str: any, key?: string): string | undefined;
+    decrypt(str: string, key?: string): string | undefined;
+    createSignature(url: string, len?: number): string;
+    normalizeURL(url: string): string;
+    generateSignature(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SymmetricalEncryptionService>;
+}

package/lib/services/utils/headers.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class HeadersService {
+    headers: {};
+    generateHeaders(headers?: Record<string, string>): {
+        headers: HttpHeaders;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeadersService>;
+}

package/lib/services/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './app.service';
+export * from './headers.service';
+export * from './path-query.service';
+export * from './utils.service';
+export * from './encryption/index';

package/lib/services/utils/object-merger.service.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class ObjectMergerService {
+    mergeOptions<T>(options: Partial<T>, configForRoot?: any): T;
+    isNonEmptyString(value: unknown): value is string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectMergerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectMergerService>;
+}

package/lib/services/utils/path-query.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class PathQueryService {
+    buildAPIPath(server: string | string[], params?: any[] | any): string;
+    private buildRestPath;
+    private buildQueryPath;
+    private cleanUrlPath;
+    private isObject;
+    private removeEmptyParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PathQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PathQueryService>;
+}

package/lib/services/utils/utils.service.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class UtilsService {
+    http: HttpClient;
+    constructor();
+    isString(x: string | number): boolean;
+    isObject(obj: any): boolean;
+    JSONToString(value: any): any;
+    stringToJSON(value: string): any;
+    isJSON(str: any): boolean;
+    getValueByProp(obj: any, prop: string): any;
+    objectsEqual(x: any, y: any): boolean;
+    getJSON(file: string): import("rxjs").Observable<Object>;
+    get today(): number;
+    base32ToHex(base32: string): string;
+    binaryToHex(binary: string): string;
+    expires(str?: string): number | undefined;
+    hasExpired(expiryDate: number): boolean;
+    hasExpiry(setting: any): boolean;
+    expiresIn(expiryDate: number): string | undefined;
+    lc: (str: string) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}

package/package.json

@@ -1,33 +1,56 @@
 {
   "name": "http-request-manager",
-  "version": "0.0.2",
+  "version": "4.1.2",
+  "description": "This library has 4 main services that simplify http requests, http request state and local storage states.",
   "author": "Michele Bonifacio",
-  "company": "wavecoders",
-  "description": "This is a test package",
-  "private": false,
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/wavecoders/sample.git"
-  },
-  "bugs": {
-    "url": "https://github.com/wavecoders/sample/issues"
-  },
-  "homepage": "https: //wavecoders.ca",
+  "company": "wavecoders.ca",
+  "homepage": "https://wavecoders.ca",
   "keywords": [
     "angular",
     "javascript",
     "typescript",
-    "typeahead",
-    "directive",
+    "http",
+    "local-storage",
+    "session-storage",
+    "DixieJS",
+    "NGRX",
+    "ComponentStore",
     "angular-material"
   ],
-  "license": "MIT",
   "peerDependencies": {
-    "@angular/common": "^16.2.0",
-    "@angular/core": "^16.2.0"
+    "@angular/cdk": "^15.2.9",
+    "@angular/common": "^15.2.0",
+    "@angular/compiler": "^15.2.0",
+    "@angular/core": "^15.2.0",
+    "toast-message-display": "^1.0.74",
+    "@ngrx/component-store": "^15.4.0",
+    "@ngx-translate/core": "^14.0.0",
+    "@ngx-translate/http-loader": "^6.0.0",
+    "@types/crypto-js": "^4.2.2",
+    "crypto-js": "^4.2.0",
+    "dexie": "^4.0.11",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/http-request-manager",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "module": "fesm2022/http-request-manager.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/http-request-manager.mjs",
+      "esm": "./esm2022/http-request-manager.mjs",
+      "default": "./fesm2022/http-request-manager.mjs"
+    }
+  }
 }

package/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/index';
+export * from './lib/http-request-manager.module';
+export * from './lib/http-request-services-demo/http-request-services-demo.component';

package/ng-package.json

@@ -1,7 +0,0 @@
-{
-  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
-  "dest": "../../dist/http-request-manager",
-  "lib": {
-    "entryFile": "src/public-api.ts"
-  }
-}

package/src/lib/http-request-manager.component.spec.ts

@@ -1,21 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { HttpRequestManagerComponent } from './http-request-manager.component';
-
-describe('HttpRequestManagerComponent', () => {
-  let component: HttpRequestManagerComponent;
-  let fixture: ComponentFixture<HttpRequestManagerComponent>;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({
-      declarations: [HttpRequestManagerComponent]
-    });
-    fixture = TestBed.createComponent(HttpRequestManagerComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});