ng-http-caching 15.2.4 → 16.0.1

package/lib/ng-http-caching.service.d.ts

@@ -1,213 +1,213 @@
-import { InjectionToken } from '@angular/core';
-import { HttpRequest, HttpResponse, HttpEvent } from '@angular/common/http';
-import { Observable } from 'rxjs/internal/Observable';
-import { NgHttpCachingStorageInterface } from './storage/ng-http-caching-storage.interface';
-import * as i0 from "@angular/core";
-export interface NgHttpCachingEntry<K = any, T = any> {
-    /**
-     * URL
-     */
-    url: string;
-    /**
-     * HttpResponse
-     */
-    response: HttpResponse<T>;
-    /**
-     * HttpRequest
-     */
-    request: HttpRequest<K>;
-    /**
-     * Timestam of add to cache time
-     */
-    addedTime: number;
-    /**
-     * Cache version
-     */
-    version: string;
-}
-export declare const NG_HTTP_CACHING_CONFIG: InjectionToken<NgHttpCachingConfig>;
-export declare enum NgHttpCachingStrategy {
-    /**
-     * All request are cacheable if HTTP method is into `allowedMethod`
-     */
-    ALLOW_ALL = "ALLOW_ALL",
-    /**
-     * Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`
-     */
-    DISALLOW_ALL = "DISALLOW_ALL"
-}
-export declare enum NgHttpCachingHeaders {
-    /**
-     * Request is cacheable if HTTP method is into `allowedMethod`
-     */
-    ALLOW_CACHE = "X-NG-HTTP-CACHING-ALLOW-CACHE",
-    /**
-     * Request isn't cacheable
-     */
-    DISALLOW_CACHE = "X-NG-HTTP-CACHING-DISALLOW-CACHE",
-    /**
-     * Specific cache lifetime for the request
-     */
-    LIFETIME = "X-NG-HTTP-CACHING-LIFETIME",
-    /**
-     * You can tag multiple request by adding this header with the same tag and
-     * using `NgHttpCachingService.clearCacheByTag(tag: string)` for delete all the tagged request
-     */
-    TAG = "X-NG-HTTP-CACHING-TAG"
-}
-export declare const NgHttpCachingHeadersList: NgHttpCachingHeaders[];
-export declare const NG_HTTP_CACHING_SECOND_IN_MS = 1000;
-export declare const NG_HTTP_CACHING_MINUTE_IN_MS: number;
-export declare const NG_HTTP_CACHING_HOUR_IN_MS: number;
-export declare const NG_HTTP_CACHING_DAY_IN_MS: number;
-export declare const NG_HTTP_CACHING_WEEK_IN_MS: number;
-export declare const NG_HTTP_CACHING_MONTH_IN_MS: number;
-export declare const NG_HTTP_CACHING_YEAR_IN_MS: number;
-export interface NgHttpCachingConfig {
-    /**
-     * Set the cache store. You can implement your custom store by implement the `NgHttpCachingStorageInterface` interface, eg.:
-     */
-    store?: NgHttpCachingStorageInterface;
-    /**
-     * Number of millisecond that a response is stored in the cache.
-     * You can set specific "lifetime" for each request by add the header `X-NG-HTTP-CACHING-LIFETIME` (see example below).
-     */
-    lifetime?: number;
-    /**
-     * Array of allowed HTTP methods to cache.
-     * You can allow multiple methods, eg.: `['GET', 'POST', 'PUT', 'DELETE', 'HEAD']` or
-     * allow all methods by: `['ALL']`. If `allowedMethod` is an empty array (`[]`), no response are cached.
-     * *Warning!* `NgHttpCaching` use the full url (url with query parameters) as unique key for the cached response,
-     * this is correct for the `GET` request but is _potentially_ wrong for other type of request (eg. `POST`, `PUT`).
-     * You can set a different "key" by customizing the `getKey` config method (see `getKey` section).
-     */
-    allowedMethod?: string[];
-    /**
-     * Set the cache strategy, possible strategies are:
-     * - `NgHttpCachingStrategy.ALLOW_ALL`: All request are cacheable if HTTP method is into `allowedMethod`;
-     * - `NgHttpCachingStrategy.DISALLOW_ALL`: Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`;
-     */
-    cacheStrategy?: NgHttpCachingStrategy;
-    /**
-     * Cache version. When you have a breaking change, change the version, and it'll delete the current cache automatically.
-     * The default value is Angular major version (eg. 13), in this way, the cache is invalitaded on every Angular upgrade.
-     */
-    version?: string;
-    /**
-     * If this function return `true` the request is expired and a new request is send to backend, if return `false` isn't expired.
-     * If the result is `undefined`, the normal behaviour is provided.
-     */
-    isExpired?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
-    /**
-     * If this function return `true` the request is cacheable, if return `false` isn't cacheable.
-     * If the result is `undefined`, the normal behaviour is provided.
-     */
-    isCacheable?: <K>(req: HttpRequest<K>) => boolean | undefined;
-    /**
-     * This function return the unique key (`string`) for store the response into the cache.
-     * If the result is `undefined`, the normal behaviour is provided.
-     */
-    getKey?: <K>(req: HttpRequest<K>) => string | undefined;
-    /**
-     * If this function return `true` the cache entry is valid and can be strored, if return `false` isn't valid.
-     * If the result is `undefined`, the normal behaviour is provided.
-     */
-    isValid?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
-}
-export interface NgHttpCachingDefaultConfig extends NgHttpCachingConfig {
-    store: NgHttpCachingStorageInterface;
-    lifetime: number;
-    allowedMethod: string[];
-    cacheStrategy: NgHttpCachingStrategy;
-    version: string;
-}
-export declare const NgHttpCachingConfigDefault: Readonly<NgHttpCachingDefaultConfig>;
-export declare class NgHttpCachingService {
-    private readonly queue;
-    private readonly config;
-    private gcLock;
-    private devMode;
-    constructor(config: Readonly<NgHttpCachingConfig>);
-    /**
-     * Return the config
-     */
-    getConfig(): Readonly<NgHttpCachingConfig>;
-    /**
-     * Return the queue map
-     */
-    getQueue(): Readonly<Map<string, Observable<HttpEvent<any>>>>;
-    /**
-     * Return the cache store
-     */
-    getStore(): Readonly<NgHttpCachingStorageInterface>;
-    /**
-     * Return response from cache
-     */
-    getFromCache<K, T>(req: HttpRequest<K>): Readonly<HttpResponse<T>> | undefined;
-    /**
-     * Add response to cache
-     */
-    addToCache<K, T>(req: HttpRequest<K>, res: HttpResponse<T>): boolean;
-    /**
-     * Delete response from cache
-     */
-    deleteFromCache<K>(req: HttpRequest<K>): boolean;
-    /**
-     * Clear the cache
-     */
-    clearCache(): void;
-    /**
-     * Clear the cache by key
-     */
-    clearCacheByKey(key: string): boolean;
-    /**
-     * Clear the cache by regex
-     */
-    clearCacheByRegex<K, T>(regex: RegExp): void;
-    /**
-     * Clear the cache by TAG
-     */
-    clearCacheByTag<K, T>(tag: string): void;
-    /**
-     * Run garbage collector (delete expired cache entry)
-     */
-    runGc<K, T>(): boolean;
-    /**
-     * Return true if cache entry is expired
-     */
-    isExpired<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
-    /**
-     * Return true if cache entry is valid for store in the cache
-     */
-    isValid<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
-    /**
-     * Return true if the request is cacheable
-     */
-    isCacheable<K>(req: HttpRequest<K>): boolean;
-    /**
-     * Return the cache key.
-     * Default key is http method plus url with query parameters, eg.:
-     * `GET@https://github.com/nigrosimone/ng-http-caching`
-     */
-    getKey<K>(req: HttpRequest<K>): string;
-    /**
-     * Return observable from cache
-     */
-    getFromQueue<K, T>(req: HttpRequest<K>): Observable<HttpEvent<T>> | undefined;
-    /**
-     * Add observable to cache
-     */
-    addToQueue<K, T>(req: HttpRequest<K>, obs: Observable<HttpEvent<T>>): void;
-    /**
-     * Delete observable from cache
-     */
-    deleteFromQueue<K>(req: HttpRequest<K>): boolean;
-    /**
-     * Recursively Object.freeze simple Javascript structures consisting of plain objects, arrays, and primitives.
-     * Make the data immutable.
-     * @returns immutable object
-     */
-    private deepFreeze;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgHttpCachingService, [{ optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgHttpCachingService>;
-}
+import { InjectionToken } from '@angular/core';
+import { HttpRequest, HttpResponse, HttpEvent } from '@angular/common/http';
+import { Observable } from 'rxjs/internal/Observable';
+import { NgHttpCachingStorageInterface } from './storage/ng-http-caching-storage.interface';
+import * as i0 from "@angular/core";
+export interface NgHttpCachingEntry<K = any, T = any> {
+    /**
+     * URL
+     */
+    url: string;
+    /**
+     * HttpResponse
+     */
+    response: HttpResponse<T>;
+    /**
+     * HttpRequest
+     */
+    request: HttpRequest<K>;
+    /**
+     * Timestam of add to cache time
+     */
+    addedTime: number;
+    /**
+     * Cache version
+     */
+    version: string;
+}
+export declare const NG_HTTP_CACHING_CONFIG: InjectionToken<NgHttpCachingConfig>;
+export declare enum NgHttpCachingStrategy {
+    /**
+     * All request are cacheable if HTTP method is into `allowedMethod`
+     */
+    ALLOW_ALL = "ALLOW_ALL",
+    /**
+     * Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`
+     */
+    DISALLOW_ALL = "DISALLOW_ALL"
+}
+export declare enum NgHttpCachingHeaders {
+    /**
+     * Request is cacheable if HTTP method is into `allowedMethod`
+     */
+    ALLOW_CACHE = "X-NG-HTTP-CACHING-ALLOW-CACHE",
+    /**
+     * Request isn't cacheable
+     */
+    DISALLOW_CACHE = "X-NG-HTTP-CACHING-DISALLOW-CACHE",
+    /**
+     * Specific cache lifetime for the request
+     */
+    LIFETIME = "X-NG-HTTP-CACHING-LIFETIME",
+    /**
+     * You can tag multiple request by adding this header with the same tag and
+     * using `NgHttpCachingService.clearCacheByTag(tag: string)` for delete all the tagged request
+     */
+    TAG = "X-NG-HTTP-CACHING-TAG"
+}
+export declare const NgHttpCachingHeadersList: NgHttpCachingHeaders[];
+export declare const NG_HTTP_CACHING_SECOND_IN_MS = 1000;
+export declare const NG_HTTP_CACHING_MINUTE_IN_MS: number;
+export declare const NG_HTTP_CACHING_HOUR_IN_MS: number;
+export declare const NG_HTTP_CACHING_DAY_IN_MS: number;
+export declare const NG_HTTP_CACHING_WEEK_IN_MS: number;
+export declare const NG_HTTP_CACHING_MONTH_IN_MS: number;
+export declare const NG_HTTP_CACHING_YEAR_IN_MS: number;
+export interface NgHttpCachingConfig {
+    /**
+     * Set the cache store. You can implement your custom store by implement the `NgHttpCachingStorageInterface` interface, eg.:
+     */
+    store?: NgHttpCachingStorageInterface;
+    /**
+     * Number of millisecond that a response is stored in the cache.
+     * You can set specific "lifetime" for each request by add the header `X-NG-HTTP-CACHING-LIFETIME` (see example below).
+     */
+    lifetime?: number;
+    /**
+     * Array of allowed HTTP methods to cache.
+     * You can allow multiple methods, eg.: `['GET', 'POST', 'PUT', 'DELETE', 'HEAD']` or
+     * allow all methods by: `['ALL']`. If `allowedMethod` is an empty array (`[]`), no response are cached.
+     * *Warning!* `NgHttpCaching` use the full url (url with query parameters) as unique key for the cached response,
+     * this is correct for the `GET` request but is _potentially_ wrong for other type of request (eg. `POST`, `PUT`).
+     * You can set a different "key" by customizing the `getKey` config method (see `getKey` section).
+     */
+    allowedMethod?: string[];
+    /**
+     * Set the cache strategy, possible strategies are:
+     * - `NgHttpCachingStrategy.ALLOW_ALL`: All request are cacheable if HTTP method is into `allowedMethod`;
+     * - `NgHttpCachingStrategy.DISALLOW_ALL`: Only the request with `X-NG-HTTP-CACHING-ALLOW-CACHE` header are cacheable if HTTP method is into `allowedMethod`;
+     */
+    cacheStrategy?: NgHttpCachingStrategy;
+    /**
+     * Cache version. When you have a breaking change, change the version, and it'll delete the current cache automatically.
+     * The default value is Angular major version (eg. 13), in this way, the cache is invalitaded on every Angular upgrade.
+     */
+    version?: string;
+    /**
+     * If this function return `true` the request is expired and a new request is send to backend, if return `false` isn't expired.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
+    isExpired?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
+    /**
+     * If this function return `true` the request is cacheable, if return `false` isn't cacheable.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
+    isCacheable?: <K>(req: HttpRequest<K>) => boolean | undefined;
+    /**
+     * This function return the unique key (`string`) for store the response into the cache.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
+    getKey?: <K>(req: HttpRequest<K>) => string | undefined;
+    /**
+     * If this function return `true` the cache entry is valid and can be strored, if return `false` isn't valid.
+     * If the result is `undefined`, the normal behaviour is provided.
+     */
+    isValid?: <K, T>(entry: NgHttpCachingEntry<K, T>) => boolean | undefined;
+}
+export interface NgHttpCachingDefaultConfig extends NgHttpCachingConfig {
+    store: NgHttpCachingStorageInterface;
+    lifetime: number;
+    allowedMethod: string[];
+    cacheStrategy: NgHttpCachingStrategy;
+    version: string;
+}
+export declare const NgHttpCachingConfigDefault: Readonly<NgHttpCachingDefaultConfig>;
+export declare class NgHttpCachingService {
+    private readonly queue;
+    private readonly config;
+    private gcLock;
+    private devMode;
+    constructor(config: Readonly<NgHttpCachingConfig>);
+    /**
+     * Return the config
+     */
+    getConfig(): Readonly<NgHttpCachingConfig>;
+    /**
+     * Return the queue map
+     */
+    getQueue(): Readonly<Map<string, Observable<HttpEvent<any>>>>;
+    /**
+     * Return the cache store
+     */
+    getStore(): Readonly<NgHttpCachingStorageInterface>;
+    /**
+     * Return response from cache
+     */
+    getFromCache<K, T>(req: HttpRequest<K>): Readonly<HttpResponse<T>> | undefined;
+    /**
+     * Add response to cache
+     */
+    addToCache<K, T>(req: HttpRequest<K>, res: HttpResponse<T>): boolean;
+    /**
+     * Delete response from cache
+     */
+    deleteFromCache<K>(req: HttpRequest<K>): boolean;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Clear the cache by key
+     */
+    clearCacheByKey(key: string): boolean;
+    /**
+     * Clear the cache by regex
+     */
+    clearCacheByRegex<K, T>(regex: RegExp): void;
+    /**
+     * Clear the cache by TAG
+     */
+    clearCacheByTag<K, T>(tag: string): void;
+    /**
+     * Run garbage collector (delete expired cache entry)
+     */
+    runGc<K, T>(): boolean;
+    /**
+     * Return true if cache entry is expired
+     */
+    isExpired<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
+    /**
+     * Return true if cache entry is valid for store in the cache
+     */
+    isValid<K, T>(entry: NgHttpCachingEntry<K, T>): boolean;
+    /**
+     * Return true if the request is cacheable
+     */
+    isCacheable<K>(req: HttpRequest<K>): boolean;
+    /**
+     * Return the cache key.
+     * Default key is http method plus url with query parameters, eg.:
+     * `GET@https://github.com/nigrosimone/ng-http-caching`
+     */
+    getKey<K>(req: HttpRequest<K>): string;
+    /**
+     * Return observable from cache
+     */
+    getFromQueue<K, T>(req: HttpRequest<K>): Observable<HttpEvent<T>> | undefined;
+    /**
+     * Add observable to cache
+     */
+    addToQueue<K, T>(req: HttpRequest<K>, obs: Observable<HttpEvent<T>>): void;
+    /**
+     * Delete observable from cache
+     */
+    deleteFromQueue<K>(req: HttpRequest<K>): boolean;
+    /**
+     * Recursively Object.freeze simple Javascript structures consisting of plain objects, arrays, and primitives.
+     * Make the data immutable.
+     * @returns immutable object
+     */
+    private deepFreeze;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgHttpCachingService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgHttpCachingService>;
+}

package/lib/storage/ng-http-caching-browser-storage.d.ts

@@ -1,18 +1,18 @@
-import { NgHttpCachingStorageInterface } from './ng-http-caching-storage.interface';
-import { NgHttpCachingEntry } from '../ng-http-caching.service';
-import { HttpRequest, HttpResponse } from '@angular/common/http';
-export declare const serializeRequest: (req: HttpRequest<any>) => string;
-export declare const serializeResponse: (res: HttpResponse<any>) => string;
-export declare const deserializeRequest: <T = any>(req: string) => HttpRequest<T>;
-export declare const deserializeResponse: <T = any>(res: string) => HttpResponse<T>;
-export declare class NgHttpCachingBrowserStorage implements NgHttpCachingStorageInterface {
-    private storage;
-    constructor(storage: Storage);
-    get size(): number;
-    clear(): void;
-    delete(key: string): boolean;
-    forEach(callbackfn: (value: NgHttpCachingEntry, key: string) => void): void;
-    get(key: string): Readonly<NgHttpCachingEntry> | undefined;
-    has(key: string): boolean;
-    set(key: string, value: NgHttpCachingEntry): void;
-}
+import { NgHttpCachingStorageInterface } from './ng-http-caching-storage.interface';
+import { NgHttpCachingEntry } from '../ng-http-caching.service';
+import { HttpRequest, HttpResponse } from '@angular/common/http';
+export declare const serializeRequest: (req: HttpRequest<any>) => string;
+export declare const serializeResponse: (res: HttpResponse<any>) => string;
+export declare const deserializeRequest: <T = any>(req: string) => HttpRequest<T>;
+export declare const deserializeResponse: <T = any>(res: string) => HttpResponse<T>;
+export declare class NgHttpCachingBrowserStorage implements NgHttpCachingStorageInterface {
+    private storage;
+    constructor(storage: Storage);
+    get size(): number;
+    clear(): void;
+    delete(key: string): boolean;
+    forEach(callbackfn: (value: NgHttpCachingEntry, key: string) => void): void;
+    get(key: string): Readonly<NgHttpCachingEntry> | undefined;
+    has(key: string): boolean;
+    set(key: string, value: NgHttpCachingEntry): void;
+}

package/lib/storage/ng-http-caching-local-storage.d.ts

@@ -1,4 +1,4 @@
-import { NgHttpCachingBrowserStorage } from './ng-http-caching-browser-storage';
-export declare class NgHttpCachingLocalStorage extends NgHttpCachingBrowserStorage {
-    constructor();
-}
+import { NgHttpCachingBrowserStorage } from './ng-http-caching-browser-storage';
+export declare class NgHttpCachingLocalStorage extends NgHttpCachingBrowserStorage {
+    constructor();
+}

package/lib/storage/ng-http-caching-memory-storage.d.ts

@@ -1,12 +1,12 @@
-import { NgHttpCachingStorageInterface } from './ng-http-caching-storage.interface';
-import { NgHttpCachingEntry } from '../ng-http-caching.service';
-export declare class NgHttpCachingMemoryStorage implements NgHttpCachingStorageInterface {
-    get size(): number;
-    private store;
-    clear(): void;
-    delete(key: string): boolean;
-    forEach<K, T>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
-    get<K, T>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
-    has(key: string): boolean;
-    set<K, T>(key: string, value: NgHttpCachingEntry<K, T>): void;
-}
+import { NgHttpCachingStorageInterface } from './ng-http-caching-storage.interface';
+import { NgHttpCachingEntry } from '../ng-http-caching.service';
+export declare class NgHttpCachingMemoryStorage implements NgHttpCachingStorageInterface {
+    get size(): number;
+    private store;
+    clear(): void;
+    delete(key: string): boolean;
+    forEach<K, T>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
+    get<K, T>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
+    has(key: string): boolean;
+    set<K, T>(key: string, value: NgHttpCachingEntry<K, T>): void;
+}

package/lib/storage/ng-http-caching-session-storage.d.ts

@@ -1,4 +1,4 @@
-import { NgHttpCachingBrowserStorage } from './ng-http-caching-browser-storage';
-export declare class NgHttpCachingSessionStorage extends NgHttpCachingBrowserStorage {
-    constructor();
-}
+import { NgHttpCachingBrowserStorage } from './ng-http-caching-browser-storage';
+export declare class NgHttpCachingSessionStorage extends NgHttpCachingBrowserStorage {
+    constructor();
+}

package/lib/storage/ng-http-caching-storage.interface.d.ts

@@ -1,31 +1,31 @@
-import { NgHttpCachingEntry } from '../ng-http-caching.service';
-export interface NgHttpCachingStorageInterface {
-    /**
-     * The number of cached entries.
-     */
-    readonly size: number;
-    /**
-     * Clear the cache.
-     */
-    clear(): void;
-    /**
-     * Delete the chache entry for the provided key.
-     */
-    delete(key: string): boolean;
-    /**
-     * The forEach() method executes a provided function once for each chache entry.
-     */
-    forEach<K = any, T = any>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
-    /**
-     * Return the chache entry for the provided key.
-     */
-    get<K = any, T = any>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
-    /**
-     * Return true if the cache entry exists the provided key.
-     */
-    has(key: string): boolean;
-    /**
-     * Set the chache entry for the provided key.
-     */
-    set<K = any, T = any>(key: string, value: NgHttpCachingEntry<K, T>): void;
-}
+import { NgHttpCachingEntry } from '../ng-http-caching.service';
+export interface NgHttpCachingStorageInterface {
+    /**
+     * The number of cached entries.
+     */
+    readonly size: number;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Delete the chache entry for the provided key.
+     */
+    delete(key: string): boolean;
+    /**
+     * The forEach() method executes a provided function once for each chache entry.
+     */
+    forEach<K = any, T = any>(callbackfn: (value: NgHttpCachingEntry<K, T>, key: string) => void): void;
+    /**
+     * Return the chache entry for the provided key.
+     */
+    get<K = any, T = any>(key: string): Readonly<NgHttpCachingEntry<K, T>> | undefined;
+    /**
+     * Return true if the cache entry exists the provided key.
+     */
+    has(key: string): boolean;
+    /**
+     * Set the chache entry for the provided key.
+     */
+    set<K = any, T = any>(key: string, value: NgHttpCachingEntry<K, T>): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-http-caching",
-  "version": "15.2.4",
+  "version": "16.0.1",
   "description": "Cache for HTTP requests in Angular application.",
   "repository": {
     "type": "git",
@@ -26,17 +26,13 @@
   },
   "homepage": "https://github.com/nigrosimone/ng-http-caching",
   "peerDependencies": {
-    "@angular/common": "^15.0.0",
-    "@angular/core": "^15.0.0"
+    "@angular/common": ">15.0.0",
+    "@angular/core": ">15.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "module": "fesm2015/ng-http-caching.mjs",
-  "es2020": "fesm2020/ng-http-caching.mjs",
-  "esm2020": "esm2020/ng-http-caching.mjs",
-  "fesm2020": "fesm2020/ng-http-caching.mjs",
-  "fesm2015": "fesm2015/ng-http-caching.mjs",
+  "module": "fesm2022/ng-http-caching.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
@@ -44,11 +40,9 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/ng-http-caching.mjs",
-      "es2020": "./fesm2020/ng-http-caching.mjs",
-      "es2015": "./fesm2015/ng-http-caching.mjs",
-      "node": "./fesm2015/ng-http-caching.mjs",
-      "default": "./fesm2020/ng-http-caching.mjs"
+      "esm2022": "./esm2022/ng-http-caching.mjs",
+      "esm": "./esm2022/ng-http-caching.mjs",
+      "default": "./fesm2022/ng-http-caching.mjs"
     }
   },
   "sideEffects": false

package/public-api.d.ts

@@ -1,8 +1,8 @@
-export * from './lib/ng-http-caching-interceptor.service';
-export * from './lib/ng-http-caching.service';
-export * from './lib/ng-http-caching.module';
-export * from './lib/storage/ng-http-caching-storage.interface';
-export * from './lib/storage/ng-http-caching-memory-storage';
-export * from './lib/storage/ng-http-caching-local-storage';
-export * from './lib/storage/ng-http-caching-session-storage';
-export * from './lib/storage/ng-http-caching-browser-storage';
+export * from './lib/ng-http-caching-interceptor.service';
+export * from './lib/ng-http-caching.service';
+export * from './lib/ng-http-caching.module';
+export * from './lib/storage/ng-http-caching-storage.interface';
+export * from './lib/storage/ng-http-caching-memory-storage';
+export * from './lib/storage/ng-http-caching-local-storage';
+export * from './lib/storage/ng-http-caching-session-storage';
+export * from './lib/storage/ng-http-caching-browser-storage';