@merkur/plugin-http-cache 0.38.0 → 0.40.0

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://merkur.js.org/docs/getting-started" title="Getting started">
-    <img src="https://raw.githubusercontent.com/mjancarik/merkur/master/images/merkur-illustration.png" width="100px" height="100px" alt="Merkur illustration"/>
+    <img src="https://raw.githubusercontent.com/mjancarik/merkur/master/images/merkur-logo.png" width="100px" height="100px" alt="Merkur illustration"/>
   </a>
 </p>
 

package/lib/index.cjs

@@ -48,21 +48,21 @@ class CacheEntry {
   serialize() {
     return {
       value: this.value,
-      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl,
+      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl
     };
   }
 }
 
 const DEV = 'development';
-const ENV =
-  typeof process !== 'undefined' && process && process.env
-    ? process.env.NODE_ENV
-    : DEV;
-
-function getCacheKey({ method, url, body, query }) {
+const ENV = typeof process !== 'undefined' && process && process.env ? process.env.NODE_ENV : DEV;
+function getCacheKey({
+  method,
+  url,
+  body,
+  query
+}) {
   const data = ~['GET', 'HEAD'].indexOf(method) ? query : body;
   let dataQuery = '';
-
   if (data) {
     try {
       dataQuery = JSON.stringify(data).replace(/<\/script/gi, '<\\/script');
@@ -72,133 +72,121 @@ function getCacheKey({ method, url, body, query }) {
   }
   return `${method}:${url}?${dataQuery}`;
 }
-
 function httpCachePlugin() {
   return {
     async setup(widget) {
       if (ENV === DEV && !widget.$in.httpClient) {
-        throw new Error(
-          'You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache',
-        );
+        throw new Error('You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache');
       }
-
       core.assignMissingKeys(widget, httpCacheAPI());
-
       widget.$in.httpClient.cache = new Map();
-
       return widget;
     },
     async create(widget) {
-      const { useCache, transferServerCache, ttl } =
-        widget.$in.httpClient.defaultConfig;
-
+      const {
+        useCache,
+        transferServerCache,
+        ttl
+      } = widget.$in.httpClient.defaultConfig;
       core.bindWidgetToFunctions(widget, widget.httpCache);
-
       pluginHttpClient.setDefaultConfig(widget, {
         useCache: useCache ?? true,
         transferServerCache: transferServerCache ?? false,
-        ttl: ttl ?? 60000,
+        ttl: ttl ?? 60000
       });
-
       if (transferServerCache) {
         core.hookMethod(widget, 'info', infoHook);
         if (widget.$httpCache) {
           widget.httpCache.deserialize(widget.$httpCache);
         }
       }
-
       return widget;
-    },
+    }
   };
 }
-
 function cacheInTransformer() {
   return {
     async transformResponse(widget, request, response) {
       if (request.useCache && !response.cached) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = new CacheEntry(pluginHttpClient.copyResponse(response), request.ttl);
         cache.set(getCacheKey(request), cacheEntry);
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function cacheOutTransformer() {
   return {
     async transformRequest(widget, request, response) {
       if (request.useCache) {
         const cachedResponse = widget.httpCache.get(getCacheKey(request));
-
         if (cachedResponse) {
-          return [request, { ...cachedResponse, cached: true }];
+          return [request, {
+            ...cachedResponse,
+            cached: true
+          }];
         }
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function httpCacheAPI() {
   return {
     httpCache: {
       get(widget, key) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = cache.get(key);
-
-        return cacheEntry && !cacheEntry.isExpired()
-          ? pluginHttpClient.copyResponse(cacheEntry.value)
-          : null;
+        return cacheEntry && !cacheEntry.isExpired() ? pluginHttpClient.copyResponse(cacheEntry.value) : null;
       },
       serialize(widget) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const serializedData = {};
-
         for (const key of cache.keys()) {
           const entry = cache.get(key);
-
           if (entry instanceof CacheEntry) {
             serializedData[key] = entry.serialize();
           }
         }
-
-        return JSON.stringify(serializedData).replace(
-          /<\/script/gi,
-          '<\\/script',
-        );
+        return JSON.stringify(serializedData).replace(/<\/script/gi, '<\\/script');
       },
-
       deserialize(widget, serializedData) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         let parsedData = {};
-
         try {
           parsedData = JSON.parse(serializedData);
         } catch (error) {
           console.warn('Failed to parse http cache data', error);
         }
-
         for (const key of Object.keys(parsedData)) {
-          let { value, ttl } = parsedData[key];
-
+          let {
+            value,
+            ttl
+          } = parsedData[key];
           if (ttl === 'Infinity') {
             ttl = Infinity;
           }
-
           cache.set(key, new CacheEntry(value, ttl));
         }
-      },
-    },
+      }
+    }
   };
 }
-
 async function infoHook(widget, originalInfoFn, ...rest) {
   const originalInfo = await originalInfoFn(...rest);
-
-  return { ...originalInfo, $httpCache: widget.httpCache.serialize() };
+  return {
+    ...originalInfo,
+    $httpCache: widget.httpCache.serialize()
+  };
 }
 
 exports.cacheInTransformer = cacheInTransformer;

package/lib/index.js

@@ -48,21 +48,21 @@ class CacheEntry {
   serialize() {
     return {
       value: this.value,
-      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl,
+      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl
     };
   }
 }
 
 const DEV = 'development';
-const ENV =
-  typeof process !== 'undefined' && process && process.env
-    ? process.env.NODE_ENV
-    : DEV;
-
-function getCacheKey({ method, url, body, query }) {
+const ENV = typeof process !== 'undefined' && process && process.env ? process.env.NODE_ENV : DEV;
+function getCacheKey({
+  method,
+  url,
+  body,
+  query
+}) {
   const data = ~['GET', 'HEAD'].indexOf(method) ? query : body;
   let dataQuery = '';
-
   if (data) {
     try {
       dataQuery = JSON.stringify(data).replace(/<\/script/gi, '<\\/script');
@@ -72,133 +72,121 @@ function getCacheKey({ method, url, body, query }) {
   }
   return `${method}:${url}?${dataQuery}`;
 }
-
 function httpCachePlugin() {
   return {
     async setup(widget) {
       if (ENV === DEV && !widget.$in.httpClient) {
-        throw new Error(
-          'You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache',
-        );
+        throw new Error('You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache');
       }
-
       core.assignMissingKeys(widget, httpCacheAPI());
-
       widget.$in.httpClient.cache = new Map();
-
       return widget;
     },
     async create(widget) {
-      const { useCache, transferServerCache, ttl } =
-        widget.$in.httpClient.defaultConfig;
-
+      const {
+        useCache,
+        transferServerCache,
+        ttl
+      } = widget.$in.httpClient.defaultConfig;
       core.bindWidgetToFunctions(widget, widget.httpCache);
-
       pluginHttpClient.setDefaultConfig(widget, {
         useCache: useCache ?? true,
         transferServerCache: transferServerCache ?? false,
-        ttl: ttl ?? 60000,
+        ttl: ttl ?? 60000
       });
-
       if (transferServerCache) {
         core.hookMethod(widget, 'info', infoHook);
         if (widget.$httpCache) {
           widget.httpCache.deserialize(widget.$httpCache);
         }
       }
-
       return widget;
-    },
+    }
   };
 }
-
 function cacheInTransformer() {
   return {
     async transformResponse(widget, request, response) {
       if (request.useCache && !response.cached) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = new CacheEntry(pluginHttpClient.copyResponse(response), request.ttl);
         cache.set(getCacheKey(request), cacheEntry);
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function cacheOutTransformer() {
   return {
     async transformRequest(widget, request, response) {
       if (request.useCache) {
         const cachedResponse = widget.httpCache.get(getCacheKey(request));
-
         if (cachedResponse) {
-          return [request, { ...cachedResponse, cached: true }];
+          return [request, {
+            ...cachedResponse,
+            cached: true
+          }];
         }
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function httpCacheAPI() {
   return {
     httpCache: {
       get(widget, key) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = cache.get(key);
-
-        return cacheEntry && !cacheEntry.isExpired()
-          ? pluginHttpClient.copyResponse(cacheEntry.value)
-          : null;
+        return cacheEntry && !cacheEntry.isExpired() ? pluginHttpClient.copyResponse(cacheEntry.value) : null;
       },
       serialize(widget) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const serializedData = {};
-
         for (const key of cache.keys()) {
           const entry = cache.get(key);
-
           if (entry instanceof CacheEntry) {
             serializedData[key] = entry.serialize();
           }
         }
-
-        return JSON.stringify(serializedData).replace(
-          /<\/script/gi,
-          '<\\/script',
-        );
+        return JSON.stringify(serializedData).replace(/<\/script/gi, '<\\/script');
       },
-
       deserialize(widget, serializedData) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         let parsedData = {};
-
         try {
           parsedData = JSON.parse(serializedData);
         } catch (error) {
           console.warn('Failed to parse http cache data', error);
         }
-
         for (const key of Object.keys(parsedData)) {
-          let { value, ttl } = parsedData[key];
-
+          let {
+            value,
+            ttl
+          } = parsedData[key];
           if (ttl === 'Infinity') {
             ttl = Infinity;
           }
-
           cache.set(key, new CacheEntry(value, ttl));
         }
-      },
-    },
+      }
+    }
   };
 }
-
 async function infoHook(widget, originalInfoFn, ...rest) {
   const originalInfo = await originalInfoFn(...rest);
-
-  return { ...originalInfo, $httpCache: widget.httpCache.serialize() };
+  return {
+    ...originalInfo,
+    $httpCache: widget.httpCache.serialize()
+  };
 }
 
 exports.cacheInTransformer = cacheInTransformer;

package/lib/index.mjs

@@ -46,21 +46,21 @@ class CacheEntry {
   serialize() {
     return {
       value: this.value,
-      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl,
+      ttl: this._ttl === Infinity ? 'Infinity' : this._ttl
     };
   }
 }
 
 const DEV = 'development';
-const ENV =
-  typeof process !== 'undefined' && process && process.env
-    ? process.env.NODE_ENV
-    : DEV;
-
-function getCacheKey({ method, url, body, query }) {
+const ENV = typeof process !== 'undefined' && process && process.env ? process.env.NODE_ENV : DEV;
+function getCacheKey({
+  method,
+  url,
+  body,
+  query
+}) {
   const data = ~['GET', 'HEAD'].indexOf(method) ? query : body;
   let dataQuery = '';
-
   if (data) {
     try {
       dataQuery = JSON.stringify(data).replace(/<\/script/gi, '<\\/script');
@@ -70,133 +70,121 @@ function getCacheKey({ method, url, body, query }) {
   }
   return `${method}:${url}?${dataQuery}`;
 }
-
 function httpCachePlugin() {
   return {
     async setup(widget) {
       if (ENV === DEV && !widget.$in.httpClient) {
-        throw new Error(
-          'You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache',
-        );
+        throw new Error('You must setup plugin @merkur/plugin-http-client before @merkur/plugin-http-cache');
       }
-
       assignMissingKeys(widget, httpCacheAPI());
-
       widget.$in.httpClient.cache = new Map();
-
       return widget;
     },
     async create(widget) {
-      const { useCache, transferServerCache, ttl } =
-        widget.$in.httpClient.defaultConfig;
-
+      const {
+        useCache,
+        transferServerCache,
+        ttl
+      } = widget.$in.httpClient.defaultConfig;
       bindWidgetToFunctions(widget, widget.httpCache);
-
       setDefaultConfig(widget, {
         useCache: useCache ?? true,
         transferServerCache: transferServerCache ?? false,
-        ttl: ttl ?? 60000,
+        ttl: ttl ?? 60000
       });
-
       if (transferServerCache) {
         hookMethod(widget, 'info', infoHook);
         if (widget.$httpCache) {
           widget.httpCache.deserialize(widget.$httpCache);
         }
       }
-
       return widget;
-    },
+    }
   };
 }
-
 function cacheInTransformer() {
   return {
     async transformResponse(widget, request, response) {
       if (request.useCache && !response.cached) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = new CacheEntry(copyResponse(response), request.ttl);
         cache.set(getCacheKey(request), cacheEntry);
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function cacheOutTransformer() {
   return {
     async transformRequest(widget, request, response) {
       if (request.useCache) {
         const cachedResponse = widget.httpCache.get(getCacheKey(request));
-
         if (cachedResponse) {
-          return [request, { ...cachedResponse, cached: true }];
+          return [request, {
+            ...cachedResponse,
+            cached: true
+          }];
         }
       }
-
       return [request, response];
-    },
+    }
   };
 }
-
 function httpCacheAPI() {
   return {
     httpCache: {
       get(widget, key) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const cacheEntry = cache.get(key);
-
-        return cacheEntry && !cacheEntry.isExpired()
-          ? copyResponse(cacheEntry.value)
-          : null;
+        return cacheEntry && !cacheEntry.isExpired() ? copyResponse(cacheEntry.value) : null;
       },
       serialize(widget) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         const serializedData = {};
-
         for (const key of cache.keys()) {
           const entry = cache.get(key);
-
           if (entry instanceof CacheEntry) {
             serializedData[key] = entry.serialize();
           }
         }
-
-        return JSON.stringify(serializedData).replace(
-          /<\/script/gi,
-          '<\\/script',
-        );
+        return JSON.stringify(serializedData).replace(/<\/script/gi, '<\\/script');
       },
-
       deserialize(widget, serializedData) {
-        const { cache } = widget.$in.httpClient;
+        const {
+          cache
+        } = widget.$in.httpClient;
         let parsedData = {};
-
         try {
           parsedData = JSON.parse(serializedData);
         } catch (error) {
           console.warn('Failed to parse http cache data', error);
         }
-
         for (const key of Object.keys(parsedData)) {
-          let { value, ttl } = parsedData[key];
-
+          let {
+            value,
+            ttl
+          } = parsedData[key];
           if (ttl === 'Infinity') {
             ttl = Infinity;
           }
-
           cache.set(key, new CacheEntry(value, ttl));
         }
-      },
-    },
+      }
+    }
   };
 }
-
 async function infoHook(widget, originalInfoFn, ...rest) {
   const originalInfo = await originalInfoFn(...rest);
-
-  return { ...originalInfo, $httpCache: widget.httpCache.serialize() };
+  return {
+    ...originalInfo,
+    $httpCache: widget.httpCache.serialize()
+  };
 }
 
 export { cacheInTransformer, cacheOutTransformer, getCacheKey, httpCachePlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merkur/plugin-http-cache",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Merkur plugin for maintaining http requests cache.",
   "main": "lib/index",
   "module": "lib/index",
@@ -24,8 +24,7 @@
     "preversion": "npm test",
     "test": "jest --no-watchman -c ./jest.config.js",
     "test:es:version": "es-check es11 ./lib/index.mjs --module && es-check es9 ./lib/index.es9.mjs --module && es-check es9 ./lib/index.es9.cjs --module",
-    "build": "rollup -c rollup.config.mjs",
-    "prepare": "npm run build"
+    "build": "rollup -c rollup.config.mjs"
   },
   "repository": {
     "type": "git",
@@ -48,13 +47,13 @@
   },
   "homepage": "https://merkur.js.org/",
   "devDependencies": {
-    "@merkur/core": "^0.38.0",
-    "@merkur/plugin-component": "^0.38.0",
-    "@merkur/plugin-http-client": "^0.38.0"
+    "@merkur/core": "^0.40.0",
+    "@merkur/plugin-component": "^0.40.0",
+    "@merkur/plugin-http-client": "^0.40.0"
   },
   "peerDependencies": {
     "@merkur/core": "*",
     "@merkur/plugin-http-client": "*"
   },
-  "gitHead": "a6e379c0cb887898e34465dc3db9231feb68e6a5"
+  "gitHead": "a7bf45d46a5c0fca7130ae6a86e1cd94e5894ca2"
 }