@duplojs/http 0.1.0

package/dist/core/steps/handler.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+var kind$1 = require('./kind.cjs');
+
+const handlerStepKind = kind.createCoreLibKind("handler-step");
+function createHandlerStep(definition) {
+    return utils.pipe({ definition }, handlerStepKind.setTo, kind$1.stepKind.setTo);
+}
+
+exports.createHandlerStep = createHandlerStep;
+exports.handlerStepKind = handlerStepKind;

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

@@ -0,0 +1,19 @@
+import { type MaybePromise, type Kind } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Floor } from "../floor";
+import { type Response, type ResponseContract } from "../response";
+import { type Request } from "../request";
+import { type StepFunctionParams } from "./types";
+export interface HandlerStepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+}
+export interface HandlerStepDefinition {
+    theFunction(floor: Floor, params: HandlerStepFunctionParams): MaybePromise<Response>;
+    readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+}
+export declare const handlerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>>;
+type _HandlerStep = (Kind<typeof handlerStepKind.definition> & StepKind);
+export interface HandlerStep<GenericDefinition extends HandlerStepDefinition = HandlerStepDefinition> extends _HandlerStep {
+    definition: GenericDefinition;
+}
+export declare function createHandlerStep<GenericDefinition extends HandlerStepDefinition>(definition: GenericDefinition): HandlerStep<GenericDefinition>;
+export {};

package/dist/core/steps/handler.mjs

@@ -0,0 +1,10 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { pipe } from '@duplojs/utils';
+import { stepKind } from './kind.mjs';
+
+const handlerStepKind = createCoreLibKind("handler-step");
+function createHandlerStep(definition) {
+    return pipe({ definition }, handlerStepKind.setTo, stepKind.setTo);
+}
+
+export { createHandlerStep, handlerStepKind };

package/dist/core/steps/identifier.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const stepIdentifier = utils.createKindIdentifier();
+
+exports.stepIdentifier = stepIdentifier;

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

@@ -0,0 +1,5 @@
+import { type Kind } from "@duplojs/utils";
+export declare const stepIdentifier: {
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericResult extends Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericKindHandler extends any ? import("@duplojs/utils").IsEqual<false | (import("@duplojs/utils").GetKindHandler<GenericInput> extends infer T ? T extends import("@duplojs/utils").GetKindHandler<GenericInput> ? T extends any ? import("@duplojs/utils").IsEqual<T, GenericKindHandler> : never : never : never), boolean> : never, true> extends true ? import("@duplojs/utils/either").EitherSuccess<GenericInput> : import("@duplojs/utils/either").EitherError<GenericInput> : never) | import("@duplojs/utils/either").EitherSuccess<GenericResult>;
+    <GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/handler-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>> | import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>, GenericInput extends Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>, unknown>, GenericResult extends Extract<import("./checker").CheckerStep<import("./checker").CheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./cut").CutStep<import("./cut").CutStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./extract").ExtractStep<import("./extract").ExtractStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./handler").HandlerStep<import("./handler").HandlerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./presetChecker").PresetCheckerStep<import("./presetChecker").PresetCheckerStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>> | Extract<import("./process").ProcessStep<import("./process").ProcessStepDefinition>, import("@duplojs/utils").UnionToIntersection<GenericKindHandler extends import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<string, unknown>> ? Kind<GenericKindHandler["definition"], GenericKindHandler["definition"]["value"]> : never>>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): (GenericInput extends any ? import("@duplojs/utils").IsEqual<GenericKindHandler extends any ? import("@duplojs/utils").IsEqual<false | (import("@duplojs/utils").GetKindHandler<GenericInput> extends infer T ? T extends import("@duplojs/utils").GetKindHandler<GenericInput> ? T extends any ? import("@duplojs/utils").IsEqual<T, GenericKindHandler> : never : never : never), boolean> : never, true> extends true ? import("@duplojs/utils/either").EitherSuccess<GenericInput> : import("@duplojs/utils/either").EitherError<GenericInput> : never) | import("@duplojs/utils/either").EitherSuccess<GenericResult>;
+};

