@duplojs/http 0.1.0

package/README.md

@@ -0,0 +1,2 @@
+# @duplojs/http
+[![NPM version](https://img.shields.io/npm/v/@duplojs/http)](https://www.npmjs.com/package/@duplojs/http)

package/dist/core/builders/checker.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var checker = require('../checker.cjs');
+var stringIdentifier = require('../stringIdentifier.cjs');
+var utils = require('@duplojs/utils');
+
+const checkerBuilder = utils.createBuilder(stringIdentifier.createCoreLibStringIdentifier("checker"));
+checkerBuilder.set("handler", ({ args: [theFunction], accumulator, }) => checker.createChecker({
+    theFunction,
+    options: accumulator.options,
+}));
+function useCheckerBuilder(params) {
+    return checkerBuilder.use({
+        options: undefined,
+        ...params,
+    });
+}
+
+exports.checkerBuilder = checkerBuilder;
+exports.useCheckerBuilder = useCheckerBuilder;

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

@@ -0,0 +1,17 @@
+import { type CheckerDefinition, type Checker, type CheckerFunctionOutput, type CheckerFunctionParams } from "../checker";
+import { type Builder, type MaybePromise, type NeverCoalescing } from "@duplojs/utils";
+export interface CheckerBuilderParams {
+    readonly options?: Record<string, unknown>;
+}
+export interface CheckerBuilder<GenericParams extends CheckerBuilderParams = CheckerBuilderParams> extends Builder<CheckerBuilderParams> {
+    handler<GenericInput extends unknown, GenericOutput extends CheckerFunctionOutput>(theFunction: (input: GenericInput, params: CheckerFunctionParams<GenericParams["options"]>) => MaybePromise<GenericOutput>): Checker<{
+        theFunction(input: GenericInput, params: CheckerFunctionParams<GenericParams["options"]>): MaybePromise<GenericOutput>;
+        options: GenericParams["options"];
+    }>;
+}
+export declare const checkerBuilder: import("@duplojs/utils").BuilderHandler<CheckerBuilder<CheckerBuilderParams>>;
+export declare function useCheckerBuilder<GenericOptions extends CheckerDefinition["options"] = never>(params?: {
+    options?: GenericOptions;
+}): CheckerBuilder<{
+    readonly options: NeverCoalescing<GenericOptions, undefined>;
+}>;

package/dist/core/builders/checker.mjs

@@ -0,0 +1,17 @@
+import { createChecker } from '../checker.mjs';
+import { createCoreLibStringIdentifier } from '../stringIdentifier.mjs';
+import { createBuilder } from '@duplojs/utils';
+
+const checkerBuilder = createBuilder(createCoreLibStringIdentifier("checker"));
+checkerBuilder.set("handler", ({ args: [theFunction], accumulator, }) => createChecker({
+    theFunction,
+    options: accumulator.options,
+}));
+function useCheckerBuilder(params) {
+    return checkerBuilder.use({
+        options: undefined,
+        ...params,
+    });
+}
+
+export { checkerBuilder, useCheckerBuilder };

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

@@ -0,0 +1,4 @@
+export * from "./checker";
+export * from "./route";
+export * from "./process";
+export * from "./preflight";

package/dist/core/builders/preflight/builder.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var stringIdentifier = require('../../stringIdentifier.cjs');
+
+const preflightBuilder = utils.createBuilder(stringIdentifier.createCoreLibStringIdentifier("preflight"));
+function usePreflightBuilder(options) {
+    return preflightBuilder.use({
+        preflightSteps: [],
+        hooks: options?.hooks ?? [],
+    });
+}
+
+exports.preflightBuilder = preflightBuilder;
+exports.usePreflightBuilder = usePreflightBuilder;

package/dist/core/builders/preflight/builder.d.ts

@@ -0,0 +1,17 @@
+import { type Floor } from "../../floor";
+import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePreFlightSteps } from "../../route";
+import { type Builder, type NeverCoalescing } from "@duplojs/utils";
+import { type Request } from "../../request";
+export interface PreflightBuilderDefinition {
+    readonly preflightSteps: readonly RoutePreFlightSteps[];
+    readonly hooks: readonly HookRouteLifeCycle[];
+}
+export interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<PreflightBuilderDefinition> {
+}
+export declare const preflightBuilder: import("@duplojs/utils").BuilderHandler<PreflightBuilder<PreflightBuilderDefinition, {}, Request>>;
+export declare function usePreflightBuilder<const GenericHooks extends readonly HookRouteLifeCycle[] = readonly []>(options?: {
+    hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+}): PreflightBuilder<{
+    readonly preflightSteps: readonly [];
+    readonly hooks: GenericHooks;
+}, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;

package/dist/core/builders/preflight/builder.mjs

@@ -0,0 +1,12 @@
+import { createBuilder } from '@duplojs/utils';
+import { createCoreLibStringIdentifier } from '../../stringIdentifier.mjs';
+
+const preflightBuilder = createBuilder(createCoreLibStringIdentifier("preflight"));
+function usePreflightBuilder(options) {
+    return preflightBuilder.use({
+        preflightSteps: [],
+        hooks: options?.hooks ?? [],
+    });
+}
+
+export { preflightBuilder, usePreflightBuilder };

package/dist/core/builders/preflight/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./builder";
+export * from "./process";
+export * from "./route";

package/dist/core/builders/preflight/process.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+var process = require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.preflightBuilder.set("exec", ({ args: [process$1, params,], accumulator, next, }) => next({
+    ...accumulator,
+    preflightSteps: [
+        ...accumulator.preflightSteps,
+        process.createProcessStep({
+            ...params,
+            process: process$1,
+        }),
+    ],
+}));

package/dist/core/builders/preflight/process.d.ts

@@ -0,0 +1,22 @@
+import { type Floor } from "../../floor";
+import { type ProcessStep } from "../../steps";
+import { type O, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction } from "@duplojs/utils";
+import { type GetProcessRequest, type GetProcessExportValue, type Process } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        exec<GenericProcess extends Process, GenericProcessExportValue extends GetProcessExportValue<GenericProcess>, const GenericImportation extends readonly Extract<keyof GenericProcessExportValue, string>[] = never, GenericOptions extends (GenericProcess["definition"]["options"] | ((floor: GenericFloor) => Exclude<GenericProcess["definition"]["options"], undefined>)) = never>(process: GenericProcess, params?: {
+            readonly imports?: GenericImportation;
+            readonly options?: FixDeepFunctionInfer<GenericProcess["definition"]["options"] | ((floor: GenericFloor) => GenericProcess["definition"]["options"]), GenericOptions>;
+        }): PreflightBuilder<O.AssignObjects<GenericDefinition, {
+            readonly preflightSteps: readonly [
+                ...GenericDefinition["preflightSteps"],
+                ProcessStep<{
+                    readonly process: GenericProcess;
+                    readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericProcess["definition"]["options"]>, undefined>;
+                    readonly imports: NeverCoalescing<GenericImportation, undefined>;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, Pick<GenericProcessExportValue, GenericImportation[number]>>, GenericRequest & NeverCoalescing<GetProcessRequest<GenericProcess>, Request>>;
+    }
+}

package/dist/core/builders/preflight/process.mjs

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import { createProcessStep } from '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { preflightBuilder } from './builder.mjs';
+
+preflightBuilder.set("exec", ({ args: [process, params,], accumulator, next, }) => next({
+    ...accumulator,
+    preflightSteps: [
+        ...accumulator.preflightSteps,
+        createProcessStep({
+            ...params,
+            process,
+        }),
+    ],
+}));

package/dist/core/builders/preflight/route.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var builder = require('./builder.cjs');
+var builder$1 = require('../route/builder.cjs');
+require('../route/handler.cjs');
+require('../route/cut.cjs');
+require('../route/extract.cjs');
+require('../route/checker.cjs');
+require('../route/process.cjs');
+require('../route/presetChecker.cjs');
+require('../route/store.cjs');
+var utils = require('@duplojs/utils');
+
+builder.preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options,], accumulator, }) => builder$1.routeBuilderHandler.use({
+    method,
+    paths: utils.A.coalescing(paths),
+    preflightSteps: accumulator.preflightSteps,
+    steps: [],
+    hooks: [
+        ...(options?.hooks ?? []),
+        ...accumulator.hooks,
+    ],
+}));

