@duplojs/http 0.7.4 → 0.8.5

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.cjs

@@ -24,14 +24,15 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         return utils.E.error(new error.BodyParseFormDataError("Wrong boundary."));
     }
     let valueAccumulator = firstValueAccumulator;
-    const startPart = Buffer.from(`\r\n--${boundary}`);
-    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    const startPart = Buffer.from(`\r\n--${boundary}\r\n`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--\r\n`);
     let currentBuffer = bufferStart;
     let size = 0;
-    const keep = endMultiPart.length - 1;
+    const keep = endMultiPart.length;
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
+    let currentTextFieldSize = undefined;
     const checkSize = (receivedChunk) => {
         size += receivedChunk.length;
         return size > params.maxBodySize
@@ -61,6 +62,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (header.filename !== undefined) {
             currentFileSize = 0;
+            currentTextFieldSize = undefined;
             fileQuantity++;
             if (fileQuantity > params.maxFileQuantity) {
                 return new error.BodyParseFormDataError("File quantity exceeds limit.");
@@ -72,6 +74,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         else {
             currentFileSize = undefined;
+            currentTextFieldSize = 0;
         }
         const newStream = await onReceiveHeader(header);
         if (newStream instanceof Error) {
@@ -93,10 +96,16 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (typeof currentFileSize === "number") {
             currentFileSize += chunk.length;
-            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+            if (currentFileSize > params.fileMaxSize) {
                 return new error.BodyParseFormDataError("File size exceeds limit.");
             }
         }
+        if (typeof currentTextFieldSize === "number") {
+            currentTextFieldSize += chunk.length;
+            if (currentTextFieldSize > params.textFieldMaxSize) {
+                return new error.BodyParseFormDataError("Text field size exceeds limit.");
+            }
+        }
         await currentStream.onReceiveChunk(chunk);
         return true;
     };
@@ -114,11 +123,6 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 return await treatError(new error.BodyParseFormDataError("Buffer size exceeds limit."));
             }
             while (true) {
-                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
-                if (endMultiPartIndex !== -1) {
-                    // check if buffer contain end of transmissions
-                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
-                }
                 const startPartIndex = currentBuffer.indexOf(startPart);
                 const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
                 if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
@@ -156,9 +160,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 }
             }
         }
-        const resultChunk = await flushReceiveChunk(currentBuffer);
-        if (resultChunk !== true) {
-            return await treatError(resultChunk);
+        if (currentBuffer.indexOf(endMultiPart) === -1) {
+            const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, 2));
+            if (resultChunk !== true) {
+                return await treatError(resultChunk);
+            }
         }
         valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
         return valueAccumulator;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.d.ts

@@ -14,7 +14,8 @@ export interface ReadRequestFormDataParams {
     maxFileQuantity: number;
     maxBufferSize: number;
     maxKeyLength: number;
-    fileMaxSize?: number;
+    fileMaxSize: number;
+    textFieldMaxSize: number;
     mimeType?: RegExp;
 }
 export declare function readRequestFormData<GenericValueAccumulator extends unknown, GenericOutputHeader extends E.Left = never>(request: http.IncomingMessage, firstValueAccumulator: GenericValueAccumulator, params: ReadRequestFormDataParams, onReceiveHeader: (header: HeaderPartInformation) => MaybePromise<ReadRequestFormDataStreamChunkEvent<GenericValueAccumulator> | Error>): Promise<E.Left<"server-error", unknown> | GenericOutputHeader | E.Error<Error> | GenericValueAccumulator>;

package/dist/interfaces/node/bodyReaders/formData/readRequestFormData.mjs

@@ -22,14 +22,15 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         return E.error(new BodyParseFormDataError("Wrong boundary."));
     }
     let valueAccumulator = firstValueAccumulator;
-    const startPart = Buffer.from(`\r\n--${boundary}`);
-    const endMultiPart = Buffer.from(`\r\n--${boundary}--`);
+    const startPart = Buffer.from(`\r\n--${boundary}\r\n`);
+    const endMultiPart = Buffer.from(`\r\n--${boundary}--\r\n`);
     let currentBuffer = bufferStart;
     let size = 0;
-    const keep = endMultiPart.length - 1;
+    const keep = endMultiPart.length;
     let currentStream = undefined;
     let fileQuantity = 0;
     let currentFileSize = undefined;
+    let currentTextFieldSize = undefined;
     const checkSize = (receivedChunk) => {
         size += receivedChunk.length;
         return size > params.maxBodySize
@@ -59,6 +60,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (header.filename !== undefined) {
             currentFileSize = 0;
+            currentTextFieldSize = undefined;
             fileQuantity++;
             if (fileQuantity > params.maxFileQuantity) {
                 return new BodyParseFormDataError("File quantity exceeds limit.");
@@ -70,6 +72,7 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         else {
             currentFileSize = undefined;
+            currentTextFieldSize = 0;
         }
         const newStream = await onReceiveHeader(header);
         if (newStream instanceof Error) {
@@ -91,10 +94,16 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
         }
         if (typeof currentFileSize === "number") {
             currentFileSize += chunk.length;
-            if (params.fileMaxSize !== undefined && currentFileSize > params.fileMaxSize) {
+            if (currentFileSize > params.fileMaxSize) {
                 return new BodyParseFormDataError("File size exceeds limit.");
             }
         }
+        if (typeof currentTextFieldSize === "number") {
+            currentTextFieldSize += chunk.length;
+            if (currentTextFieldSize > params.textFieldMaxSize) {
+                return new BodyParseFormDataError("Text field size exceeds limit.");
+            }
+        }
         await currentStream.onReceiveChunk(chunk);
         return true;
     };
@@ -112,11 +121,6 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 return await treatError(new BodyParseFormDataError("Buffer size exceeds limit."));
             }
             while (true) {
-                const endMultiPartIndex = currentBuffer.indexOf(endMultiPart);
-                if (endMultiPartIndex !== -1) {
-                    // check if buffer contain end of transmissions
-                    currentBuffer = currentBuffer.subarray(0, endMultiPartIndex);
-                }
                 const startPartIndex = currentBuffer.indexOf(startPart);
                 const endHeaderPartIndex = currentBuffer.indexOf(endHeaderPart);
                 if (startPartIndex !== -1 && endHeaderPartIndex !== -1) {
@@ -154,9 +158,11 @@ async function readRequestFormData(request, firstValueAccumulator, params, onRec
                 }
             }
         }
-        const resultChunk = await flushReceiveChunk(currentBuffer);
-        if (resultChunk !== true) {
-            return await treatError(resultChunk);
+        if (currentBuffer.indexOf(endMultiPart) === -1) {
+            const resultChunk = await flushReceiveChunk(currentBuffer.subarray(0, 2));
+            if (resultChunk !== true) {
+                return await treatError(resultChunk);
+            }
         }
         valueAccumulator = await currentStream?.onEndPart(valueAccumulator) ?? valueAccumulator;
         return valueAccumulator;

package/dist/interfaces/node/createHttpServer.cjs

@@ -2,10 +2,9 @@
 
 var http = require('http');
 var https = require('https');
-var index$3 = require('./hooks/index.cjs');
+var index$2 = require('./hooks/index.cjs');
 var implementHttpServer = require('../../core/implementHttpServer.cjs');
 var utils = require('@duplojs/utils');
-var index$2 = require('../../core/defaultHooks/index.cjs');
 require('./bodyReaders/index.cjs');
 var index = require('./bodyReaders/text/index.cjs');
 var index$1 = require('./bodyReaders/formData/index.cjs');
@@ -25,7 +24,6 @@ function createHttpServer(hub, params) {
         index.createTextBodyReaderImplementation(httpServerParams),
         index$1.createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    hub.addRouteHooks([index$2.initDefaultHook(hub, httpServerParams), index$3.nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
@@ -44,6 +42,7 @@ function createHttpServer(hub, params) {
     return implementHttpServer.implementHttpServer({
         hub,
         httpServerParams,
+        getInterfaceHooks: ({ hub, httpServerParams }) => [index$2.initNodeHook(hub, httpServerParams)],
     }, ({ httpServerParams, execRouteSystem }) => {
         const server = httpServerParams.https
             ? https.createServer(httpServerParams.https)

package/dist/interfaces/node/createHttpServer.mjs

@@ -1,9 +1,8 @@
 import http from 'http';
 import https from 'https';
-import { nodeHook } from './hooks/index.mjs';
+import { initNodeHook } from './hooks/index.mjs';
 import { implementHttpServer } from '../../core/implementHttpServer.mjs';
 import { O } from '@duplojs/utils';
-import { initDefaultHook } from '../../core/defaultHooks/index.mjs';
 import './bodyReaders/index.mjs';
 import { createTextBodyReaderImplementation } from './bodyReaders/text/index.mjs';
 import { createFormDataBodyReaderImplementation } from './bodyReaders/formData/index.mjs';
@@ -23,7 +22,6 @@ function createHttpServer(hub, params) {
         createTextBodyReaderImplementation(httpServerParams),
         createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    hub.addRouteHooks([initDefaultHook(hub, httpServerParams), nodeHook]);
     function whenUncaughtError(error, routerInitializationData) {
         const serverResponse = routerInitializationData.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
@@ -42,6 +40,7 @@ function createHttpServer(hub, params) {
     return implementHttpServer({
         hub,
         httpServerParams,
+        getInterfaceHooks: ({ hub, httpServerParams }) => [initNodeHook(hub, httpServerParams)],
     }, ({ httpServerParams, execRouteSystem }) => {
         const server = httpServerParams.https
             ? https.createServer(httpServerParams.https)

package/dist/interfaces/node/hooks/index.cjs

@@ -1,47 +1,70 @@
 'use strict';
 
+require('../../../core/response/index.cjs');
 require('../../../core/route/index.cjs');
+var serverSentEvents = require('../../../core/serverSentEvents.cjs');
 var serverUtils = require('@duplojs/server-utils');
 var utils = require('@duplojs/utils');
 var node_fs = require('node:fs');
 var hooks = require('../../../core/route/hooks.cjs');
+var serverSentEventsPredicted = require('../../../core/response/serverSentEventsPredicted.cjs');
 
-const nodeHook = hooks.createHookRouteLifeCycle({
-    beforeSendResponse({ request, currentResponse, exit }) {
-        request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
-        return exit();
-    },
-    async sendResponse({ request, currentResponse, exit }) {
-        const { response: rawResponse } = request.raw;
-        const body = currentResponse.body;
-        if (body instanceof Error) {
-            rawResponse.write(body.toString());
-        }
-        else if (serverUtils.SF.isFileInterface(body)) {
-            await new Promise((resolve, reject) => {
-                node_fs.createReadStream(body.path)
-                    .pipe(request.raw.response
-                    .once("error", reject)
-                    .once("close", resolve));
-            });
-        }
-        else if (typeof body === "object"
-            || typeof body === "number"
-            || typeof body === "boolean") {
-            rawResponse.write(JSON.stringify(body));
-        }
-        else if (typeof body === "string") {
-            rawResponse.write(body);
-        }
-        rawResponse.end();
-        return exit();
-    },
-    async afterSendResponse({ request, next }) {
-        if (request.filesAttache) {
-            await Promise.all(utils.A.map(request.filesAttache, (path) => serverUtils.SF.remove(path)));
-        }
-        return next();
-    },
-});
+function initNodeHook(hub, serverParams) {
+    const isDev = hub.config.environment === "DEV";
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse({ request, currentResponse, exit }) {
+            request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+            return exit();
+        },
+        async sendResponse({ request, currentResponse, exit }) {
+            const { response: rawResponse, request: rawRequest } = request.raw;
+            if (currentResponse instanceof serverSentEventsPredicted.ServerSentEventsPredictedResponse) {
+                const handler = serverSentEvents.ServerSentEvents.init(currentResponse, {
+                    lastId: typeof request.headers["last-event-id"] === "string"
+                        ? request.headers["last-event-id"]
+                        : null,
+                });
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write(value)) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
+            const body = currentResponse.body;
+            if (body instanceof Error) {
+                rawResponse.write(body.toString());
+            }
+            else if (serverUtils.SF.isFileInterface(body)) {
+                await new Promise((resolve, reject) => {
+                    node_fs.createReadStream(body.path)
+                        .pipe(request.raw.response
+                        .once("error", reject)
+                        .once("close", resolve));
+                });
+            }
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
+                rawResponse.write(JSON.stringify(body));
+            }
+            else if (typeof body === "string") {
+                rawResponse.write(body);
+            }
+            rawResponse.end();
+            return exit();
+        },
+        async afterSendResponse({ request, next }) {
+            if (request.filesAttache) {
+                await Promise.all(utils.A.map(request.filesAttache, (path) => serverUtils.SF.remove(path)));
+            }
+            return next();
+        },
+    });
+}
 
-exports.nodeHook = nodeHook;
+exports.initNodeHook = initNodeHook;

package/dist/interfaces/node/hooks/index.d.ts

@@ -1,5 +1,7 @@
-export declare const nodeHook: {
-    beforeSendResponse({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): import("../../../core/route").RouteHookExit;
-    sendResponse({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): Promise<import("../../../core/route").RouteHookExit>;
-    afterSendResponse({ request, next }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>): Promise<import("../../../core/route").RouteHookNext>;
+import { type Hub } from "../../../core/hub";
+import { type HttpServerParams } from "../../../core/types";
+export declare function initNodeHook(hub: Hub, serverParams: HttpServerParams): {
+    readonly beforeSendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => import("../../../core/route").RouteHookExit;
+    readonly sendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookExit>;
+    readonly afterSendResponse: ({ request, next }: import("../../../core/route").RouteHookParamsAfter<import("../../../core/request").Request>) => Promise<import("../../../core/route").RouteHookNext>;
 };

package/dist/interfaces/node/hooks/index.mjs

@@ -1,45 +1,68 @@
+import '../../../core/response/index.mjs';
 import '../../../core/route/index.mjs';
+import { ServerSentEvents } from '../../../core/serverSentEvents.mjs';
 import { SF } from '@duplojs/server-utils';
 import { A } from '@duplojs/utils';
 import { createReadStream } from 'node:fs';
 import { createHookRouteLifeCycle } from '../../../core/route/hooks.mjs';
+import { ServerSentEventsPredictedResponse } from '../../../core/response/serverSentEventsPredicted.mjs';
 
-const nodeHook = createHookRouteLifeCycle({
-    beforeSendResponse({ request, currentResponse, exit }) {
-        request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
-        return exit();
-    },
-    async sendResponse({ request, currentResponse, exit }) {
-        const { response: rawResponse } = request.raw;
-        const body = currentResponse.body;
-        if (body instanceof Error) {
-            rawResponse.write(body.toString());
-        }
-        else if (SF.isFileInterface(body)) {
-            await new Promise((resolve, reject) => {
-                createReadStream(body.path)
-                    .pipe(request.raw.response
-                    .once("error", reject)
-                    .once("close", resolve));
-            });
-        }
-        else if (typeof body === "object"
-            || typeof body === "number"
-            || typeof body === "boolean") {
-            rawResponse.write(JSON.stringify(body));
-        }
-        else if (typeof body === "string") {
-            rawResponse.write(body);
-        }
-        rawResponse.end();
-        return exit();
-    },
-    async afterSendResponse({ request, next }) {
-        if (request.filesAttache) {
-            await Promise.all(A.map(request.filesAttache, (path) => SF.remove(path)));
-        }
-        return next();
-    },
-});
+function initNodeHook(hub, serverParams) {
+    const isDev = hub.config.environment === "DEV";
+    return createHookRouteLifeCycle({
+        beforeSendResponse({ request, currentResponse, exit }) {
+            request.raw.response.writeHead(Number(currentResponse.code), currentResponse.headers);
+            return exit();
+        },
+        async sendResponse({ request, currentResponse, exit }) {
+            const { response: rawResponse, request: rawRequest } = request.raw;
+            if (currentResponse instanceof ServerSentEventsPredictedResponse) {
+                const handler = ServerSentEvents.init(currentResponse, {
+                    lastId: typeof request.headers["last-event-id"] === "string"
+                        ? request.headers["last-event-id"]
+                        : null,
+                });
+                rawRequest.on("close", handler.abort);
+                void handler.start((value) => new Promise((resolve) => {
+                    if (!rawResponse.write(value)) {
+                        rawResponse.once("drain", resolve);
+                    }
+                    else {
+                        resolve();
+                    }
+                }), () => void rawResponse.end());
+                return exit();
+            }
+            const body = currentResponse.body;
+            if (body instanceof Error) {
+                rawResponse.write(body.toString());
+            }
+            else if (SF.isFileInterface(body)) {
+                await new Promise((resolve, reject) => {
+                    createReadStream(body.path)
+                        .pipe(request.raw.response
+                        .once("error", reject)
+                        .once("close", resolve));
+                });
+            }
+            else if (typeof body === "object"
+                || typeof body === "number"
+                || typeof body === "boolean") {
+                rawResponse.write(JSON.stringify(body));
+            }
+            else if (typeof body === "string") {
+                rawResponse.write(body);
+            }
+            rawResponse.end();
+            return exit();
+        },
+        async afterSendResponse({ request, next }) {
+            if (request.filesAttache) {
+                await Promise.all(A.map(request.filesAttache, (path) => SF.remove(path)));
+            }
+            return next();
+        },
+    });
+}
 
-export { nodeHook };
+export { initNodeHook };

package/dist/interfaces/node/index.cjs

@@ -15,7 +15,7 @@ var index$2 = require('./bodyReaders/text/index.cjs');
 
 exports.createInterfacesNodeLibKind = kind.createInterfacesNodeLibKind;
 exports.createHttpServer = createHttpServer.createHttpServer;
-exports.nodeHook = index.nodeHook;
+exports.initNodeHook = index.initNodeHook;
 exports.BodyParseFormDataError = error.BodyParseFormDataError;
 exports.readRequestFormData = readRequestFormData.readRequestFormData;
 exports.createFormDataBodyReaderImplementation = index$1.createFormDataBodyReaderImplementation;

package/dist/interfaces/node/index.mjs

@@ -1,7 +1,7 @@
 import './types/index.mjs';
 export { createInterfacesNodeLibKind } from './kind.mjs';
 export { createHttpServer } from './createHttpServer.mjs';
-export { nodeHook } from './hooks/index.mjs';
+export { initNodeHook } from './hooks/index.mjs';
 import './bodyReaders/index.mjs';
 export { BodyParseFormDataError } from './bodyReaders/formData/error.mjs';
 export { readRequestFormData } from './bodyReaders/formData/readRequestFormData.mjs';

package/dist/plugins/cacheController/createResponseHeader.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function createCacheControlResponseHeader(directives) {
+    return utils.pipe([
+        utils.O.entry("max-age", directives.maxAge),
+        utils.O.entry("s-maxage", directives.sMaxAge),
+        utils.O.entry("public", directives.public),
+        utils.O.entry("private", directives.private),
+        utils.O.entry("no-cache", directives.noCache),
+        utils.O.entry("no-store", directives.noStore),
+        utils.O.entry("no-transform", directives.noTransform),
+        utils.O.entry("must-revalidate", directives.mustRevalidate),
+        utils.O.entry("proxy-revalidate", directives.proxyRevalidate),
+        utils.O.entry("immutable", directives.immutable),
+        utils.O.entry("stale-while-revalidate", directives.staleWhileRevalidate),
+        utils.O.entry("stale-if-error", directives.staleIfError),
+        utils.O.entry("must-understand", directives.mustUnderstand),
+    ], utils.A.concat(directives.extensions ? utils.O.entries(directives.extensions) : []), utils.A.reduce(utils.A.reduceFrom([]), ({ element: [key, value], lastValue, nextPush, next }) => {
+        if (value === true) {
+            return nextPush(lastValue, key);
+        }
+        else if (typeof value === "number"
+            && Number.isFinite(value)
+            && value >= 0) {
+            return nextPush(lastValue, `${key}=${Math.trunc(value)}`);
+        }
+        else if (value instanceof Array
+            && utils.A.minElements(value, 1)) {
+            return nextPush(lastValue, `${key}="${utils.A.join(value, ",")}"`);
+        }
+        else if (value !== ""
+            && typeof value === "string") {
+            return nextPush(lastValue, `${key}="${value}"`);
+        }
+        else {
+            return next(lastValue);
+        }
+    }), utils.A.join(","));
+}
+
+exports.createCacheControlResponseHeader = createCacheControlResponseHeader;

package/dist/plugins/cacheController/createResponseHeader.d.ts

@@ -0,0 +1,2 @@
+import type { CacheControlDirectives } from "./types";
+export declare function createCacheControlResponseHeader(directives: CacheControlDirectives): string;

package/dist/plugins/cacheController/createResponseHeader.mjs

@@ -0,0 +1,41 @@
+import { pipe, O, A } from '@duplojs/utils';
+
+function createCacheControlResponseHeader(directives) {
+    return pipe([
+        O.entry("max-age", directives.maxAge),
+        O.entry("s-maxage", directives.sMaxAge),
+        O.entry("public", directives.public),
+        O.entry("private", directives.private),
+        O.entry("no-cache", directives.noCache),
+        O.entry("no-store", directives.noStore),
+        O.entry("no-transform", directives.noTransform),
+        O.entry("must-revalidate", directives.mustRevalidate),
+        O.entry("proxy-revalidate", directives.proxyRevalidate),
+        O.entry("immutable", directives.immutable),
+        O.entry("stale-while-revalidate", directives.staleWhileRevalidate),
+        O.entry("stale-if-error", directives.staleIfError),
+        O.entry("must-understand", directives.mustUnderstand),
+    ], A.concat(directives.extensions ? O.entries(directives.extensions) : []), A.reduce(A.reduceFrom([]), ({ element: [key, value], lastValue, nextPush, next }) => {
+        if (value === true) {
+            return nextPush(lastValue, key);
+        }
+        else if (typeof value === "number"
+            && Number.isFinite(value)
+            && value >= 0) {
+            return nextPush(lastValue, `${key}=${Math.trunc(value)}`);
+        }
+        else if (value instanceof Array
+            && A.minElements(value, 1)) {
+            return nextPush(lastValue, `${key}="${A.join(value, ",")}"`);
+        }
+        else if (value !== ""
+            && typeof value === "string") {
+            return nextPush(lastValue, `${key}="${value}"`);
+        }
+        else {
+            return next(lastValue);
+        }
+    }), A.join(","));
+}
+
+export { createCacheControlResponseHeader };

package/dist/plugins/cacheController/hooks.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var createResponseHeader = require('./createResponseHeader.cjs');
+require('../../core/route/index.cjs');
+var hooks = require('../../core/route/hooks.cjs');
+
+const eligibleCodeRegex = /^(?:2|3)/;
+function createCacheControllerHooks(params) {
+    const cacheControl = params
+        ? createResponseHeader.createCacheControlResponseHeader(params)
+        : null;
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (cacheControl
+                && eligibleCodeRegex.test(currentResponse.code)) {
+                currentResponse.setHeader("cache-control", cacheControl);
+            }
+            return next();
+        },
+    });
+}
+
+exports.createCacheControllerHooks = createCacheControllerHooks;

package/dist/plugins/cacheController/hooks.d.ts

@@ -0,0 +1,4 @@
+import type { CacheControlDirectives } from "./types";
+export declare function createCacheControllerHooks(params?: CacheControlDirectives): {
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter<import("../../core/request").Request>) => import("../../core/route").RouteHookNext;
+};

package/dist/plugins/cacheController/hooks.mjs

@@ -0,0 +1,21 @@
+import { createCacheControlResponseHeader } from './createResponseHeader.mjs';
+import '../../core/route/index.mjs';
+import { createHookRouteLifeCycle } from '../../core/route/hooks.mjs';
+
+const eligibleCodeRegex = /^(?:2|3)/;
+function createCacheControllerHooks(params) {
+    const cacheControl = params
+        ? createCacheControlResponseHeader(params)
+        : null;
+    return createHookRouteLifeCycle({
+        beforeSendResponse: ({ currentResponse, next }) => {
+            if (cacheControl
+                && eligibleCodeRegex.test(currentResponse.code)) {
+                currentResponse.setHeader("cache-control", cacheControl);
+            }
+            return next();
+        },
+    });
+}
+
+export { createCacheControllerHooks };

package/dist/plugins/cacheController/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var hooks = require('./hooks.cjs');
+require('./types/index.cjs');
+var createResponseHeader = require('./createResponseHeader.cjs');
+
+
+
+exports.createCacheControllerHooks = hooks.createCacheControllerHooks;
+exports.createCacheControlResponseHeader = createResponseHeader.createCacheControlResponseHeader;

package/dist/plugins/cacheController/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./types";
+export * from "./createResponseHeader";

package/dist/plugins/cacheController/index.mjs

@@ -0,0 +1,3 @@
+export { createCacheControllerHooks } from './hooks.mjs';
+import './types/index.mjs';
+export { createCacheControlResponseHeader } from './createResponseHeader.mjs';