@duplojs/http 0.1.0

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

@@ -0,0 +1,13 @@
+import { type ResponseCode, Response } from "../../response";
+import { type HookRouteLifeCycle } from ".";
+declare const HookResponse_base: new (params: {
+    "@DuplojsHttpCore/hook-response"?: unknown;
+}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
+export declare class HookResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends HookResponse_base {
+    code: GenericCode;
+    information: `from-hook-${GenericInformation}`;
+    body: GenericBody;
+    fromHook: keyof HookRouteLifeCycle;
+    constructor(from: keyof HookRouteLifeCycle, code: GenericCode, information: GenericInformation, body: GenericBody);
+}
+export {};

package/dist/core/route/hooks/response.mjs

@@ -0,0 +1,21 @@
+import { createCoreLibKind } from '../../kind.mjs';
+import { Response } from '../../response/index.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class HookResponse extends kindHeritage("hook-response", createCoreLibKind("hook-response"), Response) {
+    code;
+    information;
+    body;
+    fromHook;
+    constructor(from, code, information, body) {
+        super(defaultParams, defaultParamsParent);
+        this.code = code;
+        this.information = `from-hook-${information}`;
+        this.body = body;
+        this.fromHook = from;
+    }
+}
+
+export { HookResponse };

package/dist/core/route/index.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var kind = require('../kind.cjs');
+var index = require('./hooks/index.cjs');
+
+const routeKind = kind.createCoreLibKind("route");
+function createRoute(definition) {
+    return utils.pipe({ definition }, routeKind.setTo);
+}
+
+exports.createHookRouteLifeCycle = index.createHookRouteLifeCycle;
+exports.hookRouteExitKind = index.hookRouteExitKind;
+exports.hookRouteNextKind = index.hookRouteNextKind;
+exports.createRoute = createRoute;
+exports.routeKind = routeKind;

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

@@ -0,0 +1,25 @@
+import { type O, type Kind } from "@duplojs/utils";
+import { type RequestMethods } from "../request";
+import { type ExtractStep, type CheckerStep, type CutStep, type HandlerStep, type ProcessStep, type stepKind, type PresetCheckerStep } from "../steps";
+import { type HookRouteLifeCycle } from "./hooks";
+export * from "./types";
+export * from "./hooks";
+export interface RouteStepsCustom {
+}
+export type RouteSteps = (RouteStepsCustom[O.GetPropsWithValueExtends<RouteStepsCustom, Kind<typeof stepKind.definition>>] | CheckerStep | PresetCheckerStep | ProcessStep | ExtractStep | CutStep | HandlerStep);
+export interface RoutePreFlightStepsCustom {
+}
+export type RoutePreFlightSteps = (RoutePreFlightStepsCustom[O.GetPropsWithValueExtends<RoutePreFlightStepsCustom, Kind<typeof stepKind.definition>>] | ProcessStep);
+export type RoutePath = `/${string}`;
+export interface RouteDefinition {
+    readonly paths: readonly [RoutePath, ...RoutePath[]];
+    readonly method: RequestMethods;
+    readonly preflightSteps: readonly RoutePreFlightSteps[];
+    readonly steps: readonly RouteSteps[];
+    readonly hooks: readonly HookRouteLifeCycle[];
+}
+export declare const routeKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/route", unknown>>;
+export interface Route<GenericDefinition extends RouteDefinition = RouteDefinition> extends Kind<typeof routeKind.definition> {
+    readonly definition: GenericDefinition;
+}
+export declare function createRoute<GenericDefinition extends RouteDefinition>(definition: GenericDefinition): Route<GenericDefinition>;

package/dist/core/route/index.mjs

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

package/dist/core/route/types/buildedRoute.d.ts

@@ -0,0 +1,2 @@
+import { type Request } from "../../request";
+export type BuildedRoute = (request: Request) => Promise<void>;

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

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

package/dist/core/router/buildError.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class RouterBuildError extends utils.kindHeritage("router-build-error", kind.createCoreLibKind("router-build-error"), Error) {
+    element;
+    constructor(element) {
+        super({}, ["Error during build route."]);
+        this.element = element;
+    }
+}
+
+exports.RouterBuildError = RouterBuildError;

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