package/dist/core/builders/preflight/route.d.ts

@@ -0,0 +1,21 @@
+import { type Floor } from "../../floor";
+import { type RequestMethods, type Request } from "../../request";
+import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePath } from "../../route";
+import { type RouteBuilder } from "../route";
+import { type NeverCoalescing } from "@duplojs/utils";
+declare module "./builder" {
+    interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
+            hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+        }): RouteBuilder<{
+            readonly method: GenericMethod;
+            readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
+            readonly preflightSteps: GenericDefinition["preflightSteps"];
+            readonly steps: readonly [];
+            readonly hooks: readonly [
+                ...GenericHooks,
+                ...GenericDefinition["hooks"]
+            ];
+        }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
+    }
+}

package/dist/core/builders/preflight/route.mjs

@@ -0,0 +1,21 @@
+import { preflightBuilder } from './builder.mjs';
+import { routeBuilderHandler } from '../route/builder.mjs';
+import '../route/handler.mjs';
+import '../route/cut.mjs';
+import '../route/extract.mjs';
+import '../route/checker.mjs';
+import '../route/process.mjs';
+import '../route/presetChecker.mjs';
+import '../route/store.mjs';
+import { A } from '@duplojs/utils';
+
+preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options,], accumulator, }) => routeBuilderHandler.use({
+    method,
+    paths: A.coalescing(paths),
+    preflightSteps: accumulator.preflightSteps,
+    steps: [],
+    hooks: [
+        ...(options?.hooks ?? []),
+        ...accumulator.hooks,
+    ],
+}));

