refactor: made some methods static and public

src/cache/create.ts

@@ -30,7 +30,7 @@ export function useCache(
 ): AxiosCacheInstance {
   const axiosCache = axios as AxiosCacheInstance;
 
-  axiosCache.storage = storage || new MemoryAxiosStorage({});
+  axiosCache.storage = storage || new MemoryAxiosStorage();
   axiosCache.generateKey = generateKey || defaultKeyGenerator;
   axiosCache.waiting = waiting || {};
   axiosCache.headerInterpreter = headerInterpreter || defaultHeaderInterpreter;

src/interceptors/request.ts

@@ -20,11 +20,11 @@ export class CacheRequestInterceptor<D>
 {
   constructor(readonly axios: AxiosCacheInstance) {}
 
-  public use = (): void => {
+  readonly use = (): void => {
     this.axios.interceptors.request.use(this.onFulfilled);
   };
 
-  public onFulfilled = async (
+  readonly onFulfilled = async (
     config: CacheRequestConfig<D>
   ): Promise<CacheRequestConfig<D>> => {
     if (config.cache === false) {
@@ -36,7 +36,7 @@ export class CacheRequestInterceptor<D>
 
     if (
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      !this.isMethodAllowed(config.method!, config.cache)
+      !CacheRequestInterceptor.isMethodAllowed(config.method!, config.cache)
     ) {
       return config;
     }
@@ -76,7 +76,7 @@ export class CacheRequestInterceptor<D>
 
       if (cache.state === 'stale') {
         //@ts-expect-error type infer couldn't resolve this
-        this.setRevalidationHeaders(cache, config);
+        CacheRequestInterceptor.setRevalidationHeaders(cache, config);
       }
 
       config.validateStatus = CacheRequestInterceptor.createValidateStatus(
@@ -126,7 +126,7 @@ export class CacheRequestInterceptor<D>
     return config;
   };
 
-  private isMethodAllowed = (
+  static readonly isMethodAllowed = (
     method: Method,
     properties: Partial<CacheProperties>
   ): boolean => {
@@ -141,7 +141,7 @@ export class CacheRequestInterceptor<D>
     return false;
   };
 
-  private setRevalidationHeaders = (
+  static readonly setRevalidationHeaders = <D>(
     cache: StaleStorageValue,
     config: CacheRequestConfig<D> & { cache: Partial<CacheProperties> }
   ): void => {
@@ -170,7 +170,9 @@ export class CacheRequestInterceptor<D>
    * Creates a new validateStatus function that will use the one
    * already used and also accept status code 304.
    */
-  static createValidateStatus = (oldValidate?: AxiosRequestConfig['validateStatus']) => {
+  static readonly createValidateStatus = (
+    oldValidate?: AxiosRequestConfig['validateStatus']
+  ) => {
     return (status: number): boolean => {
       return oldValidate
         ? oldValidate(status) || status === 304

src/storage/browser.ts

@@ -3,7 +3,7 @@ import { AxiosStorage } from './storage';
 import type { StorageValue } from './types';
 
 export class BrowserAxiosStorage extends AxiosStorage {
-  public static DEFAULT_KEY_PREFIX = 'a-c-i';
+  public static readonly DEFAULT_KEY_PREFIX = 'a-c-i';
 
   /**
    * @param storage Any browser storage, like sessionStorage or localStorage
@@ -16,16 +16,16 @@ export class BrowserAxiosStorage extends AxiosStorage {
     super();
   }
 
-  public find = async (key: string): Promise<StorageValue> => {
+  readonly find = async (key: string): Promise<StorageValue> => {
     const json = this.storage.getItem(`${this.prefix}:${key}`);
     return json ? JSON.parse(json) : { state: 'empty' };
   };
 
-  public set = async (key: string, value: NotEmptyStorageValue): Promise<void> => {
+  readonly set = async (key: string, value: NotEmptyStorageValue): Promise<void> => {
     return this.storage.setItem(`${this.prefix}:${key}`, JSON.stringify(value));
   };
 
-  public remove = async (key: string): Promise<void> => {
+  readonly remove = async (key: string): Promise<void> => {
     return this.storage.removeItem(`${this.prefix}:${key}`);
   };
 }

src/storage/memory.ts

@@ -6,15 +6,15 @@ export class MemoryAxiosStorage extends AxiosStorage {
     super();
   }
 
-  public find = async (key: string): Promise<StorageValue> => {
+  readonly find = async (key: string): Promise<StorageValue> => {
     return this.storage[key] || { state: 'empty' };
   };
 
-  public set = async (key: string, value: NotEmptyStorageValue): Promise<void> => {
+  readonly set = async (key: string, value: NotEmptyStorageValue): Promise<void> => {
     this.storage[key] = value;
   };
 
-  public remove = async (key: string): Promise<void> => {
+  readonly remove = async (key: string): Promise<void> => {
     delete this.storage[key];
   };
 }

src/storage/storage.ts

@@ -7,21 +7,21 @@ export abstract class AxiosStorage {
    * Returns the cached value for the given key. The get method is
    * what takes care to invalidate the values.
    */
-  protected abstract find: (key: string) => Promise<StorageValue>;
+  protected abstract readonly find: (key: string) => Promise<StorageValue>;
 
   /**
    * Sets a new value for the given key
    *
    * Use CacheStorage.remove(key) to define a key to 'empty' state.
    */
-  public abstract set: (key: string, value: NotEmptyStorageValue) => Promise<void>;
+  abstract readonly set: (key: string, value: NotEmptyStorageValue) => Promise<void>;
 
   /**
    * Removes the value for the given key
    */
-  public abstract remove: (key: string) => Promise<void>;
+  abstract readonly remove: (key: string) => Promise<void>;
 
-  public get = async (key: string): Promise<StorageValue> => {
+  readonly get = async (key: string): Promise<StorageValue> => {
     const value = await this.find(key);
 
     if (
@@ -50,7 +50,7 @@ export abstract class AxiosStorage {
   /**
    * Returns true if a invalid cache should still be kept
    */
-  static keepIfStale = ({ data }: CachedStorageValue): boolean => {
+  static readonly keepIfStale = ({ data }: CachedStorageValue): boolean => {
     if (data?.headers) {
       return (
         Header.ETag in data.headers ||