@tramvai/module-page-render-mode 7.5.3 → 7.7.0

package/lib/PageRenderWrapper.browser.js

@@ -2,20 +2,20 @@ import { jsx, Fragment } from 'react/jsx-runtime';
 import { useState, useEffect } from 'react';
 import { useDi } from '@tramvai/react';
 import { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
-import { PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT } from './tokens.browser.js';
-import { getPageRenderMode } from './utils/getPageRenderMode.browser.js';
+import { PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT } from './tokens.browser.js';
+import { STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE } from './private-tokens.browser.js';
 
 const PageRenderWrapper = ({ children }) => {
     const [mounted, setMounted] = useState(false);
     const pageService = useDi(PAGE_SERVICE_TOKEN);
+    const resolvePageRenderMode = useDi(STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE);
     const fallbackKey = useDi(PAGE_RENDER_FALLBACK_COMPONENT_PREFIX);
-    const defaultRenderMode = useDi(PAGE_RENDER_DEFAULT_MODE);
     const DefaultFallbackComponent = useDi({
         token: PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT,
         optional: true,
     });
     const FallbackComponent = pageService.resolveComponentFromConfig(fallbackKey) || DefaultFallbackComponent;
-    const mode = getPageRenderMode({ pageService, defaultRenderMode });
+    const mode = resolvePageRenderMode();
     useEffect(() => {
         if (mode === 'client') {
             setMounted(true);

package/lib/PageRenderWrapper.d.ts

@@ -1,4 +1,4 @@
 import type { PropsWithChildren } from 'react';
-export declare const PageRenderWrapper: ({ children }: PropsWithChildren<{}>) => import("react/jsx-runtime").JSX.Element;
+export declare const PageRenderWrapper: ({ children }: PropsWithChildren<{}>) => import("react/jsx-runtime").JSX.Element | null;
 export declare const pageRenderHOC: (WrapperPage: any) => (props: any) => import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=PageRenderWrapper.d.ts.map

package/lib/PageRenderWrapper.es.js

@@ -2,20 +2,20 @@ import { jsx, Fragment } from 'react/jsx-runtime';
 import { useState, useEffect } from 'react';
 import { useDi } from '@tramvai/react';
 import { PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
-import { PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT } from './tokens.es.js';
-import { getPageRenderMode } from './utils/getPageRenderMode.es.js';
+import { PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT } from './tokens.es.js';
+import { STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE } from './private-tokens.es.js';
 
 const PageRenderWrapper = ({ children }) => {
     const [mounted, setMounted] = useState(false);
     const pageService = useDi(PAGE_SERVICE_TOKEN);
+    const resolvePageRenderMode = useDi(STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE);
     const fallbackKey = useDi(PAGE_RENDER_FALLBACK_COMPONENT_PREFIX);
-    const defaultRenderMode = useDi(PAGE_RENDER_DEFAULT_MODE);
     const DefaultFallbackComponent = useDi({
         token: PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT,
         optional: true,
     });
     const FallbackComponent = pageService.resolveComponentFromConfig(fallbackKey) || DefaultFallbackComponent;
-    const mode = getPageRenderMode({ pageService, defaultRenderMode });
+    const mode = resolvePageRenderMode();
     useEffect(() => {
         if (mode === 'client') {
             setMounted(true);

package/lib/PageRenderWrapper.js

@@ -7,19 +7,19 @@ var react = require('react');
 var react$1 = require('@tramvai/react');
 var tokensRouter = require('@tramvai/tokens-router');
 var tokens = require('./tokens.js');
-var getPageRenderMode = require('./utils/getPageRenderMode.js');
+var privateTokens = require('./private-tokens.js');
 
 const PageRenderWrapper = ({ children }) => {
     const [mounted, setMounted] = react.useState(false);
     const pageService = react$1.useDi(tokensRouter.PAGE_SERVICE_TOKEN);
+    const resolvePageRenderMode = react$1.useDi(privateTokens.STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE);
     const fallbackKey = react$1.useDi(tokens.PAGE_RENDER_FALLBACK_COMPONENT_PREFIX);
-    const defaultRenderMode = react$1.useDi(tokens.PAGE_RENDER_DEFAULT_MODE);
     const DefaultFallbackComponent = react$1.useDi({
         token: tokens.PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT,
         optional: true,
     });
     const FallbackComponent = pageService.resolveComponentFromConfig(fallbackKey) || DefaultFallbackComponent;
-    const mode = getPageRenderMode.getPageRenderMode({ pageService, defaultRenderMode });
+    const mode = resolvePageRenderMode();
     react.useEffect(() => {
         if (mode === 'client') {
             setMounted(true);

package/lib/browser.js

@@ -1,13 +1,37 @@
-import { declareModule } from '@tramvai/core';
+import { declareModule, provide } from '@tramvai/core';
+import { REQUEST_MANAGER_TOKEN } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN, PAGE_SERVICE_TOKEN } from '@tramvai/tokens-router';
 import { ForceCSRModule } from './ForceCSRModule.browser.js';
 import { sharedProviders } from './shared.browser.js';
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.browser.js';
+import { STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE } from './private-tokens.browser.js';
+import { getPageRenderMode } from './utils/getPageRenderMode.browser.js';
+import { PAGE_RENDER_DEFAULT_MODE } from './tokens.browser.js';
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.browser.js';
 
 // @todo: перенести в @tramvai/module-render
 const PageRenderModeModule = declareModule({
     name: 'PageRenderModeModule',
     imports: [ForceCSRModule],
-    providers: [...sharedProviders],
+    providers: [
+        ...sharedProviders,
+        provide({
+            provide: STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE,
+            useFactory: ({ requestManager, pageService, router, defaultRenderMode }) => {
+                return () => getPageRenderMode({
+                    pageService,
+                    router,
+                    requestManager,
+                    defaultRenderMode,
+                });
+            },
+            deps: {
+                requestManager: REQUEST_MANAGER_TOKEN,
+                router: ROUTER_TOKEN,
+                pageService: PAGE_SERVICE_TOKEN,
+                defaultRenderMode: PAGE_RENDER_DEFAULT_MODE,
+            },
+        }),
+    ],
 });
 
 export { PageRenderModeModule };

package/lib/private-tokens.browser.js

@@ -0,0 +1,9 @@
+import { createToken } from '@tramvai/core';
+
+createToken();
+createToken();
+createToken();
+createToken();
+const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE = createToken();
+
+export { STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE };

package/lib/private-tokens.d.ts

@@ -0,0 +1,27 @@
+import type { Counter, Gauge } from 'prom-client';
+import { TramvaiRenderMode } from '@tramvai/tokens-render';
+import { BackgroundFetchService } from './staticPages/backgroundFetchService';
+import { FileSystemCache } from './staticPages/fileSystemCache';
+export declare const STATIC_PAGES_BACKGROUND_FETCH_SERVICE: BackgroundFetchService & {
+    __type?: "base token" | undefined;
+};
+export declare const STATIC_PAGES_CACHE_METRICS_TOKEN: {
+    hit: Counter<any>;
+} & {
+    __type?: "base token" | undefined;
+};
+export declare const STATIC_PAGES_FS_CACHE_TOKEN: (FileSystemCache & {
+    __type?: "base token" | undefined;
+}) | null;
+export declare const STATIC_PAGES_FS_CACHE_METRICS_TOKEN: {
+    hit: Counter<any>;
+    miss: Counter<any>;
+    size: Gauge<any>;
+    bytes: Gauge<any>;
+} & {
+    __type?: "base token" | undefined;
+};
+export declare const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE: (() => TramvaiRenderMode) & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=private-tokens.d.ts.map

package/lib/private-tokens.es.js

@@ -0,0 +1,9 @@
+import { createToken } from '@tramvai/core';
+
+const STATIC_PAGES_BACKGROUND_FETCH_SERVICE = createToken();
+const STATIC_PAGES_CACHE_METRICS_TOKEN = createToken();
+const STATIC_PAGES_FS_CACHE_TOKEN = createToken();
+const STATIC_PAGES_FS_CACHE_METRICS_TOKEN = createToken();
+const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE = createToken();
+
+export { STATIC_PAGES_BACKGROUND_FETCH_SERVICE, STATIC_PAGES_CACHE_METRICS_TOKEN, STATIC_PAGES_FS_CACHE_METRICS_TOKEN, STATIC_PAGES_FS_CACHE_TOKEN, STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE };

package/lib/private-tokens.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+
+const STATIC_PAGES_BACKGROUND_FETCH_SERVICE = core.createToken();
+const STATIC_PAGES_CACHE_METRICS_TOKEN = core.createToken();
+const STATIC_PAGES_FS_CACHE_TOKEN = core.createToken();
+const STATIC_PAGES_FS_CACHE_METRICS_TOKEN = core.createToken();
+const STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE = core.createToken();
+
+exports.STATIC_PAGES_BACKGROUND_FETCH_SERVICE = STATIC_PAGES_BACKGROUND_FETCH_SERVICE;
+exports.STATIC_PAGES_CACHE_METRICS_TOKEN = STATIC_PAGES_CACHE_METRICS_TOKEN;
+exports.STATIC_PAGES_FS_CACHE_METRICS_TOKEN = STATIC_PAGES_FS_CACHE_METRICS_TOKEN;
+exports.STATIC_PAGES_FS_CACHE_TOKEN = STATIC_PAGES_FS_CACHE_TOKEN;
+exports.STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE = STATIC_PAGES_RESOLVE_PAGE_RENDER_MODE;

package/lib/server.es.js

@@ -2,7 +2,7 @@ import { declareModule } from '@tramvai/core';
 import { ForceCSRModule } from './ForceCSRModule.es.js';
 import { sharedProviders } from './shared.es.js';
 import { staticPagesProviders } from './staticPages.es.js';
-export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.es.js';
+export { PAGE_RENDER_DEFAULT_FALLBACK_COMPONENT, PAGE_RENDER_DEFAULT_MODE, PAGE_RENDER_FALLBACK_COMPONENT_PREFIX, PAGE_RENDER_WRAPPER_TYPE, STATIC_PAGES_BACKGROUND_FETCH_ENABLED, STATIC_PAGES_CACHE_5xx_RESPONSE, STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN, STATIC_PAGES_CACHE_TOKEN, STATIC_PAGES_COMMAND_LINE, STATIC_PAGES_FS_CACHE_ENABLED, STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN, STATIC_PAGES_KEY_TOKEN, STATIC_PAGES_MODIFY_CACHE, STATIC_PAGES_OPTIONS_TOKEN, STATIC_PAGES_SERVICE, STATIC_PAGES_SHOULD_USE_CACHE } from './tokens.es.js';
 
 // @todo: перенести в @tramvai/module-render
 const PageRenderModeModule = declareModule({

package/lib/server.js

@@ -21,9 +21,14 @@ exports.PAGE_RENDER_FALLBACK_COMPONENT_PREFIX = tokens.PAGE_RENDER_FALLBACK_COMP
 exports.PAGE_RENDER_WRAPPER_TYPE = tokens.PAGE_RENDER_WRAPPER_TYPE;
 exports.STATIC_PAGES_BACKGROUND_FETCH_ENABLED = tokens.STATIC_PAGES_BACKGROUND_FETCH_ENABLED;
 exports.STATIC_PAGES_CACHE_5xx_RESPONSE = tokens.STATIC_PAGES_CACHE_5xx_RESPONSE;
+exports.STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN = tokens.STATIC_PAGES_CACHE_CONTROL_HEADER_TOKEN;
 exports.STATIC_PAGES_CACHE_TOKEN = tokens.STATIC_PAGES_CACHE_TOKEN;
 exports.STATIC_PAGES_COMMAND_LINE = tokens.STATIC_PAGES_COMMAND_LINE;
+exports.STATIC_PAGES_FS_CACHE_ENABLED = tokens.STATIC_PAGES_FS_CACHE_ENABLED;
+exports.STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN = tokens.STATIC_PAGES_FS_CACHE_OPTIONS_TOKEN;
+exports.STATIC_PAGES_KEY_TOKEN = tokens.STATIC_PAGES_KEY_TOKEN;
 exports.STATIC_PAGES_MODIFY_CACHE = tokens.STATIC_PAGES_MODIFY_CACHE;
 exports.STATIC_PAGES_OPTIONS_TOKEN = tokens.STATIC_PAGES_OPTIONS_TOKEN;
+exports.STATIC_PAGES_SERVICE = tokens.STATIC_PAGES_SERVICE;
 exports.STATIC_PAGES_SHOULD_USE_CACHE = tokens.STATIC_PAGES_SHOULD_USE_CACHE;
 exports.PageRenderModeModule = PageRenderModeModule;

package/lib/staticPages/backgroundFetchService.d.ts

@@ -1,22 +1,24 @@
 import type { ExtractDependencyType } from '@tinkoff/dippy';
-import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import type { ENV_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/tokens-common';
 import type { STATIC_PAGES_BACKGROUND_FETCH_ENABLED } from '../tokens';
 type Logger = ExtractDependencyType<typeof LOGGER_TOKEN>;
 type BackgroundCacheEnabled = ExtractDependencyType<typeof STATIC_PAGES_BACKGROUND_FETCH_ENABLED>;
 export declare class BackgroundFetchService {
     private requests;
+    private port;
+    private hostname;
     private log;
     private backgroundFetchEnabled;
-    constructor({ logger, backgroundFetchEnabled, }: {
+    constructor({ logger, envManager, backgroundFetchEnabled, }: {
         logger: Logger;
+        envManager: ExtractDependencyType<typeof ENV_MANAGER_TOKEN>;
         backgroundFetchEnabled: BackgroundCacheEnabled;
     });
     enabled(): boolean;
-    revalidate({ key, path, port, deviceType, }: {
-        key: string;
-        path: string;
-        port: string;
-        deviceType: string;
+    revalidate({ cacheKey, pathname, headers, }: {
+        cacheKey: string;
+        pathname: string;
+        headers: Record<string, string | string[] | undefined>;
     }): Promise<void | {
         body: string;
         headers: {

package/lib/staticPages/backgroundFetchService.es.js

@@ -1,56 +1,56 @@
 import { format } from '@tinkoff/url';
 
-const userAgentByDeviceType = {
-    /** Chrome on Mobile */
-    mobile: 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3071.125 Mobile Safari/537.36',
-    /** Chrome on Desktop */
-    desktop: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3987.87 Safari/537.36',
-};
 class BackgroundFetchService {
     requests = new Set();
+    port;
+    hostname;
     log;
     backgroundFetchEnabled;
-    constructor({ logger, backgroundFetchEnabled, }) {
+    constructor({ logger, envManager, backgroundFetchEnabled, }) {
         this.log = logger('static-pages');
+        this.port = envManager.get('PORT');
+        this.hostname = (envManager.get('HOST') ?? 'localhost').replace('0.0.0.0', 'localhost');
         this.backgroundFetchEnabled = backgroundFetchEnabled;
     }
     enabled() {
         return this.backgroundFetchEnabled();
     }
-    async revalidate({ key, path, port, deviceType, }) {
-        if (this.requests.has(key)) {
+    async revalidate({ cacheKey, pathname, headers, }) {
+        if (this.requests.has(cacheKey)) {
             return;
         }
         const revalidateUrl = format({
-            hostname: 'localhost',
-            port,
-            path,
+            hostname: this.hostname,
+            port: this.port,
+            path: pathname,
         });
-        this.requests.add(key);
+        this.requests.add(cacheKey);
         this.log.debug({
             event: 'background-fetch-init',
-            key,
+            cacheKey,
             revalidateUrl,
         });
         return fetch(revalidateUrl, {
             headers: {
-                'User-Agent': userAgentByDeviceType[`${deviceType}`],
+                ...headers,
                 'X-Tramvai-Static-Page-Revalidate': 'true',
             },
             signal: AbortSignal.timeout(10000),
+            // we need to save raw redirect response status code and headers
+            redirect: 'manual',
         })
             .then(async (response) => {
             const body = await response.text();
-            const { headers, status } = response;
+            const { status } = response;
             this.log.debug({
                 event: status >= 500 ? 'background-fetch-5xx' : 'background-fetch-success',
                 status,
-                key,
+                cacheKey,
             });
             return {
                 body,
                 // @ts-ignore outdated typings for headers in typescript
-                headers: Object.fromEntries(headers.entries()),
+                headers: Object.fromEntries(response.headers.entries()),
                 status,
             };
         })
@@ -58,11 +58,11 @@ class BackgroundFetchService {
             this.log.warn({
                 event: 'background-fetch-error',
                 error,
-                key,
+                cacheKey,
             });
         })
             .finally(() => {
-            this.requests.delete(key);
+            this.requests.delete(cacheKey);
         });
     }
 }

package/lib/staticPages/backgroundFetchService.js

@@ -4,57 +4,57 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var url = require('@tinkoff/url');
 
-const userAgentByDeviceType = {
-    /** Chrome on Mobile */
-    mobile: 'Mozilla/5.0 (Linux; Android 7.0; SM-G930V Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3071.125 Mobile Safari/537.36',
-    /** Chrome on Desktop */
-    desktop: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3987.87 Safari/537.36',
-};
 class BackgroundFetchService {
     requests = new Set();
+    port;
+    hostname;
     log;
     backgroundFetchEnabled;
-    constructor({ logger, backgroundFetchEnabled, }) {
+    constructor({ logger, envManager, backgroundFetchEnabled, }) {
         this.log = logger('static-pages');
+        this.port = envManager.get('PORT');
+        this.hostname = (envManager.get('HOST') ?? 'localhost').replace('0.0.0.0', 'localhost');
         this.backgroundFetchEnabled = backgroundFetchEnabled;
     }
     enabled() {
         return this.backgroundFetchEnabled();
     }
-    async revalidate({ key, path, port, deviceType, }) {
-        if (this.requests.has(key)) {
+    async revalidate({ cacheKey, pathname, headers, }) {
+        if (this.requests.has(cacheKey)) {
             return;
         }
         const revalidateUrl = url.format({
-            hostname: 'localhost',
-            port,
-            path,
+            hostname: this.hostname,
+            port: this.port,
+            path: pathname,
         });
-        this.requests.add(key);
+        this.requests.add(cacheKey);
         this.log.debug({
             event: 'background-fetch-init',
-            key,
+            cacheKey,
             revalidateUrl,
         });
         return fetch(revalidateUrl, {
             headers: {
-                'User-Agent': userAgentByDeviceType[`${deviceType}`],
+                ...headers,
                 'X-Tramvai-Static-Page-Revalidate': 'true',
             },
             signal: AbortSignal.timeout(10000),
+            // we need to save raw redirect response status code and headers
+            redirect: 'manual',
         })
             .then(async (response) => {
             const body = await response.text();
-            const { headers, status } = response;
+            const { status } = response;
             this.log.debug({
                 event: status >= 500 ? 'background-fetch-5xx' : 'background-fetch-success',
                 status,
-                key,
+                cacheKey,
             });
             return {
                 body,
                 // @ts-ignore outdated typings for headers in typescript
-                headers: Object.fromEntries(headers.entries()),
+                headers: Object.fromEntries(response.headers.entries()),
                 status,
             };
         })
@@ -62,11 +62,11 @@ class BackgroundFetchService {
             this.log.warn({
                 event: 'background-fetch-error',
                 error,
-                key,
+                cacheKey,
             });
         })
             .finally(() => {
-            this.requests.delete(key);
+            this.requests.delete(cacheKey);
         });
     }
 }

package/lib/staticPages/fileSystemCache.d.ts

@@ -0,0 +1,72 @@
+import type { ExtractDependencyType } from '@tinkoff/dippy';
+import type { LOGGER_TOKEN } from '@tramvai/tokens-common';
+import type { Counter, Gauge } from 'prom-client';
+import { Route } from '@tinkoff/router';
+import { StaticPagesCacheEntry } from '../tokens';
+type Logger = ExtractDependencyType<typeof LOGGER_TOKEN>;
+interface FileMetadata {
+    filePath: string;
+    pathname: string;
+    key: string;
+    cacheKey: string;
+    size: number;
+    mtime: number;
+}
+export type CacheMetrics = {
+    hit: Counter;
+    miss: Counter;
+    size: Gauge;
+    bytes: Gauge;
+};
+export interface FileSystemCacheOptions {
+    /**
+     * Directory where static HTML files are stored
+     */
+    directory: string;
+    /**
+     * Maximum number of files to keep in cache
+     */
+    maxSize: number;
+    /**
+     * TTL for cache entries in milliseconds
+     */
+    ttl: number;
+    /**
+     * Whether to allow stale entries to be returned
+     */
+    allowStale: boolean;
+}
+export declare class FileSystemCache {
+    private directory;
+    private maxSize;
+    private ttl;
+    private allowStale;
+    private log;
+    private cache;
+    private list;
+    private nodes;
+    staticPages: Route[];
+    private metrics;
+    private limit;
+    constructor({ directory, maxSize, ttl, allowStale, logger, metrics, }: FileSystemCacheOptions & {
+        metrics: CacheMetrics;
+        logger: Logger;
+    });
+    init(): Promise<void>;
+    get(cacheKey: string): Promise<StaticPagesCacheEntry | undefined>;
+    set(cacheKey: string, cacheEntry: StaticPagesCacheEntry): Promise<void>;
+    has(cacheKey: string): boolean;
+    delete(cacheKey: string): Promise<boolean>;
+    clear(): Promise<void>;
+    get size(): number;
+    dump(): Array<[key: string, metadata: FileMetadata]>;
+    private scanDirectory;
+    private addFileToCache;
+    moveToHead(cacheKey: string): void;
+    private removeNode;
+    private evictTail;
+    private getTotalBytes;
+    private updateMetrics;
+}
+export {};
+//# sourceMappingURL=fileSystemCache.d.ts.map