package/dist/core/builders/process/builder.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var stringIdentifier = require('../../stringIdentifier.cjs');
+
+const processBuilder = utils.createBuilder(stringIdentifier.createCoreLibStringIdentifier("process"));
+function useProcessBuilder(params) {
+    return processBuilder.use({
+        options: undefined,
+        ...params,
+        steps: [],
+        hooks: params?.hooks ?? [],
+    });
+}
+
+exports.processBuilder = processBuilder;
+exports.useProcessBuilder = useProcessBuilder;

package/dist/core/builders/process/builder.d.ts

@@ -0,0 +1,18 @@
+import { type ProcessDefinition } from "../../process";
+import { type Floor } from "../../floor";
+import { type Builder, type IsEqual, type NeverCoalescing } from "@duplojs/utils";
+import { type MakeRequestFromHooks, type HookRouteLifeCycle } from "../../route";
+import { type Request } from "../../request";
+export interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<ProcessDefinition> {
+}
+export declare const processBuilder: import("@duplojs/utils").BuilderHandler<ProcessBuilder<ProcessDefinition, {}, Request>>;
+export declare function useProcessBuilder<GenericOptions extends ProcessDefinition["options"] = never, const GenericHooks extends readonly HookRouteLifeCycle[] = readonly []>(params?: {
+    options?: GenericOptions;
+    hooks?: GenericHooks | readonly HookRouteLifeCycle[];
+}): ProcessBuilder<{
+    readonly steps: readonly [];
+    readonly options: NeverCoalescing<GenericOptions, undefined>;
+    readonly hooks: GenericHooks;
+}, IsEqual<GenericOptions, never> extends true ? {} : {
+    options: GenericOptions;
+}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;

