@duplojs/http 0.8.5 → 0.9.5

package/dist/core/index.cjs

@@ -13,13 +13,13 @@ var index$2 = require('./request/index.cjs');
 var presetChecker$1 = require('./presetChecker.cjs');
 var index$3 = require('./hub/index.cjs');
 require('./functionsBuilders/index.cjs');
-var index$4 = require('./router/index.cjs');
+var index$6 = require('./router/index.cjs');
 var stringIdentifier = require('./stringIdentifier.cjs');
 require('./metadata/index.cjs');
 var implementHttpServer = require('./implementHttpServer.cjs');
 var narrowingInput = require('./narrowingInput.cjs');
 require('./clean/index.cjs');
-var index$5 = require('./defaultHooks/index.cjs');
+var index$7 = require('./defaultHooks/index.cjs');
 require('./errors/index.cjs');
 var serverSentEvents = require('./serverSentEvents.cjs');
 var checker = require('./builders/checker.cjs');
@@ -53,8 +53,8 @@ var defaultMalformedUrlHandler = require('./hub/defaultMalformedUrlHandler.cjs')
 var defaultEmptyReaderImplementation = require('./hub/defaultEmptyReaderImplementation.cjs');
 var build = require('./functionsBuilders/route/build.cjs');
 var create = require('./functionsBuilders/route/create.cjs');
-var _default = require('./functionsBuilders/route/default.cjs');
-var hook$1 = require('./functionsBuilders/route/hook.cjs');
+var hook$1 = require('./functionsBuilders/route/default/hook.cjs');
+var index$4 = require('./functionsBuilders/route/default/index.cjs');
 var create$1 = require('./functionsBuilders/steps/create.cjs');
 var checkerStep = require('./functionsBuilders/steps/defaults/checkerStep.cjs');
 var cutStep = require('./functionsBuilders/steps/defaults/cutStep.cjs');
@@ -62,11 +62,13 @@ var handlerStep = require('./functionsBuilders/steps/defaults/handlerStep.cjs');
 var extractStep = require('./functionsBuilders/steps/defaults/extractStep.cjs');
 var processStep = require('./functionsBuilders/steps/defaults/processStep.cjs');
 var build$1 = require('./functionsBuilders/steps/build.cjs');
+var create$2 = require('./functionsBuilders/router/create.cjs');
+var index$5 = require('./functionsBuilders/router/default/index.cjs');
+var build$2 = require('./functionsBuilders/router/build.cjs');
 var pathToRegExp = require('./router/pathToRegExp.cjs');
 var buildError = require('./router/buildError.cjs');
-var decodeUrl = require('./router/decodeUrl.cjs');
 var notFoundBodyReaderImplementationError = require('./router/notFoundBodyReaderImplementationError.cjs');
-var buildSystemRoute = require('./router/buildSystemRoute.cjs');
+var createRouterElementSystem = require('./router/createRouterElementSystem.cjs');
 var base$2 = require('./metadata/base.cjs');
 var ignoreByRouteStore = require('./metadata/ignoreByRouteStore.cjs');
 var wrongContentTypeError = require('./errors/wrongContentTypeError.cjs');
@@ -90,11 +92,11 @@ exports.presetCheckerKind = presetChecker$1.presetCheckerKind;
 exports.Hub = index$3.Hub;
 exports.createHub = index$3.createHub;
 exports.hubKind = index$3.hubKind;
-exports.buildRouter = index$4.buildRouter;
+exports.createRouter = index$6.createRouter;
 exports.createCoreLibStringIdentifier = stringIdentifier.createCoreLibStringIdentifier;
 exports.implementHttpServer = implementHttpServer.implementHttpServer;
 exports.createNarrowingInput = narrowingInput.createNarrowingInput;