package/dist/core/steps/identifier.mjs

@@ -0,0 +1,5 @@
+import { createKindIdentifier } from '@duplojs/utils';
+
+const stepIdentifier = createKindIdentifier();
+
+export { stepIdentifier };

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

@@ -0,0 +1,9 @@
+export * from "./types";
+export * from "./kind";
+export * from "./identifier";
+export * from "./checker";
+export * from "./extract";
+export * from "./cut";
+export * from "./handler";
+export * from "./process";
+export * from "./presetChecker";

package/dist/core/steps/kind.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+
+const stepKind = kind.createCoreLibKind("step");
+
+exports.stepKind = stepKind;

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

@@ -0,0 +1,3 @@
+import { type Kind } from "@duplojs/utils";
+export declare const stepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/step", unknown>>;
+export type StepKind = Kind<typeof stepKind.definition>;

package/dist/core/steps/kind.mjs

@@ -0,0 +1,5 @@
+import { createCoreLibKind } from '../kind.mjs';
+
+const stepKind = createCoreLibKind("step");
+
+export { stepKind };

package/dist/core/steps/presetChecker.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+var kind$1 = require('./kind.cjs');
+
+const presetCheckerStepKind = kind.createCoreLibKind("presetChecker-step");
+function createPresetCheckerStep(definition) {
+    return utils.pipe({ definition }, presetCheckerStepKind.setTo, kind$1.stepKind.setTo);
+}
+
+exports.createPresetCheckerStep = createPresetCheckerStep;
+exports.presetCheckerStepKind = presetCheckerStepKind;

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

@@ -0,0 +1,14 @@
+import { type Kind } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Floor } from "../floor";
+import { type PresetChecker } from "../presetChecker";
+export interface PresetCheckerStepDefinition {
+    readonly presetChecker: PresetChecker;
+    input(input: Floor): unknown;
+}
+export declare const presetCheckerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/presetChecker-step", unknown>>;
+export type _PresetCheckerStep = (Kind<typeof presetCheckerStepKind.definition> & StepKind);
+export interface PresetCheckerStep<GenericDefinition extends PresetCheckerStepDefinition = PresetCheckerStepDefinition> extends _PresetCheckerStep {
+    readonly definition: GenericDefinition;
+}
+export declare function createPresetCheckerStep<GenericDefinition extends PresetCheckerStepDefinition>(definition: GenericDefinition): PresetCheckerStep<GenericDefinition>;

package/dist/core/steps/presetChecker.mjs

@@ -0,0 +1,10 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { pipe } from '@duplojs/utils';
+import { stepKind } from './kind.mjs';
+
+const presetCheckerStepKind = createCoreLibKind("presetChecker-step");
+function createPresetCheckerStep(definition) {
+    return pipe({ definition }, presetCheckerStepKind.setTo, stepKind.setTo);
+}
+
+export { createPresetCheckerStep, presetCheckerStepKind };

package/dist/core/steps/process.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+var kind$1 = require('./kind.cjs');
+
+const processStepKind = kind.createCoreLibKind("process-step");
+function createProcessStep(definition) {
+    return utils.pipe({ definition }, processStepKind.setTo, kind$1.stepKind.setTo);
+}
+
+exports.createProcessStep = createProcessStep;
+exports.processStepKind = processStepKind;

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

@@ -0,0 +1,14 @@
+import { type Kind } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Process } from "../process";
+export interface ProcessStepDefinition {
+    readonly process: Process;
+    readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
+    readonly imports?: readonly string[];
+}
+export declare const processStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/process-step", unknown>>;
+export type _ProcessStep = (Kind<typeof processStepKind.definition> & StepKind);
+export interface ProcessStep<GenericDefinition extends ProcessStepDefinition = ProcessStepDefinition> extends _ProcessStep {
+    definition: GenericDefinition;
+}
+export declare function createProcessStep<GenericDefinition extends ProcessStepDefinition>(definition: GenericDefinition): ProcessStep<GenericDefinition>;