package/dist/core/builders/process/builder.mjs

@@ -0,0 +1,14 @@
+import { createBuilder } from '@duplojs/utils';
+import { createCoreLibStringIdentifier } from '../../stringIdentifier.mjs';
+
+const processBuilder = createBuilder(createCoreLibStringIdentifier("process"));
+function useProcessBuilder(params) {
+    return processBuilder.use({
+        options: undefined,
+        ...params,
+        steps: [],
+        hooks: params?.hooks ?? [],
+    });
+}
+
+export { processBuilder, useProcessBuilder };

package/dist/core/builders/process/checker.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+var checker = require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.processBuilder.set("check", ({ args: [checker$1, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        checker.createCheckerStep({
+            ...params,
+            responseContract,
+            checker: checker$1,
+        }),
+    ],
+}));

package/dist/core/builders/process/checker.d.ts

@@ -0,0 +1,34 @@
+import { type Floor } from "../../floor";
+import { type CheckerStep } from "../../steps";
+import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfer, type Adaptor, type AnyFunction, type DP, type A } from "@duplojs/utils";
+import { type GetCheckerResult, type Checker, type GetCheckerInput, type GetCheckerOptions } from "../../checker";
+import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
+import { type ProcessDefinition } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        check<GenericChecker extends Checker, GenericResultInformation extends MaybeArray<Awaited<GetCheckerResult<GenericChecker>>["information"]>, GenericInput extends GetCheckerInput<GenericChecker>, GenericResponseContract extends ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>, GenericIndex extends string = never, GenericOptions extends (GetCheckerOptions<GenericChecker> | ((floor: GenericFloor) => Exclude<GetCheckerOptions<GenericChecker>, undefined>)) = never>(checker: GenericChecker, params: {
+            input(floor: GenericFloor): GenericInput;
+            readonly result: GenericResultInformation;
+            readonly indexing?: GenericIndex;
+            readonly options?: FixDeepFunctionInfer<GenericChecker["definition"]["options"] | ((floor: GenericFloor) => GenericChecker["definition"]["options"]), GenericOptions>;
+            readonly otherwise: GenericResponseContract;
+        }): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                CheckerStep<{
+                    readonly checker: GenericChecker;
+                    readonly result: GenericResultInformation;
+                    readonly indexing: NeverCoalescing<GenericIndex, undefined>;
+                    input(floor: GenericFloor): GenericInput;
+                    readonly options: NeverCoalescing<Adaptor<GenericOptions, AnyFunction | GenericChecker["definition"]["options"]>, undefined>;
+                    readonly responseContract: GenericResponseContract;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, {
+            [Prop in GenericIndex]: Extract<Awaited<GetCheckerResult<GenericChecker>>, {
+                information: A.ArrayCoalescing<GenericResultInformation>[number];
+            }>["value"];
+        }>, GenericRequest>;
+    }
+}

package/dist/core/builders/process/checker.mjs

@@ -0,0 +1,21 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import { createCheckerStep } from '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { processBuilder } from './builder.mjs';
+
+processBuilder.set("check", ({ args: [checker, { otherwise: responseContract, ...params },], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createCheckerStep({
+            ...params,
+            responseContract,
+            checker,
+        }),
+    ],
+}));

package/dist/core/builders/process/cut.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+var cut = require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.processBuilder.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        cut.createCutStep({
+            responseContract,
+            theFunction,
+        }),
+    ],
+}));

package/dist/core/builders/process/cut.d.ts