@@ -0,0 +1,9 @@
+import { type Route } from "../route";
+declare const RouterBuildError_base: new (params: {
+    "@DuplojsHttpCore/router-build-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
+export declare class RouterBuildError extends RouterBuildError_base {
+    element: Route;
+    constructor(element: Route);
+}
+export {};

package/dist/core/router/buildError.mjs

@@ -0,0 +1,12 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class RouterBuildError extends kindHeritage("router-build-error", createCoreLibKind("router-build-error"), Error) {
+    element;
+    constructor(element) {
+        super({}, ["Error during build route."]);
+        this.element = element;
+    }
+}
+
+export { RouterBuildError };

package/dist/core/router/decodeUrl.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
+const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+function decodeUrl(url) {
+    try {
+        const groups = regexUrlAnalyser.exec(url).groups;
+        const path = decodeURIComponent(groups.path || "/");
+        const queryString = groups.query;
+        if (!queryString) {
+            return {
+                path,
+                query: {},
+            };
+        }
+        const query = {};
+        for (const result of queryString.matchAll(regexQueryAnalyser)) {
+            const groups = result.groups;
+            const key = decodeURIComponent(groups.key);
+            const value = decodeURIComponent(groups.value);
+            const currentValue = query[key];
+            if (typeof currentValue === "undefined") {
+                query[key] = value;
+            }
+            else if (currentValue instanceof Array) {
+                currentValue.push(value);
+            }
+            else {
+                query[key] = [currentValue, value];
+            }
+        }
+        return {
+            path,
+            query,
+        };
+    }
+    catch {
+        return {
+            path: "/",
+            query: {},
+        };
+    }
+}
+
+exports.decodeUrl = decodeUrl;
+exports.regexQueryAnalyser = regexQueryAnalyser;
+exports.regexUrlAnalyser = regexUrlAnalyser;

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

@@ -0,0 +1,7 @@
+export declare const regexUrlAnalyser: RegExp;
+export declare const regexQueryAnalyser: RegExp;
+export interface DecodedUrl {
+    path: string;
+    query: Record<string, string | string[]>;
+}
+export declare function decodeUrl(url: string): DecodedUrl;

package/dist/core/router/decodeUrl.mjs

@@ -0,0 +1,43 @@
+const regexUrlAnalyser = /^(?<path>[^?]*)(?:\?(?<query>[^#]*))?(?:#(?<fragment>[^]*))?$/;
+const regexQueryAnalyser = /(?<key>[^=&]+)=(?<value>[^&]*)/g;
+function decodeUrl(url) {
+    try {
+        const groups = regexUrlAnalyser.exec(url).groups;
+        const path = decodeURIComponent(groups.path || "/");
+        const queryString = groups.query;
+        if (!queryString) {
+            return {
+                path,
+                query: {},
+            };
+        }
+        const query = {};
+        for (const result of queryString.matchAll(regexQueryAnalyser)) {
+            const groups = result.groups;
+            const key = decodeURIComponent(groups.key);
+            const value = decodeURIComponent(groups.value);
+            const currentValue = query[key];
+            if (typeof currentValue === "undefined") {
+                query[key] = value;
+            }
+            else if (currentValue instanceof Array) {
+                currentValue.push(value);
+            }
+            else {
+                query[key] = [currentValue, value];
+            }
+        }
+        return {
+            path,
+            query,
+        };
+    }
+    catch {
+        return {
+            path: "/",
+            query: {},
+        };
+    }
+}
+
+export { decodeUrl, regexQueryAnalyser, regexUrlAnalyser };

package/dist/core/router/index.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+require('../hub/index.cjs');
+var utils = require('@duplojs/utils');
+var pathToRegExp = require('./pathToRegExp.cjs');
+var index = require('../route/index.cjs');
+var buildError = require('./buildError.cjs');
+var build = require('../functionsBuilders/route/build.cjs');
+var _default = require('../functionsBuilders/route/default.cjs');
+require('../functionsBuilders/route/hook.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');
+var extractStep = require('../functionsBuilders/steps/defaults/extractStep.cjs');
+var processStep = require('../functionsBuilders/steps/defaults/processStep.cjs');
+var decodeUrl = require('./decodeUrl.cjs');
+var hooks = require('../hub/hooks.cjs');
+
+async function buildRouter(inputHub) {
+    const hub = inputHub
+        .addRouteFunctionBuilder(_default.defaultRouteFunctionBuilder)
+        .addStepFunctionBuilder([
+        checkerStep.defaultCheckerStepFunctionBuilder,
+        cutStep.defaultCutStepFunctionBuilder,
+        handlerStep.defaultHandlerStepFunctionBuilder,
+        extractStep.defaultExtractStepFunctionBuilder,
+        processStep.defaultProcessStepFunctionBuilder,
+    ]);
+    const { environment } = hub.config;
+    const { hooksRouteLifeCycle, routeFunctionBuilders, routes, stepFunctionBuilders, hooksHubLifeCycle, } = hub.aggregates();
+    const hooksBeforeBuildRoute = utils.pipe(hooksHubLifeCycle, utils.A.map(({ beforeBuildRoute }) => beforeBuildRoute), utils.A.filter(utils.isType("function")));
+    const buildParams = {
+        environment,
+        globalHooksRouteLifeCycle: hooksRouteLifeCycle,
+        stepFunctionBuilders,
+        routeFunctionBuilders,
+    };
+    const groupedRoute = 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)) {
+            throw new buildError.RouterBuildError(utils.unwrap(buildedRoute));
+        }
+        return nextWithObject(lastValue, {
+            [route.definition.method]: utils.A.concat(lastValue[route.definition.method] ?? [], utils.A.map(route.definition.paths, utils.O.to({
+                pattern: pathToRegExp.pathToRegExp,
+                buildedRoute: utils.justReturn(utils.unwrap(buildedRoute)),
+                matchedPath: utils.forward,
+            }))),
+        });
+    });
+    const buildedNotfoundRoute = await utils.asyncPipe(index.createRoute({
+        method: "GET",
+        paths: ["/"],
+        hooks: [],
+        preflightSteps: [],
+        steps: [hub.notfoundHandler],
+    }), (route) => build.buildRouteFunction(route, buildParams), utils.E.whenIsLeft((element) => {
+        throw new buildError.RouterBuildError(element);
+    }), utils.unwrap);
+    const Request = hub.classRequest;
+    return {
+        exec: (initializationData) => {
+            const routerElements = groupedRoute[initializationData.method];
+            const decodedUrl = decodeUrl.decodeUrl(initializationData.url);
+            if (!routerElements) {
+                return buildedNotfoundRoute(new Request({
+                    ...initializationData,
+                    ...decodedUrl,
+                    params: {},
+                    matchedPath: null,
+                }));
+            }
+            // 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,
+                }));
+            }
+            return buildedNotfoundRoute(new Request({
+                ...initializationData,
+                ...decodedUrl,
+                params: {},
+                matchedPath: null,
+            }));
+        },
+        hooksRouteLifeCycle,
+        routeFunctionBuilders,
+        routes,
+        stepFunctionBuilders,
+        hooksHubLifeCycle,
+    };
+}
+
+exports.pathToRegExp = pathToRegExp.pathToRegExp;
+exports.RouterBuildError = buildError.RouterBuildError;
+exports.decodeUrl = decodeUrl.decodeUrl;
+exports.regexQueryAnalyser = decodeUrl.regexQueryAnalyser;
+exports.regexUrlAnalyser = decodeUrl.regexUrlAnalyser;
+exports.buildRouter = buildRouter;

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