package/dist/core/steps/process.mjs

@@ -0,0 +1,10 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { pipe } from '@duplojs/utils';
+import { stepKind } from './kind.mjs';
+
+const processStepKind = createCoreLibKind("process-step");
+function createProcessStep(definition) {
+    return pipe({ definition }, processStepKind.setTo, stepKind.setTo);
+}
+
+export { createProcessStep, processStepKind };

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

@@ -0,0 +1,5 @@
+import { type Floor } from "../../floor";
+import { type Request } from "../../request";
+import { type Response } from "../../response";
+import { type MaybePromise } from "@duplojs/utils";
+export type BuildedStep = (request: Request, floor: Floor) => MaybePromise<Floor | Response>;

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

@@ -0,0 +1,3 @@
+export * from "./stepFunctionParams";
+export * from "./steps";
+export * from "./buildedStep";

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

@@ -0,0 +1,12 @@
+import { type Request } from "../../request";
+import { type Response } from "../../response";
+import { type IsEqual, type Or } from "@duplojs/utils";
+export interface StepFunctionParams<GenericRequest extends Request = Request, GenericResponse extends Response = Response> {
+    request: GenericRequest;
+    response<GenericInformation extends GenericResponse["information"], GenericFilteredResponse extends Extract<GenericResponse, {
+        information: GenericInformation;
+    }>>(information: GenericInformation, ...args: Or<[
+        IsEqual<GenericFilteredResponse["body"], unknown>,
+        IsEqual<GenericFilteredResponse["body"], undefined>
+    ]> extends true ? [body?: NoInfer<GenericFilteredResponse["body"]>] : [body: NoInfer<GenericFilteredResponse["body"]>]): GenericFilteredResponse;
+}

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

@@ -0,0 +1,11 @@
+import { type Kind, type O } from "@duplojs/utils";
+import { type CheckerStep } from "../checker";
+import { type CutStep } from "../cut";
+import { type ExtractStep } from "../extract";
+import { type HandlerStep } from "../handler";
+import { type PresetCheckerStep } from "../presetChecker";
+import { type ProcessStep } from "../process";
+import { type stepKind } from "../kind";
+export interface StepsCustom {
+}
+export type Steps = (StepsCustom[O.GetPropsWithValueExtends<StepsCustom, Kind<typeof stepKind.definition>>] | CheckerStep | CutStep | ExtractStep | HandlerStep | PresetCheckerStep | ProcessStep);

package/dist/core/stringIdentifier.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function createCoreLibStringIdentifier(value) {
+    return `@duplojs/http/core/${value}`;
+}
+
+exports.createCoreLibStringIdentifier = createCoreLibStringIdentifier;

package/dist/core/stringIdentifier.d.ts

@@ -0,0 +1 @@
+export declare function createCoreLibStringIdentifier<GenericValue extends string>(value: GenericValue): `@duplojs/http/core/${GenericValue}`;

package/dist/core/stringIdentifier.mjs

@@ -0,0 +1,5 @@
+function createCoreLibStringIdentifier(value) {
+    return `@duplojs/http/core/${value}`;
+}
+
+export { createCoreLibStringIdentifier };

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

@@ -0,0 +1,4 @@
+import { type O } from "@duplojs/utils";
+export interface EnvironmentCustom {
+}
+export type Environment = (EnvironmentCustom[O.GetPropsWithValue<EnvironmentCustom, true>] | "DEV" | "PROD");

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

@@ -0,0 +1 @@
+export * from "./environment";

