@duplojs/http 0.8.5 → 0.9.5

package/dist/core/router/types/buildedRouter.d.ts

@@ -1,13 +1,3 @@
-import { type createStepFunctionBuilder, type createRouteFunctionBuilder } from "../../functionsBuilders";
-import { type HookHubLifeCycle } from "../../hub";
 import { type RequestInitializationData } from "../../request";
-import { type HookRouteLifeCycle, type Route } from "../../route";
-export type RouterInitializationData = Omit<RequestInitializationData, "matchedPath" | "bodyReader" | "params" | "path" | "query">;
-export interface BuildedRouter {
-    exec(initializationData: RouterInitializationData): Promise<void>;
-    readonly routes: ReadonlySet<Route>;
-    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
-    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
-    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
-    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
-}
+export type RouterParams = Omit<RequestInitializationData, "matchedPath" | "bodyReader" | "params" | "path" | "query">;
+export type BuildedRouter = (params: RouterParams) => Promise<void>;

package/dist/core/router/types/index.cjs

@@ -1,4 +1,8 @@
 'use strict';
 
 require('./buildedRouter.cjs');
+require('./router.cjs');
+require('./routerElement.cjs');
+require('./routerElementSystem.cjs');
+require('./routerElementWrapper.cjs');
 

package/dist/core/router/types/index.d.ts

@@ -1 +1,5 @@
 export * from "./buildedRouter";
+export * from "./router";
+export * from "./routerElement";
+export * from "./routerElementSystem";
+export * from "./routerElementWrapper";

package/dist/core/router/types/index.mjs

@@ -1 +1,5 @@
 import './buildedRouter.mjs';
+import './router.mjs';
+import './routerElement.mjs';
+import './routerElementSystem.mjs';
+import './routerElementWrapper.mjs';

package/dist/core/router/types/router.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/router.d.ts

@@ -0,0 +1,12 @@
+import { type createRouteFunctionBuilder, type createStepFunctionBuilder } from "../../functionsBuilders";
+import { type HookHubLifeCycle } from "../../hub";
+import { type HookRouteLifeCycle, type Route } from "../../route";
+import { type BuildedRouter } from "./buildedRouter";
+export interface Router {
+    exec: BuildedRouter;
+    readonly routes: ReadonlySet<Route>;
+    readonly hooksRouteLifeCycle: readonly HookRouteLifeCycle[];
+    readonly routeFunctionBuilders: readonly ReturnType<typeof createRouteFunctionBuilder>[];
+    readonly stepFunctionBuilders: readonly ReturnType<typeof createStepFunctionBuilder>[];
+    readonly hooksHubLifeCycle: readonly HookHubLifeCycle[];
+}

package/dist/core/router/types/router.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElement.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElement.d.ts

@@ -0,0 +1,8 @@
+import { type BodyReader } from "../../request";
+import { type BuildedRoute } from "../../route/types";
+export interface RouterElement {
+    readonly pattern: RegExp;
+    readonly matchedPath: string;
+    readonly bodyReader: BodyReader;
+    readonly buildedRoute: BuildedRoute;
+}

package/dist/core/router/types/routerElement.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElementSystem.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElementSystem.d.ts

@@ -0,0 +1,6 @@
+import { type BodyReader } from "../../request";
+import { type BuildedRoute } from "../../route/types";
+export interface RouterElementSystem {
+    readonly bodyReader: BodyReader;
+    readonly buildedRoute: BuildedRoute;
+}

package/dist/core/router/types/routerElementSystem.mjs

@@ -0,0 +1 @@
+

package/dist/core/router/types/routerElementWrapper.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/core/router/types/routerElementWrapper.d.ts

@@ -0,0 +1,2 @@
+import { type RouterElement } from "./routerElement";
+export type RouterElementWrapper = Record<string, RouterElement[]>;

package/dist/core/router/types/routerElementWrapper.mjs

@@ -0,0 +1 @@
+

package/dist/core/steps/cut.d.ts

@@ -3,12 +3,11 @@ import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type StepFunctionParams } from "./types";
 import { type PredictedResponse, type ResponseContract } from "../response";