@@ -0,0 +1,7 @@
+import { type Hub } from "../hub";
+import { type BuildedRouter } from "./types";
+export * from "./types";
+export * from "./pathToRegExp";
+export * from "./buildError";
+export * from "./decodeUrl";
+export declare function buildRouter(inputHub: Hub): Promise<BuildedRouter>;

package/dist/core/router/index.mjs

@@ -0,0 +1,102 @@
+import '../hub/index.mjs';
+import { pipe, A, isType, G, E, unwrap, O, forward, justReturn, asyncPipe } from '@duplojs/utils';
+import { pathToRegExp } from './pathToRegExp.mjs';
+import { createRoute } from '../route/index.mjs';
+import { RouterBuildError } from './buildError.mjs';
+import { buildRouteFunction } from '../functionsBuilders/route/build.mjs';
+import { defaultRouteFunctionBuilder } from '../functionsBuilders/route/default.mjs';
+import '../functionsBuilders/route/hook.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';
+import { defaultExtractStepFunctionBuilder } from '../functionsBuilders/steps/defaults/extractStep.mjs';
+import { defaultProcessStepFunctionBuilder } from '../functionsBuilders/steps/defaults/processStep.mjs';
+import { decodeUrl } from './decodeUrl.mjs';
+export { regexQueryAnalyser, regexUrlAnalyser } from './decodeUrl.mjs';
+import { launchHookBeforeBuildRoute } from '../hub/hooks.mjs';
+
+async function buildRouter(inputHub) {
+    const hub = inputHub
+        .addRouteFunctionBuilder(defaultRouteFunctionBuilder)
+        .addStepFunctionBuilder([
+        defaultCheckerStepFunctionBuilder,
+        defaultCutStepFunctionBuilder,
+        defaultHandlerStepFunctionBuilder,
+        defaultExtractStepFunctionBuilder,
+        defaultProcessStepFunctionBuilder,
+    ]);
+    const { environment } = hub.config;
+    const { hooksRouteLifeCycle, routeFunctionBuilders, routes, stepFunctionBuilders, hooksHubLifeCycle, } = hub.aggregates();
+    const hooksBeforeBuildRoute = pipe(hooksHubLifeCycle, A.map(({ beforeBuildRoute }) => beforeBuildRoute), A.filter(isType("function")));
+    const buildParams = {
+        environment,
+        globalHooksRouteLifeCycle: hooksRouteLifeCycle,
+        stepFunctionBuilders,
+        routeFunctionBuilders,
+    };
+    const groupedRoute = 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)) {
+            throw new RouterBuildError(unwrap(buildedRoute));
+        }
+        return nextWithObject(lastValue, {
+            [route.definition.method]: A.concat(lastValue[route.definition.method] ?? [], A.map(route.definition.paths, O.to({
+                pattern: pathToRegExp,
+                buildedRoute: justReturn(unwrap(buildedRoute)),
+                matchedPath: forward,
+            }))),
+        });
+    });
+    const buildedNotfoundRoute = await asyncPipe(createRoute({
+        method: "GET",
+        paths: ["/"],
+        hooks: [],
+        preflightSteps: [],
+        steps: [hub.notfoundHandler],
+    }), (route) => buildRouteFunction(route, buildParams), E.whenIsLeft((element) => {
+        throw new RouterBuildError(element);
+    }), unwrap);
+    const Request = hub.classRequest;
+    return {
+        exec: (initializationData) => {
+            const routerElements = groupedRoute[initializationData.method];
+            const decodedUrl = decodeUrl(initializationData.url);
+            if (!routerElements) {
+                return buildedNotfoundRoute(new Request({
+                    ...initializationData,
+                    ...decodedUrl,
+                    params: {},
+                    matchedPath: null,
+                }));
+            }
+            // 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,
+                }));
+            }
+            return buildedNotfoundRoute(new Request({
+                ...initializationData,
+                ...decodedUrl,
+                params: {},
+                matchedPath: null,
+            }));
+        },
+        hooksRouteLifeCycle,
+        routeFunctionBuilders,
+        routes,
+        stepFunctionBuilders,
+        hooksHubLifeCycle,
+    };
+}
+
+export { RouterBuildError, buildRouter, decodeUrl, pathToRegExp };