package/dist/interfaces/bun/index.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+require('../../core/request.cjs');
+require('../../core/steps/kind.cjs');
+require('../../core/steps/identifier.cjs');
+require('../../core/steps/checker.cjs');
+require('../../core/steps/extract.cjs');
+require('../../core/steps/cut.cjs');
+require('../../core/steps/handler.cjs');
+require('../../core/steps/process.cjs');
+require('../../core/steps/presetChecker.cjs');
+var kind = require('./kind.cjs');
+
+
+
+exports.createInterfacesBunLibKind = kind.createInterfacesBunLibKind;

package/dist/interfaces/bun/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./kind";

package/dist/interfaces/bun/index.mjs

@@ -0,0 +1,10 @@
+import '../../core/request.mjs';
+import '../../core/steps/kind.mjs';
+import '../../core/steps/identifier.mjs';
+import '../../core/steps/checker.mjs';
+import '../../core/steps/extract.mjs';
+import '../../core/steps/cut.mjs';
+import '../../core/steps/handler.mjs';
+import '../../core/steps/process.mjs';
+import '../../core/steps/presetChecker.mjs';
+export { createInterfacesBunLibKind } from './kind.mjs';

package/dist/interfaces/bun/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createInterfacesBunLibKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesBun");
+
+exports.createInterfacesBunLibKind = createInterfacesBunLibKind;

package/dist/interfaces/bun/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsHttpInterfacesBun: true;
+    }
+}
+export declare const createInterfacesBunLibKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsHttpInterfacesBun/${GenericName}`, GenericKindValue>>;

package/dist/interfaces/bun/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createInterfacesBunLibKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesBun");
+
+export { createInterfacesBunLibKind };

package/dist/interfaces/bun/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./request";

package/dist/interfaces/bun/types/request.d.ts

@@ -0,0 +1,21 @@
+import "../../../core/request";
+import "../../../core/steps";
+export interface RawRequest {
+    request: Request;
+}
+declare module "../../../core/steps" {
+    interface DisabledExtractKeysCustom {
+        raw: true;
+    }
+}
+declare module "../../../core/request" {
+    interface RequestInitializationData {
+        raw: RawRequest;
+    }
+    interface Request {
+        /**
+         * @deprecated
+         */
+        raw: RawRequest;
+    }
+}

package/dist/interfaces/deno/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+
+
+
+exports.createInterfacesDenoLibKind = kind.createInterfacesDenoLibKind;

package/dist/interfaces/deno/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./kind";

package/dist/interfaces/deno/index.mjs

@@ -0,0 +1 @@
+export { createInterfacesDenoLibKind } from './kind.mjs';

package/dist/interfaces/deno/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createInterfacesDenoLibKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesDeno");
+
+exports.createInterfacesDenoLibKind = createInterfacesDenoLibKind;

package/dist/interfaces/deno/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsHttpInterfacesDeno: true;
+    }
+}
+export declare const createInterfacesDenoLibKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsHttpInterfacesDeno/${GenericName}`, GenericKindValue>>;

package/dist/interfaces/deno/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createInterfacesDenoLibKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpInterfacesDeno");
+
+export { createInterfacesDenoLibKind };

package/dist/interfaces/deno/types/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/deno/types/request.d.ts

@@ -0,0 +1,21 @@
+import "../../../core/request";
+import "../../../core/steps";
+export interface RawRequest {
+    request: Request;
+}
+declare module "../../../core/steps" {
+    interface DisabledExtractKeysCustom {
+        raw: true;
+    }
+}
+declare module "../../../core/request" {
+    interface RequestInitializationData {
+        raw: RawRequest;
+    }
+    interface Request {
+        /**
+         * @deprecated
+         */
+        raw: RawRequest;
+    }
+}