-exports.initDefaultHook = index$5.initDefaultHook;
+exports.initDefaultHook = index$7.initDefaultHook;
 Object.defineProperty(exports, "ServerSentEvents", {
 	enumerable: true,
 	get: function () { return serverSentEvents.ServerSentEvents; }
@@ -118,7 +120,6 @@ exports.PredictedResponse = predicted.PredictedResponse;
 exports.ServerSentEventsPredictedResponse = serverSentEventsPredicted.ServerSentEventsPredictedResponse;
 exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
 exports.hookRouteExitKind = hooks.hookRouteExitKind;
-exports.hookRouteLifeCycleAddRequestProperties = hooks.hookRouteLifeCycleAddRequestProperties;
 exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.stepKind = kind.stepKind;
 exports.stepIdentifier = identifier.stepIdentifier;
@@ -158,13 +159,13 @@ exports.defaultMalformedUrlHandler = defaultMalformedUrlHandler.defaultMalformed
 exports.defaultEmptyReaderImplementation = defaultEmptyReaderImplementation.defaultEmptyReaderImplementation;
 exports.buildRouteFunction = build.buildRouteFunction;
 exports.createRouteFunctionBuilder = create.createRouteFunctionBuilder;
-exports.defaultRouteFunctionBuilder = _default.defaultRouteFunctionBuilder;
 exports.buildHookAfter = hook$1.buildHookAfter;
 exports.buildHookBefore = hook$1.buildHookBefore;
 exports.buildHookErrorBefore = hook$1.buildHookErrorBefore;
 exports.createHookResponse = hook$1.createHookResponse;
 exports.exitHookFunction = hook$1.exitHookFunction;
 exports.nextHookFunction = hook$1.nextHookFunction;
+exports.defaultRouteFunctionBuilder = index$4.defaultRouteFunctionBuilder;
 exports.createStepFunctionBuilder = create$1.createStepFunctionBuilder;
 exports.defaultCheckerStepFunctionBuilder = checkerStep.defaultCheckerStepFunctionBuilder;
 exports.defaultCutStepFunctionBuilder = cutStep.defaultCutStepFunctionBuilder;
@@ -173,13 +174,13 @@ exports.defaultExtractStepFunctionBuilder = extractStep.defaultExtractStepFuncti
 exports.buildStepsFunction = processStep.buildStepsFunction;
 exports.defaultProcessStepFunctionBuilder = processStep.defaultProcessStepFunctionBuilder;
 exports.buildStepFunction = build$1.buildStepFunction;
+exports.createRouterFunctionBuilder = create$2.createRouterFunctionBuilder;
+exports.defaultRouterFunctionBuilder = index$5.defaultRouterFunctionBuilder;
+exports.buildRouterFunction = build$2.buildRouterFunction;
 exports.pathToRegExp = pathToRegExp.pathToRegExp;
 exports.RouterBuildError = buildError.RouterBuildError;
-exports.decodeUrl = decodeUrl.decodeUrl;
-exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
-exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
 exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
-exports.buildSystemRoute = buildSystemRoute.buildSystemRoute;
+exports.createRouterElementSystem = createRouterElementSystem.createRouterElementSystem;
 exports.createMetadata = base$2.createMetadata;
 exports.metadataKind = base$2.metadataKind;
 exports.IgnoreByRouteStoreMetadata = ignoreByRouteStore.IgnoreByRouteStoreMetadata;

package/dist/core/index.mjs

@@ -11,7 +11,7 @@ export { Request } from './request/index.mjs';
 export { createPresetChecker, presetCheckerKind } from './presetChecker.mjs';
 export { Hub, createHub, hubKind } from './hub/index.mjs';
 import './functionsBuilders/index.mjs';
-export { buildRouter } from './router/index.mjs';
+export { createRouter } from './router/index.mjs';
 export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
 import './metadata/index.mjs';
 export { implementHttpServer } from './implementHttpServer.mjs';
@@ -30,7 +30,7 @@ export { ResponseContract } from './response/contract.mjs';
 export { HookResponse } from './response/hook.mjs';
 export { PredictedResponse } from './response/predicted.mjs';
 export { ServerSentEventsPredictedResponse } from './response/serverSentEventsPredicted.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind } from './route/hooks.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks.mjs';
 export { stepKind } from './steps/kind.mjs';
 export { stepIdentifier } from './steps/identifier.mjs';
 export { checkerStepKind, createCheckerStep } from './steps/checker.mjs';
@@ -51,8 +51,8 @@ export { defaultMalformedUrlHandler } from './hub/defaultMalformedUrlHandler.mjs
 export { defaultEmptyReaderImplementation } from './hub/defaultEmptyReaderImplementation.mjs';
 export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
 export { createRouteFunctionBuilder } from './functionsBuilders/route/create.mjs';
-export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default.mjs';
-export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './functionsBuilders/route/hook.mjs';
+export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './functionsBuilders/route/default/hook.mjs';
+export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default/index.mjs';
 export { createStepFunctionBuilder } from './functionsBuilders/steps/create.mjs';
 export { defaultCheckerStepFunctionBuilder } from './functionsBuilders/steps/defaults/checkerStep.mjs';
 export { defaultCutStepFunctionBuilder } from './functionsBuilders/steps/defaults/cutStep.mjs';
@@ -60,11 +60,13 @@ export { defaultHandlerStepFunctionBuilder } from './functionsBuilders/steps/def
 export { defaultExtractStepFunctionBuilder } from './functionsBuilders/steps/defaults/extractStep.mjs';
 export { buildStepsFunction, defaultProcessStepFunctionBuilder } from './functionsBuilders/steps/defaults/processStep.mjs';
 export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
+export { createRouterFunctionBuilder } from './functionsBuilders/router/create.mjs';
+export { defaultRouterFunctionBuilder } from './functionsBuilders/router/default/index.mjs';
+export { buildRouterFunction } from './functionsBuilders/router/build.mjs';
 export { pathToRegExp } from './router/pathToRegExp.mjs';
 export { RouterBuildError } from './router/buildError.mjs';
-export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser } from './router/decodeUrl.mjs';
 export { NotFoundBodyReaderImplementationError } from './router/notFoundBodyReaderImplementationError.mjs';
-export { buildSystemRoute } from './router/buildSystemRoute.mjs';
+export { createRouterElementSystem } from './router/createRouterElementSystem.mjs';
 export { createMetadata, metadataKind } from './metadata/base.mjs';
 export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';
 export { WrongContentTypeError } from './errors/wrongContentTypeError.mjs';

package/dist/core/process/index.d.ts

@@ -2,30 +2,23 @@ import { type IsEqual, type Kind, type O } from "@duplojs/utils";
 import { type ProcessStep, type CheckerStep, type CutStep, type ExtractStep, type stepKind, type PresetCheckerStep } from "../steps";
 import { type Floor } from "../floor";
 import { type HookRouteLifeCycle } from "../route";
-import { type Request } from "../request";
 import { type Metadata } from "../metadata";
 export * from "./types";
 export interface ProcessStepsCustom {
 }
 export type ProcessSteps = (ProcessStepsCustom[O.GetPropsWithValueExtends<ProcessStepsCustom, Kind<typeof stepKind.definition>>] | CheckerStep | ExtractStep | PresetCheckerStep | CutStep | ProcessStep);
 declare const SymbolProcessExportValue: unique symbol;
-declare const SymbolProcessRequest: unique symbol;
 export interface ProcessDefinition {
     steps: readonly ProcessSteps[];
     options?: Record<string, unknown>;
     readonly hooks: readonly HookRouteLifeCycle[];
     readonly metadata: readonly Metadata[];
     [SymbolProcessExportValue]?: Floor;
-    [SymbolProcessRequest]?: Request;
 }
 export interface ProcessExportValue<GenericExportValue extends Floor> {
     [SymbolProcessExportValue]: GenericExportValue;
 }
 export type GetProcessExportValue<GenericProcess extends Process> = IsEqual<GenericProcess["definition"][typeof SymbolProcessExportValue], unknown> extends true ? never : GenericProcess["definition"][typeof SymbolProcessExportValue];
-export interface ProcessRequest<GenericRequest extends Request> {
-    [SymbolProcessRequest]: GenericRequest;
-}
-export type GetProcessRequest<GenericProcess extends Process> = IsEqual<GenericProcess["definition"][typeof SymbolProcessRequest], unknown> extends true ? never : GenericProcess["definition"][typeof SymbolProcessRequest];
 export declare const processKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process", unknown>>;
 export interface Process<GenericDefinition extends ProcessDefinition = ProcessDefinition> extends Kind<typeof processKind.definition> {
     definition: GenericDefinition;

package/dist/core/route/hooks.cjs

@@ -4,25 +4,10 @@ var kind = require('../kind.cjs');
 
 const hookRouteExitKind = kind.createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = kind.createCoreLibKind("route-hook-next");
-function createHookRouteLifeCycle(...args) {
-    if (args.length === 1) {
-        return args[0];
-    }
-    return {
-        ...args[1],
-        onConstructRequest: args[0],
-    };
-}
-function hookRouteLifeCycleAddRequestProperties(request) {
-    return (newProperties) => {
-        for (const key in newProperties) {
-            request[key] = newProperties[key];
-        }
-        return request;
-    };
+function createHookRouteLifeCycle(hookRouteLifeCycle) {
+    return hookRouteLifeCycle;
 }
 
 exports.createHookRouteLifeCycle = createHookRouteLifeCycle;
 exports.hookRouteExitKind = hookRouteExitKind;
-exports.hookRouteLifeCycleAddRequestProperties = hookRouteLifeCycleAddRequestProperties;
 exports.hookRouteNextKind = hookRouteNextKind;

package/dist/core/route/hooks.d.ts

@@ -1,25 +1,20 @@
 import { type Request } from "../request";
-import { type UnionToIntersection, type AnyFunction, type Kind, type MaybePromise, type SimplifyTopLevel, type IsEqual, type BivariantFunction } from "@duplojs/utils";
+import { type Kind, type MaybePromise } from "@duplojs/utils";
 import { type HookResponse } from "../response";
 import { type ResponseCode, type Response } from "../response";
-export interface HookParamsOnConstructRequest {
-    request: Request;
-    addRequestProperties<GenericNewProperties extends Record<string, unknown>>(newProperties: GenericNewProperties): Request & GenericNewProperties;
-}
-export type HookOnConstructRequest<GenericRequest extends Request = Request> = (params: HookParamsOnConstructRequest) => MaybePromise<GenericRequest>;
 export declare const hookRouteExitKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-exit", unknown>>;
 export interface RouteHookExit extends Kind<typeof hookRouteExitKind.definition> {
 }
 export declare const hookRouteNextKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route-hook-next", unknown>>;
 export interface RouteHookNext extends Kind<typeof hookRouteNextKind.definition> {
 }
-export interface RouteHookParams<GenericRequest extends Request = Request> {
-    readonly request: GenericRequest;
+export interface RouteHookParams {
+    readonly request: Request;
     next(): RouteHookNext;
     exit(): RouteHookExit;
     response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown>(code: GenericCode, information: GenericInformation, body?: GenericBody): HookResponse<GenericCode, GenericInformation, GenericBody | undefined>;
 }
-export type HookBeforeRouteExecution<GenericRequest extends Request = Request> = (params: RouteHookParams<GenericRequest>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
+export type HookBeforeRouteExecution = (params: RouteHookParams) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
 export interface RouteHookErrorParams<GenericRequest extends Request = Request> {
     readonly request: GenericRequest;
     readonly error: unknown;
@@ -28,32 +23,20 @@ export interface RouteHookErrorParams<GenericRequest extends Request = Request>
     response<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown>(code: GenericCode, information: GenericInformation, body?: GenericBody): HookResponse<GenericCode, GenericInformation, GenericBody | undefined>;
 }
 export type HookError = (params: RouteHookErrorParams<Request>) => MaybePromise<HookResponse | RouteHookExit | RouteHookNext>;
-export interface RouteHookParamsAfter<GenericRequest extends Request = Request> {
-    readonly request: GenericRequest;
+export interface RouteHookParamsAfter {
+    readonly request: Request;
     readonly currentResponse: Response;
     next(): RouteHookNext;
     exit(): RouteHookExit;
 }
-export type HookBeforeSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
-export type HookSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
-export type HookAfterSendResponse<GenericRequest extends Request = Request> = (params: RouteHookParamsAfter<GenericRequest>) => MaybePromise<RouteHookExit | RouteHookNext>;
-export interface HookRouteLifeCycle<GenericRequest extends Request = Request> {
-    onConstructRequest?: BivariantFunction<HookOnConstructRequest<GenericRequest>>;
-    beforeRouteExecution?: BivariantFunction<HookBeforeRouteExecution<GenericRequest>>;
+export type HookBeforeSendResponse = (params: RouteHookParamsAfter) => MaybePromise<RouteHookExit | RouteHookNext>;
+export type HookSendResponse = (params: RouteHookParamsAfter) => MaybePromise<RouteHookExit | RouteHookNext>;
+export type HookAfterSendResponse = (params: RouteHookParamsAfter) => MaybePromise<RouteHookExit | RouteHookNext>;
+export interface HookRouteLifeCycle {
+    beforeRouteExecution?: HookBeforeRouteExecution;
     error?: HookError;
-    beforeSendResponse?: BivariantFunction<HookBeforeSendResponse<GenericRequest>>;
-    sendResponse?: BivariantFunction<HookSendResponse<GenericRequest>>;
-    afterSendResponse?: BivariantFunction<HookAfterSendResponse<GenericRequest>>;
+    beforeSendResponse?: HookBeforeSendResponse;
+    sendResponse?: HookSendResponse;
+    afterSendResponse?: HookAfterSendResponse;
 }
-export declare function createHookRouteLifeCycle<const GenericHookLiveCycle extends Omit<HookRouteLifeCycle, "onConstructRequest">>(hookRouteLifeCycle: GenericHookLiveCycle): GenericHookLiveCycle;
-export declare function createHookRouteLifeCycle<GenericOnConstructRequest extends HookOnConstructRequest, const GenericHookLiveCycle extends Omit<HookRouteLifeCycle<Awaited<ReturnType<GenericOnConstructRequest>>>, "onConstructRequest">>(onConstructRequest: GenericOnConstructRequest, hookRouteLifeCycle: GenericHookLiveCycle): SimplifyTopLevel<{
-    readonly onConstructRequest: GenericOnConstructRequest;
-} & GenericHookLiveCycle>;
-export declare function hookRouteLifeCycleAddRequestProperties<GenericRequest extends Request = Request>(request: GenericRequest): <GenericNewProperties extends Record<string, unknown> = Record<string, unknown>>(newProperties: GenericNewProperties) => never;
-export type ExtractRequestFromHooks<GenericHooks extends readonly HookRouteLifeCycle[]> = GenericHooks extends readonly [
-    infer InferredFirst,
-    ...infer InferredRest extends HookRouteLifeCycle[]
-] ? (InferredFirst extends {
-    onConstructRequest: AnyFunction;
-} ? Awaited<ReturnType<InferredFirst["onConstructRequest"]>> : never) extends infer InferredResultFirst ? InferredRest extends readonly [] ? InferredResultFirst : ExtractRequestFromHooks<InferredRest> extends infer InferredResultRest ? InferredResultFirst | InferredResultRest : never : never : never;
-export type MakeRequestFromHooks<GenericHooks extends readonly HookRouteLifeCycle[]> = ExtractRequestFromHooks<GenericHooks> extends infer InferredResult extends Request ? IsEqual<InferredResult, never> extends true ? never : UnionToIntersection<InferredResult> : never;
+export declare function createHookRouteLifeCycle<const GenericHookLiveCycle extends HookRouteLifeCycle>(hookRouteLifeCycle: GenericHookLiveCycle): GenericHookLiveCycle;

package/dist/core/route/hooks.mjs

@@ -2,22 +2,8 @@ import { createCoreLibKind } from '../kind.mjs';
 
 const hookRouteExitKind = createCoreLibKind("route-hook-exit");
 const hookRouteNextKind = createCoreLibKind("route-hook-next");
-function createHookRouteLifeCycle(...args) {
-    if (args.length === 1) {
-        return args[0];
-    }
-    return {
-        ...args[1],
-        onConstructRequest: args[0],
-    };
-}
-function hookRouteLifeCycleAddRequestProperties(request) {
-    return (newProperties) => {
-        for (const key in newProperties) {
-            request[key] = newProperties[key];
-        }
-        return request;
-    };
+function createHookRouteLifeCycle(hookRouteLifeCycle) {
+    return hookRouteLifeCycle;
 }
 
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind };
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind };

package/dist/core/route/index.cjs

@@ -12,7 +12,6 @@ function createRoute(definition) {
 
 exports.createHookRouteLifeCycle = hooks.createHookRouteLifeCycle;
 exports.hookRouteExitKind = hooks.hookRouteExitKind;
-exports.hookRouteLifeCycleAddRequestProperties = hooks.hookRouteLifeCycleAddRequestProperties;
 exports.hookRouteNextKind = hooks.hookRouteNextKind;
 exports.createRoute = createRoute;
 exports.routeKind = routeKind;

package/dist/core/route/index.mjs

@@ -1,7 +1,7 @@
 import { pipe } from '@duplojs/utils';
 import { createCoreLibKind } from '../kind.mjs';
 import './types/index.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteLifeCycleAddRequestProperties, hookRouteNextKind } from './hooks.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './hooks.mjs';
 
 const routeKind = createCoreLibKind("route");
 function createRoute(definition) {

package/dist/core/router/{buildSystemRoute.cjs → createRouterElementSystem.cjs}

@@ -5,11 +5,12 @@ require('../functionsBuilders/index.cjs');
 require('../request/index.cjs');
 var index = require('../route/index.cjs');
 var buildError = require('./buildError.cjs');
-var defaultEmptyReaderImplementation = require('../hub/defaultEmptyReaderImplementation.cjs');
+require('../hub/index.cjs');
 var empty = require('../request/bodyController/empty.cjs');
+var defaultEmptyReaderImplementation = require('../hub/defaultEmptyReaderImplementation.cjs');
 var build = require('../functionsBuilders/route/build.cjs');
 
-async function buildSystemRoute(params) {
+async function createRouterElementSystem(params) {
     const bodyController = empty.controlBodyAsEmpty();
     const bodyReader = bodyController.createReaderOrThrow(defaultEmptyReaderImplementation.defaultEmptyReaderImplementation);
     const route = index.createRoute({
@@ -30,4 +31,4 @@ async function buildSystemRoute(params) {
     };
 }
 
-exports.buildSystemRoute = buildSystemRoute;
+exports.createRouterElementSystem = createRouterElementSystem;

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

@@ -0,0 +1,9 @@
+import { type BuildRouteFunctionParams } from "../functionsBuilders";
+import { type HandlerStep } from "../steps";
+import { type RouterElementSystem } from "./types";
+interface CreateRouterElementSystemParams {
+    handlerStep: HandlerStep;
+    buildParams: BuildRouteFunctionParams;
+}
+export declare function createRouterElementSystem(params: CreateRouterElementSystemParams): Promise<RouterElementSystem>;
+export {};

package/dist/core/router/{buildSystemRoute.mjs → createRouterElementSystem.mjs}

@@ -3,11 +3,12 @@ import '../functionsBuilders/index.mjs';
 import '../request/index.mjs';
 import { createRoute } from '../route/index.mjs';
 import { RouterBuildError } from './buildError.mjs';
-import { defaultEmptyReaderImplementation } from '../hub/defaultEmptyReaderImplementation.mjs';
+import '../hub/index.mjs';
 import { controlBodyAsEmpty } from '../request/bodyController/empty.mjs';
+import { defaultEmptyReaderImplementation } from '../hub/defaultEmptyReaderImplementation.mjs';
 import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
 
-async function buildSystemRoute(params) {
+async function createRouterElementSystem(params) {
     const bodyController = controlBodyAsEmpty();
     const bodyReader = bodyController.createReaderOrThrow(defaultEmptyReaderImplementation);
     const route = createRoute({
@@ -28,4 +29,4 @@ async function buildSystemRoute(params) {
     };
 }
 
-export { buildSystemRoute };
+export { createRouterElementSystem };

package/dist/core/router/index.cjs

@@ -4,13 +4,11 @@ require('../hub/index.cjs');
 var utils = require('@duplojs/utils');
 var pathToRegExp = require('./pathToRegExp.cjs');
 var buildError = require('./buildError.cjs');
-require('../functionsBuilders/route/index.cjs');
-var decodeUrl = require('./decodeUrl.cjs');
 var notFoundBodyReaderImplementationError = require('./notFoundBodyReaderImplementationError.cjs');
 require('../functionsBuilders/index.cjs');
-var buildSystemRoute = require('./buildSystemRoute.cjs');
+var createRouterElementSystem = require('./createRouterElementSystem.cjs');
 require('./types/index.cjs');
-var _default = require('../functionsBuilders/route/default.cjs');
+var index = require('../functionsBuilders/route/default/index.cjs');
 var checkerStep = require('../functionsBuilders/steps/defaults/checkerStep.cjs');
 var cutStep = require('../functionsBuilders/steps/defaults/cutStep.cjs');
 var handlerStep = require('../functionsBuilders/steps/defaults/handlerStep.cjs');
@@ -18,13 +16,15 @@ var extractStep = require('../functionsBuilders/steps/defaults/extractStep.cjs')
 var processStep = require('../functionsBuilders/steps/defaults/processStep.cjs');
 var hooks = require('../hub/hooks.cjs');
 var build = require('../functionsBuilders/route/build.cjs');
+var build$1 = require('../functionsBuilders/router/build.cjs');
+var index$1 = require('../functionsBuilders/router/default/index.cjs');
 
-async function buildRouter(hub) {
+async function createRouter(hub) {
     const { environment } = hub.config;
     const { hooksRouteLifeCycle, routes, hooksHubLifeCycle, bodyReaderImplementations, } = hub;
     const routeFunctionBuilders = [
         ...hub.routeFunctionBuilders,
-        _default.defaultRouteFunctionBuilder,
+        index.defaultRouteFunctionBuilder,
     ];
     const stepFunctionBuilders = [
         ...hub.stepFunctionBuilders,
@@ -42,7 +42,7 @@ async function buildRouter(hub) {
         routeFunctionBuilders,
         defaultExtractContract: hub.defaultExtractContract,
     };
-    const groupedRoute = await utils.G.asyncReduce(routes, utils.G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
+    const routerElementWrapper = await utils.G.asyncReduce(routes, utils.G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
         const routeAfterHook = await hooks.launchHookBeforeBuildRoute(hooksBeforeBuildRoute, route);
         const buildedRoute = await build.buildRouteFunction(routeAfterHook, buildParams);
         if (utils.E.isLeft(buildedRoute)) {
@@ -62,61 +62,23 @@ async function buildRouter(hub) {
             }))),
         });
     });
-    const defaultNotfoundRoute = await buildSystemRoute.buildSystemRoute({
+    const notfoundRouterElement = await createRouterElementSystem.createRouterElementSystem({
         handlerStep: hub.notfoundHandler,
         buildParams,
     });
-    const defaultMalformedUrlRoute = await buildSystemRoute.buildSystemRoute({
+    const malformedUrlRouterElement = await createRouterElementSystem.createRouterElementSystem({
         handlerStep: hub.malformedUrlHandler,
         buildParams,
     });
-    const Request = hub.classRequest;
     return {
-        exec: (initializationData) => {
-            const routerElements = groupedRoute[initializationData.method];
-            const decodedUrl = decodeUrl.decodeUrl(initializationData.url);
-            if (!decodedUrl) {
-                return defaultMalformedUrlRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    params: {},
-                    path: "",
-                    query: {},
-                    matchedPath: null,
-                    bodyReader: defaultMalformedUrlRoute.bodyReader,
-                }));
-            }
-            if (!routerElements) {
-                return defaultNotfoundRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: {},
-                    matchedPath: null,
-                    bodyReader: defaultNotfoundRoute.bodyReader,
-                }));
-            }
-            // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index = 0; index < routerElements.length; index++) {
-                const routerElement = routerElements[index];
-                const result = routerElement.pattern.exec(decodedUrl.path);
-                if (!result) {
-                    continue;
-                }
-                return routerElement.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: result.groups ?? {},
-                    matchedPath: routerElement.matchedPath,
-                    bodyReader: routerElement.bodyReader,
-                }));
-            }
-            return defaultNotfoundRoute.buildedRoute(new Request({
-                ...initializationData,
-                ...decodedUrl,
-                params: {},
-                matchedPath: null,
-                bodyReader: defaultNotfoundRoute.bodyReader,
-            }));
-        },
+        exec: await build$1.buildRouterFunction({
+            environment: hub.config.environment,
+            routerElementWrapper,
+            notfoundRouterElement: notfoundRouterElement,
+            malformedUrlRouterElement: malformedUrlRouterElement,
+            classRequest: hub.classRequest,
+            routerFunctionBuilder: hub.routerFunctionBuilder ?? index$1.defaultRouterFunctionBuilder,
+        }),
         hooksRouteLifeCycle,
         routeFunctionBuilders,
         routes,
@@ -127,9 +89,6 @@ async function buildRouter(hub) {
 
 exports.pathToRegExp = pathToRegExp.pathToRegExp;
 exports.RouterBuildError = buildError.RouterBuildError;
-exports.decodeUrl = decodeUrl.decodeUrl;
-exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
-exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
 exports.NotFoundBodyReaderImplementationError = notFoundBodyReaderImplementationError.NotFoundBodyReaderImplementationError;
-exports.buildSystemRoute = buildSystemRoute.buildSystemRoute;
-exports.buildRouter = buildRouter;
+exports.createRouterElementSystem = createRouterElementSystem.createRouterElementSystem;
+exports.createRouter = createRouter;

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

@@ -1,9 +1,8 @@
 import { type Hub } from "../hub";
-import { type BuildedRouter } from "./types";
+import { type Router } from "./types";
 export * from "./types";
 export * from "./pathToRegExp";
 export * from "./buildError";
-export * from "./decodeUrl";
 export * from "./notFoundBodyReaderImplementationError";
-export * from "./buildSystemRoute";
-export declare function buildRouter(hub: Hub): Promise<BuildedRouter>;
+export * from "./createRouterElementSystem";
+export declare function createRouter(hub: Hub): Promise<Router>;

package/dist/core/router/index.mjs

@@ -2,14 +2,11 @@ import '../hub/index.mjs';
 import { pipe, A, isType, G, E, unwrap, justReturn, O, forward } from '@duplojs/utils';
 import { pathToRegExp } from './pathToRegExp.mjs';
 import { RouterBuildError } from './buildError.mjs';
-import '../functionsBuilders/route/index.mjs';
-import { decodeUrl } from './decodeUrl.mjs';
-export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
 import { NotFoundBodyReaderImplementationError } from './notFoundBodyReaderImplementationError.mjs';
 import '../functionsBuilders/index.mjs';
-import { buildSystemRoute } from './buildSystemRoute.mjs';
+import { createRouterElementSystem } from './createRouterElementSystem.mjs';
 import './types/index.mjs';
-import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
+import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default/index.mjs';
 import { defaultCheckerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/checkerStep.mjs';
 import { defaultCutStepFunctionBuilder } from '../functionsBuilders/steps/defaults/cutStep.mjs';
 import { defaultHandlerStepFunctionBuilder } from '../functionsBuilders/steps/defaults/handlerStep.mjs';
@@ -17,8 +14,10 @@ import { defaultExtractStepFunctionBuilder } from '../functionsBuilders/steps/de
 import { defaultProcessStepFunctionBuilder } from '../functionsBuilders/steps/defaults/processStep.mjs';
 import { launchHookBeforeBuildRoute } from '../hub/hooks.mjs';
 import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+import { buildRouterFunction } from '../functionsBuilders/router/build.mjs';
+import { defaultRouterFunctionBuilder } from '../functionsBuilders/router/default/index.mjs';
 
-async function buildRouter(hub) {
+async function createRouter(hub) {
     const { environment } = hub.config;
     const { hooksRouteLifeCycle, routes, hooksHubLifeCycle, bodyReaderImplementations, } = hub;
     const routeFunctionBuilders = [
@@ -41,7 +40,7 @@ async function buildRouter(hub) {
         routeFunctionBuilders,
         defaultExtractContract: hub.defaultExtractContract,
     };
-    const groupedRoute = await G.asyncReduce(routes, G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
+    const routerElementWrapper = await G.asyncReduce(routes, G.reduceFrom({}), async ({ lastValue, element: route, nextWithObject, }) => {
         const routeAfterHook = await launchHookBeforeBuildRoute(hooksBeforeBuildRoute, route);
         const buildedRoute = await buildRouteFunction(routeAfterHook, buildParams);
         if (E.isLeft(buildedRoute)) {
@@ -61,61 +60,23 @@ async function buildRouter(hub) {
             }))),
         });
     });
-    const defaultNotfoundRoute = await buildSystemRoute({
+    const notfoundRouterElement = await createRouterElementSystem({
         handlerStep: hub.notfoundHandler,
         buildParams,
     });
-    const defaultMalformedUrlRoute = await buildSystemRoute({
+    const malformedUrlRouterElement = await createRouterElementSystem({
         handlerStep: hub.malformedUrlHandler,
         buildParams,
     });
-    const Request = hub.classRequest;
     return {
-        exec: (initializationData) => {
-            const routerElements = groupedRoute[initializationData.method];
-            const decodedUrl = decodeUrl(initializationData.url);
-            if (!decodedUrl) {
-                return defaultMalformedUrlRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    params: {},
-                    path: "",
-                    query: {},
-                    matchedPath: null,
-                    bodyReader: defaultMalformedUrlRoute.bodyReader,
-                }));
-            }
-            if (!routerElements) {
-                return defaultNotfoundRoute.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: {},
-                    matchedPath: null,
-                    bodyReader: defaultNotfoundRoute.bodyReader,
-                }));
-            }
-            // eslint-disable-next-line @typescript-eslint/prefer-for-of
-            for (let index = 0; index < routerElements.length; index++) {
-                const routerElement = routerElements[index];
-                const result = routerElement.pattern.exec(decodedUrl.path);
-                if (!result) {
-                    continue;
-                }
-                return routerElement.buildedRoute(new Request({
-                    ...initializationData,
-                    ...decodedUrl,
-                    params: result.groups ?? {},
-                    matchedPath: routerElement.matchedPath,
-                    bodyReader: routerElement.bodyReader,
-                }));
-            }
-            return defaultNotfoundRoute.buildedRoute(new Request({
-                ...initializationData,
-                ...decodedUrl,
-                params: {},
-                matchedPath: null,
-                bodyReader: defaultNotfoundRoute.bodyReader,
-            }));
-        },
+        exec: await buildRouterFunction({
+            environment: hub.config.environment,
+            routerElementWrapper,
+            notfoundRouterElement: notfoundRouterElement,
+            malformedUrlRouterElement: malformedUrlRouterElement,
+            classRequest: hub.classRequest,
+            routerFunctionBuilder: hub.routerFunctionBuilder ?? defaultRouterFunctionBuilder,
+        }),
         hooksRouteLifeCycle,
         routeFunctionBuilders,
         routes,
@@ -124,4 +85,4 @@ async function buildRouter(hub) {
     };
 }
 
-export { NotFoundBodyReaderImplementationError, RouterBuildError, buildRouter, buildSystemRoute, decodeUrl, pathToRegExp };
+export { NotFoundBodyReaderImplementationError, RouterBuildError, createRouter, createRouterElementSystem, pathToRegExp };