package/dist/core/router/pathToRegExp.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+function pathToRegExp(path) {
+    return utils.pipe(path, utils.escapeRegExp, utils.S.replace(/\\\/$/g, ""), utils.S.replace(/\\\*/g, ".*"), utils.S.replace(/\\\{([A-zÀ-ÿ0-9_-]+)\\\}/g, "(?<$1>[A-zÀ-ÿ0-9_\\-. ]+)"), (regExp) => new RegExp(`^${regExp}\\/?$`));
+}
+
+exports.pathToRegExp = pathToRegExp;

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

@@ -0,0 +1,2 @@
+import { type RoutePath } from "../route";
+export declare function pathToRegExp(path: RoutePath): RegExp;

package/dist/core/router/pathToRegExp.mjs

@@ -0,0 +1,7 @@
+import { pipe, escapeRegExp, S } from '@duplojs/utils';
+
+function pathToRegExp(path) {
+    return pipe(path, escapeRegExp, S.replace(/\\\/$/g, ""), S.replace(/\\\*/g, ".*"), S.replace(/\\\{([A-zÀ-ÿ0-9_-]+)\\\}/g, "(?<$1>[A-zÀ-ÿ0-9_\\-. ]+)"), (regExp) => new RegExp(`^${regExp}\\/?$`));
+}
+
+export { pathToRegExp };

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

@@ -0,0 +1,12 @@
+import { type createStepFunctionBuilder, type createRouteFunctionBuilder } from "../../functionsBuilders";
+import { type HookHubLifeCycle } from "../../hub";
+import { type RequestInitializationData } from "../../request";
+import { type HookRouteLifeCycle, type Route, type RouteDefinition } from "../../route";
+export interface BuildedRouter {
+    exec(initializationData: Omit<RequestInitializationData, "matchedPath" | "params" | "path" | "query">): Promise<void>;
+    readonly routes: readonly Route<RouteDefinition>[];
+    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/index.d.ts

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

package/dist/core/steps/checker.cjs

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

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

@@ -0,0 +1,19 @@
+import { type Kind } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Checker } from "../checker";
+import { type Floor } from "../floor";
+import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+export interface CheckerStepDefinition {
+    readonly checker: Checker;
+    readonly result: string | readonly string[];
+    readonly indexing?: string;
+    input(input: Floor): unknown;
+    readonly options?: Record<string, unknown> | ((input: any) => Record<string, unknown>);
+    readonly responseContract: ResponseContract.Contract<ClientErrorResponseCode>;
+}
+export declare const checkerStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/checker-step", unknown>>;
+export type _CheckerStep = (Kind<typeof checkerStepKind.definition> & StepKind);
+export interface CheckerStep<GenericDefinition extends CheckerStepDefinition = CheckerStepDefinition> extends _CheckerStep {
+    readonly definition: GenericDefinition;
+}
+export declare function createCheckerStep<GenericDefinition extends CheckerStepDefinition>(definition: GenericDefinition): CheckerStep<GenericDefinition>;