package/dist/interfaces/node/createHttpServer.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+require('../../core/hub/index.cjs');
+var index = require('../../core/router/index.cjs');
+var http = require('http');
+var https = require('https');
+var hooks$1 = require('./hooks.cjs');
+var hooks = require('../../core/hub/hooks.cjs');
+
+async function createHttpServer(inputHub, params) {
+    const httpServerParams = {
+        ...params,
+        maxBodySize: "50mb",
+        informationHeaderKey: "information",
+        fromHookHeaderKey: "from-hook",
+        interface: "node",
+    };
+    const newHub1 = await hooks.launchHookServer(inputHub.aggregatesHooksHubLifeCycle("beforeServerBuildRoute"), inputHub, httpServerParams);
+    const router = await index.buildRouter(newHub1.addRouteHooks(hooks$1.makeNodeHook(newHub1, httpServerParams)));
+    const newHub2 = await hooks.launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, httpServerParams);
+    const server = params.https
+        ? https.createServer(params.https)
+        : http.createServer(params.http ?? {});
+    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
+    server.addListener("request", (serverRequest, serverResponse) => router
+        .exec({
+        method: serverRequest.method ?? "",
+        headers: serverRequest.headers,
+        host: serverRequest.headers.host ?? "",
+        origin: serverRequest.headers.origin ?? "",
+        url: serverRequest.url ?? "",
+        raw: {
+            request: serverRequest,
+            response: serverResponse,
+        },
+    })
+        .catch(async (error) => {
+        await hooks.launchHookServerError(serverErrorHooks, {
+            error,
+            exit: hooks.serverErrorExitHookFunction,
+            next: hooks.serverErrorNextHookFunction,
+            serverRequest,
+            serverResponse,
+        });
+        if (!serverResponse.headersSent && !serverResponse.writableEnded) {
+            serverResponse.writeHead(500, {
+                [httpServerParams.informationHeaderKey]: "critical-server-error",
+            });
+            serverResponse.write(error?.toString?.() ?? "unknown-server-error");
+        }
+        if (!serverResponse.writableEnded) {
+            serverResponse.end();
+        }
+    }));
+    await new Promise((resolve) => {
+        server.listen({
+            port: httpServerParams.port,
+            host: httpServerParams.host,
+        }, () => void resolve());
+    });
+    await hooks.launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, httpServerParams);
+    return server;
+}
+
+exports.createHttpServer = createHttpServer;

package/dist/interfaces/node/createHttpServer.d.ts

@@ -0,0 +1,23 @@
+import { type HttpServerParams, type Hub } from "../../core/hub";
+import { type Hosts } from "./types/host";
+import { type O, type BytesInString } from "@duplojs/utils";
+import http from "http";
+import https from "https";
+declare module "../../core/hub" {
+    interface HttpServerParams {
+        readonly interface: "node";
+        readonly host: Hosts;
+        readonly port: number;
+        readonly maxBodySize: BytesInString | number;
+        readonly informationHeaderKey: string;
+        readonly fromHookHeaderKey: string;
+        readonly http?: http.ServerOptions;
+        readonly https?: https.ServerOptions;
+    }
+    interface HttpServerErrorParams {
+        readonly serverRequest: http.IncomingMessage;
+        readonly serverResponse: http.ServerResponse;
+    }
+}
+export type CreateHttpServerParams = O.PartialKeys<Omit<HttpServerParams, "interface">, "maxBodySize" | "informationHeaderKey" | "fromHookHeaderKey">;
+export declare function createHttpServer(inputHub: Hub, params: CreateHttpServerParams): Promise<https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>>;

package/dist/interfaces/node/createHttpServer.mjs

