@tramvai/pwa-recipes 2.121.2

package/lib/cache-application-fonts.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationAssetsCacheOptions } from './types';
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/googleFontsCache.ts
+ */
+export declare function cacheApplicationFonts({ precacheManifest, maxEntries, maxAgeSeconds, strategy: Strategy, }?: ApplicationAssetsCacheOptions): void;

package/lib/cache-application-fonts.es.js

@@ -0,0 +1,32 @@
+import { Route, registerRoute } from 'workbox-routing';
+import { StaleWhileRevalidate } from 'workbox-strategies';
+import { ExpirationPlugin } from 'workbox-expiration';
+import { CacheableResponsePlugin } from 'workbox-cacheable-response';
+import { warmStrategyCache } from './warm-strategy-cache.es.js';
+import { isApplicationAsset } from './routing.es.js';
+import { createCacheKey } from './cache.es.js';
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/googleFontsCache.ts
+ */
+function cacheApplicationFonts({ precacheManifest = [], maxEntries = 30, maxAgeSeconds = 90 * 24 * 60 * 60, strategy: Strategy = StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: createCacheKey('fonts'),
+        plugins: [
+            new CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new Route(({ request }) => {
+        return isApplicationAsset(request) && request.destination === 'font';
+    }, strategy);
+    warmStrategyCache({ urls: precacheManifest, type: 'font', strategy });
+    registerRoute(route);
+}
+
+export { cacheApplicationFonts };

package/lib/cache-application-fonts.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var workboxRouting = require('workbox-routing');
+var workboxStrategies = require('workbox-strategies');
+var workboxExpiration = require('workbox-expiration');
+var workboxCacheableResponse = require('workbox-cacheable-response');
+var warmStrategyCache = require('./warm-strategy-cache.js');
+var routing = require('./routing.js');
+var cache = require('./cache.js');
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/googleFontsCache.ts
+ */
+function cacheApplicationFonts({ precacheManifest = [], maxEntries = 30, maxAgeSeconds = 90 * 24 * 60 * 60, strategy: Strategy = workboxStrategies.StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: cache.createCacheKey('fonts'),
+        plugins: [
+            new workboxCacheableResponse.CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new workboxExpiration.ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new workboxRouting.Route(({ request }) => {
+        return routing.isApplicationAsset(request) && request.destination === 'font';
+    }, strategy);
+    warmStrategyCache.warmStrategyCache({ urls: precacheManifest, type: 'font', strategy });
+    workboxRouting.registerRoute(route);
+}
+
+exports.cacheApplicationFonts = cacheApplicationFonts;

package/lib/cache-application-images.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationAssetsCacheOptions } from './types';
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/imageCache.ts
+ */
+export declare function cacheApplicationImages({ precacheManifest, maxEntries, maxAgeSeconds, strategy: Strategy, }?: ApplicationAssetsCacheOptions): void;

package/lib/cache-application-images.es.js

@@ -0,0 +1,32 @@
+import { Route, registerRoute } from 'workbox-routing';
+import { StaleWhileRevalidate } from 'workbox-strategies';
+import { ExpirationPlugin } from 'workbox-expiration';
+import { CacheableResponsePlugin } from 'workbox-cacheable-response';
+import { warmStrategyCache } from './warm-strategy-cache.es.js';
+import { isApplicationAsset } from './routing.es.js';
+import { createCacheKey } from './cache.es.js';
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/imageCache.ts
+ */
+function cacheApplicationImages({ precacheManifest = [], maxEntries = 60, maxAgeSeconds = 30 * 24 * 60 * 60, strategy: Strategy = StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: createCacheKey('images'),
+        plugins: [
+            new CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new Route(({ request }) => {
+        return isApplicationAsset(request) && request.destination === 'image';
+    }, strategy);
+    warmStrategyCache({ urls: precacheManifest, type: 'image', strategy });
+    registerRoute(route);
+}
+
+export { cacheApplicationImages };

package/lib/cache-application-images.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var workboxRouting = require('workbox-routing');
+var workboxStrategies = require('workbox-strategies');
+var workboxExpiration = require('workbox-expiration');
+var workboxCacheableResponse = require('workbox-cacheable-response');
+var warmStrategyCache = require('./warm-strategy-cache.js');
+var routing = require('./routing.js');
+var cache = require('./cache.js');
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/imageCache.ts
+ */
+function cacheApplicationImages({ precacheManifest = [], maxEntries = 60, maxAgeSeconds = 30 * 24 * 60 * 60, strategy: Strategy = workboxStrategies.StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: cache.createCacheKey('images'),
+        plugins: [
+            new workboxCacheableResponse.CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new workboxExpiration.ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new workboxRouting.Route(({ request }) => {
+        return routing.isApplicationAsset(request) && request.destination === 'image';
+    }, strategy);
+    warmStrategyCache.warmStrategyCache({ urls: precacheManifest, type: 'image', strategy });
+    workboxRouting.registerRoute(route);
+}
+
+exports.cacheApplicationImages = cacheApplicationImages;

package/lib/cache-application-pages.d.ts

@@ -0,0 +1,7 @@
+import type { ApplicationAssetsCacheOptions } from './types';
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/pageCache.ts
+ */
+export declare function cacheApplicationPages({ precacheManifest, maxEntries, maxAgeSeconds, networkTimeoutSeconds, strategy: Strategy, }?: ApplicationAssetsCacheOptions & {
+    networkTimeoutSeconds?: number;
+}): void;

package/lib/cache-application-pages.es.js

@@ -0,0 +1,34 @@
+import { Route, registerRoute } from 'workbox-routing';
+import { NetworkFirst } from 'workbox-strategies';
+import { ExpirationPlugin } from 'workbox-expiration';
+import { CacheableResponsePlugin } from 'workbox-cacheable-response';
+import { warmStrategyCache } from './warm-strategy-cache.es.js';
+import { isApplicationScope } from './routing.es.js';
+import { createCacheKey } from './cache.es.js';
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/pageCache.ts
+ */
+function cacheApplicationPages({ precacheManifest = [], maxEntries = 30, maxAgeSeconds = 30 * 24 * 60 * 60, networkTimeoutSeconds = 3, strategy: Strategy = NetworkFirst, } = {}) {
+    const strategy = new Strategy({
+        cacheName: createCacheKey('pages'),
+        networkTimeoutSeconds,
+        plugins: [
+            new CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+                purgeOnQuotaError: true,
+            }),
+        ],
+    });
+    const route = new Route(({ request }) => {
+        return isApplicationScope(request) && request.mode === 'navigate';
+    }, strategy);
+    warmStrategyCache({ urls: precacheManifest, type: 'html', strategy });
+    registerRoute(route);
+}
+
+export { cacheApplicationPages };

package/lib/cache-application-pages.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var workboxRouting = require('workbox-routing');
+var workboxStrategies = require('workbox-strategies');
+var workboxExpiration = require('workbox-expiration');
+var workboxCacheableResponse = require('workbox-cacheable-response');
+var warmStrategyCache = require('./warm-strategy-cache.js');
+var routing = require('./routing.js');
+var cache = require('./cache.js');
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/pageCache.ts
+ */
+function cacheApplicationPages({ precacheManifest = [], maxEntries = 30, maxAgeSeconds = 30 * 24 * 60 * 60, networkTimeoutSeconds = 3, strategy: Strategy = workboxStrategies.NetworkFirst, } = {}) {
+    const strategy = new Strategy({
+        cacheName: cache.createCacheKey('pages'),
+        networkTimeoutSeconds,
+        plugins: [
+            new workboxCacheableResponse.CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new workboxExpiration.ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+                purgeOnQuotaError: true,
+            }),
+        ],
+    });
+    const route = new workboxRouting.Route(({ request }) => {
+        return routing.isApplicationScope(request) && request.mode === 'navigate';
+    }, strategy);
+    warmStrategyCache.warmStrategyCache({ urls: precacheManifest, type: 'html', strategy });
+    workboxRouting.registerRoute(route);
+}
+
+exports.cacheApplicationPages = cacheApplicationPages;

package/lib/cache-application-static-assets.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationAssetsCacheOptions } from './types';
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/staticResourceCache.ts
+ */
+export declare function cacheApplicationStaticAssets({ precacheManifest, maxEntries, maxAgeSeconds, strategy: Strategy, }?: ApplicationAssetsCacheOptions): void;

package/lib/cache-application-static-assets.es.js

@@ -0,0 +1,34 @@
+import { Route, registerRoute } from 'workbox-routing';
+import { StaleWhileRevalidate } from 'workbox-strategies';
+import { ExpirationPlugin } from 'workbox-expiration';
+import { CacheableResponsePlugin } from 'workbox-cacheable-response';
+import { warmStrategyCache } from './warm-strategy-cache.es.js';
+import { isApplicationAsset, isApplicationScope } from './routing.es.js';
+import { createCacheKey } from './cache.es.js';
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/staticResourceCache.ts
+ */
+function cacheApplicationStaticAssets({ precacheManifest = [], maxEntries = 60, maxAgeSeconds, strategy: Strategy = StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: createCacheKey('static-assets'),
+        plugins: [
+            new CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new Route(({ request }) => {
+        return ((isApplicationAsset(request) &&
+            (request.destination === 'script' || request.destination === 'style')) ||
+            (isApplicationScope(request) && request.destination === 'manifest'));
+    }, strategy);
+    warmStrategyCache({ urls: precacheManifest, type: ['script', 'style', 'manifest'], strategy });
+    registerRoute(route);
+}
+
+export { cacheApplicationStaticAssets };

package/lib/cache-application-static-assets.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var workboxRouting = require('workbox-routing');
+var workboxStrategies = require('workbox-strategies');
+var workboxExpiration = require('workbox-expiration');
+var workboxCacheableResponse = require('workbox-cacheable-response');
+var warmStrategyCache = require('./warm-strategy-cache.js');
+var routing = require('./routing.js');
+var cache = require('./cache.js');
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/staticResourceCache.ts
+ */
+function cacheApplicationStaticAssets({ precacheManifest = [], maxEntries = 60, maxAgeSeconds, strategy: Strategy = workboxStrategies.StaleWhileRevalidate, } = {}) {
+    const strategy = new Strategy({
+        cacheName: cache.createCacheKey('static-assets'),
+        plugins: [
+            new workboxCacheableResponse.CacheableResponsePlugin({
+                statuses: [0, 200],
+            }),
+            new workboxExpiration.ExpirationPlugin({
+                maxEntries,
+                maxAgeSeconds,
+            }),
+        ],
+    });
+    const route = new workboxRouting.Route(({ request }) => {
+        return ((routing.isApplicationAsset(request) &&
+            (request.destination === 'script' || request.destination === 'style')) ||
+            (routing.isApplicationScope(request) && request.destination === 'manifest'));
+    }, strategy);
+    warmStrategyCache.warmStrategyCache({ urls: precacheManifest, type: ['script', 'style', 'manifest'], strategy });
+    workboxRouting.registerRoute(route);
+}
+
+exports.cacheApplicationStaticAssets = cacheApplicationStaticAssets;

package/lib/cache.d.ts

@@ -0,0 +1 @@
+export declare const createCacheKey: (key: string) => string;

package/lib/cache.es.js

@@ -0,0 +1,3 @@
+const createCacheKey = (key) => [process.env.APP_ID, process.env.APP_VERSION, key].filter(Boolean).join('-');
+
+export { createCacheKey };

package/lib/cache.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const createCacheKey = (key) => [process.env.APP_ID, process.env.APP_VERSION, key].filter(Boolean).join('-');
+
+exports.createCacheKey = createCacheKey;

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './cache';
+export * from './routing';
+export * from './warm-strategy-cache';
+export * from './cache-application-static-assets';
+export * from './cache-application-images';
+export * from './cache-application-fonts';
+export * from './cache-application-pages';

package/lib/index.es.js

@@ -0,0 +1,7 @@
+export { createCacheKey } from './cache.es.js';
+export { isApplicationAsset, isApplicationScope } from './routing.es.js';
+export { matchResourceType, warmStrategyCache } from './warm-strategy-cache.es.js';
+export { cacheApplicationStaticAssets } from './cache-application-static-assets.es.js';
+export { cacheApplicationImages } from './cache-application-images.es.js';
+export { cacheApplicationFonts } from './cache-application-fonts.es.js';
+export { cacheApplicationPages } from './cache-application-pages.es.js';

package/lib/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cache = require('./cache.js');
+var routing = require('./routing.js');
+var warmStrategyCache = require('./warm-strategy-cache.js');
+var cacheApplicationStaticAssets = require('./cache-application-static-assets.js');
+var cacheApplicationImages = require('./cache-application-images.js');
+var cacheApplicationFonts = require('./cache-application-fonts.js');
+var cacheApplicationPages = require('./cache-application-pages.js');
+
+
+
+exports.createCacheKey = cache.createCacheKey;
+exports.isApplicationAsset = routing.isApplicationAsset;
+exports.isApplicationScope = routing.isApplicationScope;
+exports.matchResourceType = warmStrategyCache.matchResourceType;
+exports.warmStrategyCache = warmStrategyCache.warmStrategyCache;
+exports.cacheApplicationStaticAssets = cacheApplicationStaticAssets.cacheApplicationStaticAssets;
+exports.cacheApplicationImages = cacheApplicationImages.cacheApplicationImages;
+exports.cacheApplicationFonts = cacheApplicationFonts.cacheApplicationFonts;
+exports.cacheApplicationPages = cacheApplicationPages.cacheApplicationPages;

package/lib/routing.d.ts

@@ -0,0 +1,2 @@
+export declare const isApplicationAsset: (request: Request) => boolean;
+export declare const isApplicationScope: (request: Request) => boolean;

package/lib/routing.es.js

@@ -0,0 +1,6 @@
+const isApplicationAsset = (request) => request.url.startsWith(process.env.ASSETS_PREFIX);
+const isApplicationScope = (request) => {
+    return new URL(request.url).pathname.startsWith(process.env.TRAMVAI_PWA_SW_SCOPE);
+};
+
+export { isApplicationAsset, isApplicationScope };

package/lib/routing.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isApplicationAsset = (request) => request.url.startsWith(process.env.ASSETS_PREFIX);
+const isApplicationScope = (request) => {
+    return new URL(request.url).pathname.startsWith(process.env.TRAMVAI_PWA_SW_SCOPE);
+};
+
+exports.isApplicationAsset = isApplicationAsset;
+exports.isApplicationScope = isApplicationScope;

package/lib/types.d.ts

@@ -0,0 +1,17 @@
+import type { PrecacheEntry } from 'workbox-precaching';
+import type { Strategy, StrategyOptions } from 'workbox-strategies';
+export interface ApplicationAssetsCacheOptions {
+    precacheManifest?: Array<string | PrecacheEntry>;
+    maxEntries?: number;
+    maxAgeSeconds?: number;
+    strategy?: StrategyConstructor;
+}
+export interface StrategyConstructor {
+    new (options: StrategyOptions & Record<string, any>): Strategy;
+}
+export interface WarmStrategyCacheOptions {
+    urls: Array<string | PrecacheEntry>;
+    type: ResourcesTypes | ResourcesTypes[];
+    strategy: Strategy;
+}
+export type ResourcesTypes = 'script' | 'style' | 'image' | 'font' | 'manifest' | 'html';

package/lib/warm-strategy-cache.d.ts

@@ -0,0 +1,6 @@
+import type { ResourcesTypes, WarmStrategyCacheOptions } from './types';
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/warmStrategyCache.ts
+ */
+export declare function warmStrategyCache(options: WarmStrategyCacheOptions): void;
+export declare function matchResourceType(type: ResourcesTypes, path: string): boolean;

package/lib/warm-strategy-cache.es.js

@@ -0,0 +1,54 @@
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/warmStrategyCache.ts
+ */
+function warmStrategyCache(options) {
+    self.addEventListener('install', (event) => {
+        const done = options.urls
+            .map((path) => {
+            return typeof path === 'object' ? path.url : path;
+        })
+            .filter((path) => {
+            const types = Array.isArray(options.type) ? options.type : [options.type];
+            return types.some((type) => matchResourceType(type, path));
+        })
+            .map((path) => options.strategy.handleAll({
+            event,
+            request: new Request(path),
+        })[1]);
+        event.waitUntil(Promise.all(done));
+    });
+}
+function matchResourceType(type, path) {
+    if (path.includes('?')) {
+        // eslint-disable-next-line no-param-reassign
+        [path] = path.split('?');
+    }
+    switch (type) {
+        case 'script':
+            return path.endsWith('.js');
+        case 'style':
+            return path.endsWith('.css');
+        case 'manifest':
+            return path.endsWith('.webmanifest') || path.endsWith('.json');
+        case 'image':
+            return (path.endsWith('.png') ||
+                path.endsWith('.jpg') ||
+                path.endsWith('.jpeg') ||
+                path.endsWith('.svg') ||
+                path.endsWith('.webp') ||
+                path.endsWith('.avif'));
+        case 'font':
+            return (path.endsWith('.woff') ||
+                path.endsWith('.woff2') ||
+                path.endsWith('.ttf') ||
+                path.endsWith('.otf'));
+        case 'html':
+            return ((path.startsWith(process.env.TRAMVAI_PWA_SW_SCOPE) &&
+                !matchResourceType('manifest', path)) ||
+                path.endsWith('.html'));
+        default:
+            return false;
+    }
+}
+
+export { matchResourceType, warmStrategyCache };

package/lib/warm-strategy-cache.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * reference - https://github.com/GoogleChrome/workbox/blob/v7/packages/workbox-recipes/src/warmStrategyCache.ts
+ */
+function warmStrategyCache(options) {
+    self.addEventListener('install', (event) => {
+        const done = options.urls
+            .map((path) => {
+            return typeof path === 'object' ? path.url : path;
+        })
+            .filter((path) => {
+            const types = Array.isArray(options.type) ? options.type : [options.type];
+            return types.some((type) => matchResourceType(type, path));
+        })
+            .map((path) => options.strategy.handleAll({
+            event,
+            request: new Request(path),
+        })[1]);
+        event.waitUntil(Promise.all(done));
+    });
+}
+function matchResourceType(type, path) {
+    if (path.includes('?')) {
+        // eslint-disable-next-line no-param-reassign
+        [path] = path.split('?');
+    }
+    switch (type) {
+        case 'script':
+            return path.endsWith('.js');
+        case 'style':
+            return path.endsWith('.css');
+        case 'manifest':
+            return path.endsWith('.webmanifest') || path.endsWith('.json');
+        case 'image':
+            return (path.endsWith('.png') ||
+                path.endsWith('.jpg') ||
+                path.endsWith('.jpeg') ||
+                path.endsWith('.svg') ||
+                path.endsWith('.webp') ||
+                path.endsWith('.avif'));
+        case 'font':
+            return (path.endsWith('.woff') ||
+                path.endsWith('.woff2') ||
+                path.endsWith('.ttf') ||
+                path.endsWith('.otf'));
+        case 'html':
+            return ((path.startsWith(process.env.TRAMVAI_PWA_SW_SCOPE) &&
+                !matchResourceType('manifest', path)) ||
+                path.endsWith('.html'));
+        default:
+            return false;
+    }
+}
+
+exports.matchResourceType = matchResourceType;
+exports.warmStrategyCache = warmStrategyCache;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@tramvai/pwa-recipes",
+  "version": "2.121.2",
+  "description": "",
+  "main": "lib/index.js",
+  "module": "lib/index.es.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:Tinkoff/tramvai.git"
+  },
+  "scripts": {
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "workbox-routing": "^6.6.1",
+    "workbox-strategies": "^6.6.1",
+    "workbox-expiration": "^6.6.1",
+    "workbox-cacheable-response": "^6.6.1",
+    "workbox-precaching": "^6.6.1"
+  }
+}