package/dist/core/steps/checker.mjs

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

package/dist/core/steps/cut.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+var kind$1 = require('./kind.cjs');
+
+const cutStepOutputKind = kind.createCoreLibKind("cut-output");
+const cutStepKind = kind.createCoreLibKind("cut-step");
+function createCutStep(definition) {
+    return utils.pipe({ definition }, cutStepKind.setTo, kind$1.stepKind.setTo);
+}
+
+exports.createCutStep = createCutStep;
+exports.cutStepKind = cutStepKind;
+exports.cutStepOutputKind = cutStepOutputKind;

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

@@ -0,0 +1,22 @@
+import { type WrappedValue, type Kind, type MaybePromise, type NeverCoalescing } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Floor } from "../floor";
+import { type StepFunctionParams } from "./types";
+import { type Response, type ResponseContract } from "../response";
+import { type Request } from "../request";
+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 Response = Response> extends StepFunctionParams<GenericRequest, GenericResponse> {
+    output<GenericData extends Record<string, unknown> = never>(data?: GenericData): CutStepFunctionOutput<NeverCoalescing<GenericData, {}>>;
+}
+export interface CutStepDefinition {
+    theFunction(floor: Floor, params: CutStepFunctionParams): MaybePromise<CutStepFunctionOutput | Response>;
+    readonly responseContract: ResponseContract.Contract | readonly ResponseContract.Contract[];
+}
+export declare const cutStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/cut-step", unknown>>;
+export type _CutStep = (Kind<typeof cutStepKind.definition> & StepKind);
+export interface CutStep<GenericDefinition extends CutStepDefinition = CutStepDefinition> extends _CutStep {
+    definition: GenericDefinition;
+}
+export declare function createCutStep<GenericDefinition extends CutStepDefinition>(definition: GenericDefinition): CutStep<GenericDefinition>;

package/dist/core/steps/cut.mjs

@@ -0,0 +1,11 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { pipe } from '@duplojs/utils';
+import { stepKind } from './kind.mjs';
+
+const cutStepOutputKind = createCoreLibKind("cut-output");
+const cutStepKind = createCoreLibKind("cut-step");
+function createCutStep(definition) {
+    return pipe({ definition }, cutStepKind.setTo, stepKind.setTo);
+}
+
+export { createCutStep, cutStepKind, cutStepOutputKind };

package/dist/core/steps/extract.cjs

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

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

@@ -0,0 +1,18 @@
+import { type DP, type Kind, type O, type AnyFunction } from "@duplojs/utils";
+import { type StepKind } from "./kind";
+import { type Request } from "../request";
+import { type ClientErrorResponseCode, type ResponseContract } from "../response";
+export interface DisabledExtractKeysCustom {
+}
+export type DisabledExtractKeys = O.GetPropsWithValue<DisabledExtractKeysCustom, true>;
+export type ExtractShape<GenericRequest extends Request = Request> = Partial<Record<Exclude<keyof GenericRequest, O.GetPropsWithValueExtends<GenericRequest, AnyFunction> | DisabledExtractKeys>, DP.DataParser | Record<string, DP.DataParser>>>;
+export interface ExtractStepDefinition {
+    readonly shape: ExtractShape;
+    readonly responseContract?: ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>;
+}
+export declare const extractStepKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/extract-step", unknown>>;
+export type _ExtractStep = (Kind<typeof extractStepKind.definition> & StepKind);
+export interface ExtractStep<GenericDefinition extends ExtractStepDefinition = ExtractStepDefinition> extends _ExtractStep {
+    readonly definition: GenericDefinition;
+}
+export declare function createExtractStep<GenericDefinition extends ExtractStepDefinition>(definition: GenericDefinition): ExtractStep<GenericDefinition>;

package/dist/core/steps/extract.mjs

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