@@ -0,0 +1,63 @@
+import '../../core/hub/index.mjs';
+import { buildRouter } from '../../core/router/index.mjs';
+import http from 'http';
+import https from 'https';
+import { makeNodeHook } from './hooks.mjs';
+import { launchHookServer, launchHookServerError, serverErrorNextHookFunction, serverErrorExitHookFunction } from '../../core/hub/hooks.mjs';
+
+async function createHttpServer(inputHub, params) {
+    const httpServerParams = {
+        ...params,
+        maxBodySize: "50mb",
+        informationHeaderKey: "information",
+        fromHookHeaderKey: "from-hook",
+        interface: "node",
+    };
+    const newHub1 = await launchHookServer(inputHub.aggregatesHooksHubLifeCycle("beforeServerBuildRoute"), inputHub, httpServerParams);
+    const router = await buildRouter(newHub1.addRouteHooks(makeNodeHook(newHub1, httpServerParams)));
+    const newHub2 = await launchHookServer(newHub1.aggregatesHooksHubLifeCycle("beforeStartServer"), newHub1, httpServerParams);
+    const server = params.https
+        ? https.createServer(params.https)
+        : http.createServer(params.http ?? {});
+    const serverErrorHooks = newHub1.aggregatesHooksHubLifeCycle("serverError");
+    server.addListener("request", (serverRequest, serverResponse) => router
+        .exec({
+        method: serverRequest.method ?? "",
+        headers: serverRequest.headers,
+        host: serverRequest.headers.host ?? "",
+        origin: serverRequest.headers.origin ?? "",
+        url: serverRequest.url ?? "",
+        raw: {
+            request: serverRequest,
+            response: serverResponse,
+        },
+    })
+        .catch(async (error) => {
+        await launchHookServerError(serverErrorHooks, {
+            error,
+            exit: serverErrorExitHookFunction,
+            next: serverErrorNextHookFunction,
+            serverRequest,
+            serverResponse,
+        });
+        if (!serverResponse.headersSent && !serverResponse.writableEnded) {
+            serverResponse.writeHead(500, {
+                [httpServerParams.informationHeaderKey]: "critical-server-error",
+            });
+            serverResponse.write(error?.toString?.() ?? "unknown-server-error");
+        }
+        if (!serverResponse.writableEnded) {
+            serverResponse.end();
+        }
+    }));
+    await new Promise((resolve) => {
+        server.listen({
+            port: httpServerParams.port,
+            host: httpServerParams.host,
+        }, () => void resolve());
+    });
+    await launchHookServer(newHub2.aggregatesHooksHubLifeCycle("afterStartServer"), newHub2, httpServerParams);
+    return server;
+}
+
+export { createHttpServer };

package/dist/interfaces/node/error/bodyParseUnknownError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+
+class BodyParseUnknownError extends utils.kindHeritage("body-parse-unknown-error", kind.createInterfacesNodeLibKind("body-parse-unknown-error"), Error) {
+    contentType;
+    unknownError;
+    constructor(contentType, unknownError) {
+        super({}, [`Error when parsing body with '${contentType}' content-type.`]);
+        this.contentType = contentType;
+        this.unknownError = unknownError;
+    }
+}
+
+exports.BodyParseUnknownError = BodyParseUnknownError;

package/dist/interfaces/node/error/bodyParseUnknownError.d.ts

@@ -0,0 +1,9 @@
+declare const BodyParseUnknownError_base: new (params: {
+    "@DuplojsHttpInterfacesNode/body-parse-unknown-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
+export declare class BodyParseUnknownError extends BodyParseUnknownError_base {
+    contentType: string;
+    unknownError: unknown;
+    constructor(contentType: string, unknownError: unknown);
+}
+export {};

package/dist/interfaces/node/error/bodyParseUnknownError.mjs

@@ -0,0 +1,14 @@
+import { kindHeritage } from '@duplojs/utils';
+import { createInterfacesNodeLibKind } from '../kind.mjs';
+
+class BodyParseUnknownError extends kindHeritage("body-parse-unknown-error", createInterfacesNodeLibKind("body-parse-unknown-error"), Error) {
+    contentType;
+    unknownError;
+    constructor(contentType, unknownError) {
+        super({}, [`Error when parsing body with '${contentType}' content-type.`]);
+        this.contentType = contentType;
+        this.unknownError = unknownError;
+    }
+}
+
+export { BodyParseUnknownError };