@@ -0,0 +1,19 @@
+import { type Floor } from "../../floor";
+import { type ResponseContract } from "../../response";
+import { type CutStepFunctionOutput, type CutStep, type CutStepFunctionParams } from "../../steps";
+import { type Unwrap, type O, type MaybePromise, type IsEqual, type A } from "@duplojs/utils";
+import { type ProcessDefinition } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        cut<const GenericResponseContract extends (ResponseContract.Contract | readonly ResponseContract.Contract[]), GenericResponse extends ResponseContract.Convert<A.ArrayCoalescing<GenericResponseContract>[number]>, GenericOutput extends CutStepFunctionOutput | GenericResponse>(responseContract: GenericResponseContract, theFunction: (floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>) => MaybePromise<GenericOutput>): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                CutStep<{
+                    readonly responseContract: GenericResponseContract;
+                    theFunction(floor: GenericFloor, param: CutStepFunctionParams<GenericRequest, GenericResponse>): MaybePromise<GenericOutput>;
+                }>
+            ];
+        }>, IsEqual<Extract<GenericOutput, CutStepFunctionOutput>, never> extends true ? GenericFloor : (GenericOutput extends infer InferredOutputData extends CutStepFunctionOutput ? O.AssignObjects<GenericFloor, Unwrap<InferredOutputData>> : never), GenericRequest>;
+    }
+}

package/dist/core/builders/process/cut.mjs

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import '../../steps/extract.mjs';
+import { createCutStep } from '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { processBuilder } from './builder.mjs';
+
+processBuilder.set("cut", ({ args: [responseContract, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createCutStep({
+            responseContract,
+            theFunction,
+        }),
+    ],
+}));

package/dist/core/builders/process/export.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+var builder = require('./builder.cjs');
+var index = require('../../process/index.cjs');
+
+builder.processBuilder.set("exports", ({ accumulator, }) => index.createProcess(accumulator));

package/dist/core/builders/process/export.d.ts

@@ -0,0 +1,12 @@
+import { type Floor } from "../../floor";
+import { type SimplifyTopLevel, type IsEqual, type Or } from "@duplojs/utils";
+import { type Process, type ProcessExportValue, type ProcessDefinition, type ProcessRequest } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        exports<GenericExportation extends (keyof GenericFloor)[] = never>(exportedKey?: GenericExportation): Process<SimplifyTopLevel<GenericDefinition & (Or<[
+            IsEqual<GenericExportation, never>,
+            IsEqual<GenericExportation, never[]>
+        ]> extends true ? {} : ProcessExportValue<SimplifyTopLevel<Pick<GenericFloor, GenericExportation[number]>>>) & (IsEqual<GenericRequest, Request> extends true ? {} : ProcessRequest<GenericRequest>)>>;
+    }
+}

package/dist/core/builders/process/export.mjs

@@ -0,0 +1,4 @@
+import { processBuilder } from './builder.mjs';
+import { createProcess } from '../../process/index.mjs';
+
+processBuilder.set("exports", ({ accumulator, }) => createProcess(accumulator));

package/dist/core/builders/process/extract.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+var extract = require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.processBuilder.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        extract.createExtractStep({
+            shape,
+            responseContract,
+        }),
+    ],
+}));

package/dist/core/builders/process/extract.d.ts

@@ -0,0 +1,25 @@
+import { type Floor } from "../../floor";
+import { type ExtractShape, type ExtractStep } from "../../steps";
+import { type DP, type ObjectEntry, type O, type SimplifyTopLevel, type NeverCoalescing } from "@duplojs/utils";
+import { type ClientErrorResponseCode, type ResponseContract } from "../../response";
+import { type ProcessDefinition } from "../../process";
+import { type Request } from "../../request";
+declare module "./builder" {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        extract<GenericShape extends ExtractShape, GenericResponseContract extends (ResponseContract.Contract<ClientErrorResponseCode, string, DP.DataParserEmpty>) = never>(shape: GenericShape, responseContract?: GenericResponseContract): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                ExtractStep<{
+                    readonly shape: GenericShape;
+                    readonly responseContract: NeverCoalescing<GenericResponseContract, undefined>;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, {
+            [Prop in keyof GenericShape]: GenericShape[Prop] extends DP.DataParser ? [Prop, DP.Output<GenericShape[Prop]>] : GenericShape[Prop] extends infer InferredSubShape extends Record<string, DP.DataParser> ? {
+                [Prop in keyof InferredSubShape]: [Prop, DP.Output<InferredSubShape[Prop]>];
+            }[keyof InferredSubShape] : never;
+        }[keyof GenericShape] extends infer InferredEntry extends ObjectEntry ? SimplifyTopLevel<{
+            [Entry in InferredEntry as Entry[0]]: Entry[1];
+        }> : never>, GenericRequest>;
+    }
+}