-import { type Request } from "../request";
 import { type Metadata } from "../metadata";
 export declare const cutStepOutputKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-output", unknown>>;
 export interface CutStepFunctionOutput<GenericData extends Record<string, unknown> = Record<string, unknown>> extends Kind<typeof cutStepOutputKind.definition>, WrappedValue<GenericData> {
 }
-export interface CutStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericRequest, GenericResponse> {
+export interface CutStepFunctionParams<GenericResponse extends PredictedResponse = PredictedResponse> extends StepFunctionParams<GenericResponse> {
     output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
 }
 export interface CutStepDefinition {

package/dist/core/steps/handler.d.ts

@@ -2,7 +2,6 @@ import { type MaybePromise, type Kind, type MaybeArray } from "@duplojs/utils";
 import { type StepKind } from "./kind";
 import { type Floor } from "../floor";
 import { type ServerSentEventsPredictedResponse, type PredictedResponse, type ResponseContract } from "../response";
-import { type Request } from "../request";
 import { type StepFunctionParams } from "./types";
 import { type Metadata } from "../metadata";
 interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse extends ServerSentEventsPredictedResponse> {
@@ -10,7 +9,7 @@ interface HandlerStepFunctionParamsServerSentEventsResponse<GenericResponse exte
         information: GenericInformation;
     }>>(information: GenericInformation, startSendingEvents: GenericFilteredResponse["startSendingEvents"]): GenericFilteredResponse;
 }
-export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<GenericRequest, Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
+export interface HandlerStepFunctionParams<GenericResponse extends PredictedResponse | ServerSentEventsPredictedResponse = PredictedResponse | ServerSentEventsPredictedResponse> extends StepFunctionParams<Extract<GenericResponse, PredictedResponse>>, HandlerStepFunctionParamsServerSentEventsResponse<Extract<GenericResponse, ServerSentEventsPredictedResponse>> {
 }
 export interface HandlerStepDefinition {
     theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<PredictedResponse | ServerSentEventsPredictedResponse>;

package/dist/core/steps/types/stepFunctionParams.d.ts

@@ -1,8 +1,8 @@
 import { type Request } from "../../request";
 import { type PredictedResponse } from "../../response";
 import { type IsEqual, type Or } from "@duplojs/utils";
-export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends PredictedResponse = PredictedResponse> {
-    request: GenericRequest;
+export interface StepFunctionParams<GenericResponse extends PredictedResponse = PredictedResponse> {
+    request: Request;
     response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
         information: GenericInformation;
     }>>(information: GenericInformation, ...args: Or<[

package/dist/interfaces/node/createHttpServer.cjs

@@ -24,8 +24,8 @@ function createHttpServer(hub, params) {
         index.createTextBodyReaderImplementation(httpServerParams),
         index$1.createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    function whenUncaughtError(error, routerInitializationData) {
-        const serverResponse = routerInitializationData.raw.response;
+    function whenUncaughtError(error, routerParams) {
+        const serverResponse = routerParams.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",

package/dist/interfaces/node/createHttpServer.mjs

@@ -22,8 +22,8 @@ function createHttpServer(hub, params) {
         createTextBodyReaderImplementation(httpServerParams),
         createFormDataBodyReaderImplementation(httpServerParams),
     ]);
-    function whenUncaughtError(error, routerInitializationData) {
-        const serverResponse = routerInitializationData.raw.response;
+    function whenUncaughtError(error, routerParams) {
+        const serverResponse = routerParams.raw.response;
         if (!serverResponse.headersSent && !serverResponse.writableEnded) {
             serverResponse.writeHead(500, {
                 [httpServerParams.informationHeaderKey]: "critical-server-error",

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

@@ -1,7 +1,7 @@
 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>;
+    readonly beforeSendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter) => import("../../../core/route").RouteHookExit;
+    readonly sendResponse: ({ request, currentResponse, exit }: import("../../../core/route").RouteHookParamsAfter) => Promise<import("../../../core/route").RouteHookExit>;
+    readonly afterSendResponse: ({ request, next }: import("../../../core/route").RouteHookParamsAfter) => Promise<import("../../../core/route").RouteHookNext>;
 };

package/dist/plugins/cacheController/hooks.cjs

@@ -12,7 +12,8 @@ function createCacheControllerHooks(params) {
     return hooks.createHookRouteLifeCycle({
         beforeSendResponse: ({ currentResponse, next }) => {
             if (cacheControl
-                && eligibleCodeRegex.test(currentResponse.code)) {
+                && eligibleCodeRegex.test(currentResponse.code)
+                && currentResponse.headers?.["cache-control"] === undefined) {
                 currentResponse.setHeader("cache-control", cacheControl);
             }
             return next();

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

@@ -1,4 +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;
+    readonly beforeSendResponse: ({ currentResponse, next }: import("../../core/route").RouteHookParamsAfter) => import("../../core/route").RouteHookNext;
 };

package/dist/plugins/cacheController/hooks.mjs

@@ -10,7 +10,8 @@ function createCacheControllerHooks(params) {
     return createHookRouteLifeCycle({
         beforeSendResponse: ({ currentResponse, next }) => {
             if (cacheControl
-                && eligibleCodeRegex.test(currentResponse.code)) {
+                && eligibleCodeRegex.test(currentResponse.code)
+                && currentResponse.headers?.["cache-control"] === undefined) {
                 currentResponse.setHeader("cache-control", cacheControl);
             }
             return next();

package/dist/plugins/cors/headerFunctions/allowHeaders.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const allowHeadersFunction = {
+    default(allowHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-headers", allowHeaders);
+        };
+    },
+};
+
+exports.allowHeadersFunction = allowHeadersFunction;

package/dist/plugins/cors/headerFunctions/allowHeaders.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const allowHeadersFunction: {
+    default(allowHeaders: string): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/allowHeaders.mjs

@@ -0,0 +1,9 @@
+const allowHeadersFunction = {
+    default(allowHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-headers", allowHeaders);
+        };
+    },
+};
+
+export { allowHeadersFunction };

package/dist/plugins/cors/headerFunctions/allowMethods.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+const allowMethodsFunction = {
+    default(methods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", methods);
+        };
+    },
+    isBool(allowMethods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", allowMethods[request.path]);
+        };
+    },
+};
+
+exports.allowMethodsFunction = allowMethodsFunction;

package/dist/plugins/cors/headerFunctions/allowMethods.d.ts

@@ -0,0 +1,6 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const allowMethodsFunction: {
+    default(methods: string): (request: Request, response: Response) => void;
+    isBool(allowMethods: Record<string, string>): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/allowMethods.mjs

@@ -0,0 +1,14 @@
+const allowMethodsFunction = {
+    default(methods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", methods);
+        };
+    },
+    isBool(allowMethods) {
+        return (request, response) => {
+            response.setHeader("access-control-allow-methods", allowMethods[request.path]);
+        };
+    },
+};
+
+export { allowMethodsFunction };

package/dist/plugins/cors/headerFunctions/allowOrigin.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const allowOriginFunction = {
+    default(allowOrigin) {
+        return (request, response) => {
+            if (allowOrigin.test(request.origin)) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+    isFunction(allowOrigin) {
+        return async (request, response) => {
+            let result = allowOrigin(request.origin);
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            if (result === true) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+};
+
+exports.allowOriginFunction = allowOriginFunction;

package/dist/plugins/cors/headerFunctions/allowOrigin.d.ts

@@ -0,0 +1,7 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+import type { MaybePromise } from "@duplojs/utils";
+export declare const allowOriginFunction: {
+    default(allowOrigin: RegExp): (request: Request, response: Response) => void;
+    isFunction(allowOrigin: (origin: string) => MaybePromise<boolean>): (request: Request, response: Response) => Promise<void>;
+};

package/dist/plugins/cors/headerFunctions/allowOrigin.mjs

@@ -0,0 +1,22 @@
+const allowOriginFunction = {
+    default(allowOrigin) {
+        return (request, response) => {
+            if (allowOrigin.test(request.origin)) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+    isFunction(allowOrigin) {
+        return async (request, response) => {
+            let result = allowOrigin(request.origin);
+            if (result instanceof Promise) {
+                result = await result;
+            }
+            if (result === true) {
+                response.setHeader("access-control-allow-origin", request.origin);
+            }
+        };
+    },
+};
+
+export { allowOriginFunction };

package/dist/plugins/cors/headerFunctions/credentials.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const credentialsFunction = {
+    default() {
+        return (request, response) => {
+            response.setHeader("access-control-allow-credentials", "true");
+        };
+    },
+};
+
+exports.credentialsFunction = credentialsFunction;

package/dist/plugins/cors/headerFunctions/credentials.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const credentialsFunction: {
+    default(): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/credentials.mjs

@@ -0,0 +1,9 @@
+const credentialsFunction = {
+    default() {
+        return (request, response) => {
+            response.setHeader("access-control-allow-credentials", "true");
+        };
+    },
+};
+
+export { credentialsFunction };

package/dist/plugins/cors/headerFunctions/exposeHeaders.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const exposeHeadersFunction = {
+    default(exposeHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-expose-headers", exposeHeaders);
+        };
+    },
+};
+
+exports.exposeHeadersFunction = exposeHeadersFunction;

package/dist/plugins/cors/headerFunctions/exposeHeaders.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const exposeHeadersFunction: {
+    default(exposeHeaders: string): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/exposeHeaders.mjs

@@ -0,0 +1,9 @@
+const exposeHeadersFunction = {
+    default(exposeHeaders) {
+        return (request, response) => {
+            response.setHeader("access-control-expose-headers", exposeHeaders);
+        };
+    },
+};
+
+export { exposeHeadersFunction };

package/dist/plugins/cors/headerFunctions/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var allowHeaders = require('./allowHeaders.cjs');
+var allowMethods = require('./allowMethods.cjs');
+var allowOrigin = require('./allowOrigin.cjs');
+var credentials = require('./credentials.cjs');
+var exposeHeaders = require('./exposeHeaders.cjs');
+var maxAge = require('./maxAge.cjs');
+var vary = require('./vary.cjs');
+
+
+
+exports.allowHeadersFunction = allowHeaders.allowHeadersFunction;
+exports.allowMethodsFunction = allowMethods.allowMethodsFunction;
+exports.allowOriginFunction = allowOrigin.allowOriginFunction;
+exports.credentialsFunction = credentials.credentialsFunction;
+exports.exposeHeadersFunction = exposeHeaders.exposeHeadersFunction;
+exports.maxAgeFunction = maxAge.maxAgeFunction;
+exports.varyFunction = vary.varyFunction;

package/dist/plugins/cors/headerFunctions/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./allowHeaders";
+export * from "./allowMethods";
+export * from "./allowOrigin";
+export * from "./credentials";
+export * from "./exposeHeaders";
+export * from "./maxAge";
+export * from "./vary";

package/dist/plugins/cors/headerFunctions/index.mjs

@@ -0,0 +1,7 @@
+export { allowHeadersFunction } from './allowHeaders.mjs';
+export { allowMethodsFunction } from './allowMethods.mjs';
+export { allowOriginFunction } from './allowOrigin.mjs';
+export { credentialsFunction } from './credentials.mjs';
+export { exposeHeadersFunction } from './exposeHeaders.mjs';
+export { maxAgeFunction } from './maxAge.mjs';
+export { varyFunction } from './vary.mjs';

package/dist/plugins/cors/headerFunctions/maxAge.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const maxAgeFunction = {
+    default(maxAge) {
+        return (request, response) => {
+            response.setHeader("access-control-max-age", maxAge);
+        };
+    },
+};
+
+exports.maxAgeFunction = maxAgeFunction;

package/dist/plugins/cors/headerFunctions/maxAge.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const maxAgeFunction: {
+    default(maxAge: string): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/maxAge.mjs

@@ -0,0 +1,9 @@
+const maxAgeFunction = {
+    default(maxAge) {
+        return (request, response) => {
+            response.setHeader("access-control-max-age", maxAge);
+        };
+    },
+};
+
+export { maxAgeFunction };

package/dist/plugins/cors/headerFunctions/vary.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const starRegex = /(^|,) *\* *(?=,|$)/;
+const originRegex = /(^|,) *origin *(?=,|$)/i;
+const varyFunction = {
+    default() {
+        const maxStoreSize = 500;
+        const store = new Map();
+        return (request, response) => {
+            const cachedVary = store.get(request.origin);
+            if (cachedVary) {
+                response.setHeader("vary", cachedVary);
+                return;
+            }
+            let varyValue = Array.isArray(response.headers?.vary)
+                ? response.headers.vary.join(", ")
+                : response.headers?.vary;
+            if (varyValue === undefined) {
+                varyValue = "Origin";
+            }
+            else if (starRegex.test(varyValue)) {
+                varyValue = "*";
+            }
+            else if (!originRegex.test(varyValue)) {
+                varyValue = `${varyValue}, Origin`;
+            }
+            if (store.size < maxStoreSize) {
+                store.set(request.origin, varyValue);
+            }
+            response.setHeader("vary", varyValue);
+        };
+    },
+};
+
+exports.varyFunction = varyFunction;

package/dist/plugins/cors/headerFunctions/vary.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from "../../../core/request";
+import type { Response } from "../../../core/response";
+export declare const varyFunction: {
+    default(): (request: Request, response: Response) => void;
+};

package/dist/plugins/cors/headerFunctions/vary.mjs

@@ -0,0 +1,33 @@
+const starRegex = /(^|,) *\* *(?=,|$)/;
+const originRegex = /(^|,) *origin *(?=,|$)/i;
+const varyFunction = {
+    default() {
+        const maxStoreSize = 500;
+        const store = new Map();
+        return (request, response) => {
+            const cachedVary = store.get(request.origin);
+            if (cachedVary) {
+                response.setHeader("vary", cachedVary);
+                return;
+            }
+            let varyValue = Array.isArray(response.headers?.vary)
+                ? response.headers.vary.join(", ")
+                : response.headers?.vary;
+            if (varyValue === undefined) {
+                varyValue = "Origin";
+            }
+            else if (starRegex.test(varyValue)) {
+                varyValue = "*";
+            }
+            else if (!originRegex.test(varyValue)) {
+                varyValue = `${varyValue}, Origin`;
+            }
+            if (store.size < maxStoreSize) {
+                store.set(request.origin, varyValue);
+            }
+            response.setHeader("vary", varyValue);
+        };
+    },
+};
+
+export { varyFunction };

package/dist/plugins/cors/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var metadata = require('./metadata.cjs');
+var plugin = require('./plugin.cjs');
+
+
+
+exports.IgnoreRouteCorsMetadata = metadata.IgnoreRouteCorsMetadata;
+exports.corsPlugin = plugin.corsPlugin;

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

@@ -0,0 +1,2 @@
+export * from "./metadata";
+export * from "./plugin";

package/dist/plugins/cors/index.mjs

@@ -0,0 +1,2 @@
+export { IgnoreRouteCorsMetadata } from './metadata.mjs';
+export { corsPlugin } from './plugin.mjs';

package/dist/plugins/cors/metadata.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('../../core/metadata/index.cjs');
+var base = require('../../core/metadata/base.cjs');
+
+const IgnoreRouteCorsMetadata = base.createMetadata("ignore-by-cors");
+
+exports.IgnoreRouteCorsMetadata = IgnoreRouteCorsMetadata;

package/dist/plugins/cors/metadata.d.ts

@@ -0,0 +1 @@
+export declare const IgnoreRouteCorsMetadata: import("../../core/metadata").MetadataHandler<"ignore-by-cors", unknown>;

package/dist/plugins/cors/metadata.mjs

@@ -0,0 +1,6 @@
+import '../../core/metadata/index.mjs';
+import { createMetadata } from '../../core/metadata/base.mjs';
+
+const IgnoreRouteCorsMetadata = createMetadata("ignore-by-cors");
+
+export { IgnoreRouteCorsMetadata };