package/dist/core/builders/process/extract.mjs

@@ -0,0 +1,20 @@
+import '../../steps/kind.mjs';
+import '../../steps/identifier.mjs';
+import '../../steps/checker.mjs';
+import { createExtractStep } from '../../steps/extract.mjs';
+import '../../steps/cut.mjs';
+import '../../steps/handler.mjs';
+import '../../steps/process.mjs';
+import '../../steps/presetChecker.mjs';
+import { processBuilder } from './builder.mjs';
+
+processBuilder.set("extract", ({ args: [shape, responseContract], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        createExtractStep({
+            shape,
+            responseContract,
+        }),
+    ],
+}));

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

@@ -0,0 +1,7 @@
+export * from "./builder";
+export * from "./cut";
+export * from "./extract";
+export * from "./checker";
+export * from "./process";
+export * from "./export";
+export * from "./presetChecker";

package/dist/core/builders/process/presetChecker.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+require('../../steps/kind.cjs');
+require('../../steps/identifier.cjs');
+require('../../steps/checker.cjs');
+require('../../steps/extract.cjs');
+require('../../steps/cut.cjs');
+require('../../steps/handler.cjs');
+require('../../steps/process.cjs');
+var presetChecker = require('../../steps/presetChecker.cjs');
+var builder = require('./builder.cjs');
+
+builder.processBuilder.set("presetCheck", ({ args: [presetChecker$1, input,], accumulator, next, }) => next({
+    ...accumulator,
+    steps: [
+        ...accumulator.steps,
+        presetChecker.createPresetCheckerStep({
+            presetChecker: presetChecker$1,
+            input,
+        }),
+    ],
+}));

package/dist/core/builders/process/presetChecker.d.ts

@@ -0,0 +1,23 @@
+import { type Floor } from "../../floor";
+import { type PresetCheckerStep } from "../../steps";
+import { type O, type A } from "@duplojs/utils";
+import { type Request } from "../../request";
+import { type GetPresetCheckerIndex, type GetPresetCheckerInformation, type GetPresetCheckerResult, type GetPresetCheckerInput, type PresetChecker } from "../../presetChecker";
+import { type ProcessDefinition } from "../../process";
+declare module "./builder" {
+    interface ProcessBuilder<GenericDefinition extends ProcessDefinition = ProcessDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
+        presetCheck<GenericPresetChecker extends PresetChecker, GenericInput extends GetPresetCheckerInput<GenericPresetChecker>>(presetChecker: GenericPresetChecker, input: (floor: GenericFloor) => GenericInput): ProcessBuilder<O.AssignObjects<GenericDefinition, {
+            readonly steps: readonly [
+                ...GenericDefinition["steps"],
+                PresetCheckerStep<{
+                    readonly presetChecker: GenericPresetChecker;
+                    input(floor: GenericFloor): GenericInput;
+                }>
+            ];
+        }>, O.AssignObjects<GenericFloor, {
+            [Prop in GetPresetCheckerIndex<GenericPresetChecker>]: Extract<Awaited<GetPresetCheckerResult<GenericPresetChecker>>, {
+                information: A.ArrayCoalescing<GetPresetCheckerInformation<GenericPresetChecker>>[number];
+            }>["value"];
+        }>, GenericRequest>;
+    }
+}