@duplojs/http 0.10.0 → 0.11.0

package/dist/core/index.mjs

@@ -20,56 +20,59 @@ import './clean/index.mjs';
 export { initDefaultHook } from './defaultHooks/index.mjs';
 import './errors/index.mjs';
 export { ServerSentEvents } from './serverSentEvents.mjs';
-export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
-export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
-export { routeStore } from './builders/route/store.mjs';
-export { processBuilder, useProcessBuilder } from './builders/process/builder.mjs';
-export { preflightBuilder, usePreflightBuilder } from './builders/preflight/builder.mjs';
-export { Response } from './response/base.mjs';
-export { ResponseContract } from './response/contract.mjs';
+export { Stream } from './stream.mjs';
+export { BodyParseWrongChunkReceived } from './errors/bodyParseWrongChunkReceived.mjs';
+export { BodySizeExceedsLimitError } from './errors/bodySizeExceedsLimitError.mjs';
+export { EmptyBodyController, controlBodyAsEmpty } from './request/bodyController/empty.mjs';
+export { FormDataBodyController, controlBodyAsFormData } from './request/bodyController/formData.mjs';
 export { HookResponse } from './response/hook.mjs';
+export { IgnoreByRouteStoreMetadata } from './metadata/ignoreByRouteStore.mjs';
+export { NotFoundBodyReaderImplementationError } from './router/notFoundBodyReaderImplementationError.mjs';
+export { ParseJsonError } from './errors/parseJsonError.mjs';
 export { PredictedResponse } from './response/predicted.mjs';
+export { Response } from './response/base.mjs';
+export { ResponseContract } from './response/contract.mjs';
+export { RouterBuildError } from './router/buildError.mjs';
 export { ServerSentEventsPredictedResponse } from './response/serverSentEventsPredicted.mjs';
-export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks.mjs';
-export { stepKind } from './steps/kind.mjs';
-export { stepIdentifier } from './steps/identifier.mjs';
+export { StreamPredictedResponse } from './response/streamPredicted.mjs';
+export { StreamTextPredictedResponse } from './response/streamTextPredicted.mjs';
+export { TextBodyController, controlBodyAsText } from './request/bodyController/text.mjs';
+export { WrongBodyReaderImplementationError, createBodyController } from './request/bodyController/base.mjs';
+export { WrongContentTypeError } from './errors/wrongContentTypeError.mjs';
+export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './functionsBuilders/route/default/hook.mjs';
+export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
+export { buildRouterFunction } from './functionsBuilders/router/build.mjs';
+export { buildStepFunction } from './functionsBuilders/steps/build.mjs';
+export { buildStepsFunction, defaultProcessStepFunctionBuilder } from './functionsBuilders/steps/defaults/processStep.mjs';
+export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { checkerStepKind, createCheckerStep } from './steps/checker.mjs';
-export { createExtractStep, extractStepKind } from './steps/extract.mjs';
 export { createCutStep, cutStepKind, cutStepOutputKind } from './steps/cut.mjs';
+export { createExtractStep, extractStepKind } from './steps/extract.mjs';
 export { createHandlerStep, handlerStepKind } from './steps/handler.mjs';
-export { createProcessStep, processStepKind } from './steps/process.mjs';
-export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
-export { WrongBodyReaderImplementationError, createBodyController } from './request/bodyController/base.mjs';
-export { FormDataBodyController, controlBodyAsFormData } from './request/bodyController/formData.mjs';
-export { TextBodyController, controlBodyAsText } from './request/bodyController/text.mjs';
-export { EmptyBodyController, controlBodyAsEmpty } from './request/bodyController/empty.mjs';
 export { createHookHubLifeCycle, hookServerExitKind, hookServerNextKind, launchHookBeforeBuildRoute, launchHookServer, launchHookServerError, serverErrorExitHookFunction, serverErrorNextHookFunction } from './hub/hooks.mjs';
-export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
-export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
-export { defaultBodyController } from './hub/defaultBodyController.mjs';
-export { defaultMalformedUrlHandler } from './hub/defaultMalformedUrlHandler.mjs';
-export { defaultEmptyReaderImplementation } from './hub/defaultEmptyReaderImplementation.mjs';
-export { buildRouteFunction } from './functionsBuilders/route/build.mjs';
+export { createHookRouteLifeCycle, hookRouteExitKind, hookRouteNextKind } from './route/hooks.mjs';
+export { createMetadata, metadataKind } from './metadata/base.mjs';
+export { createPresetCheckerStep, presetCheckerStepKind } from './steps/presetChecker.mjs';
+export { createProcessStep, processStepKind } from './steps/process.mjs';
 export { createRouteFunctionBuilder } from './functionsBuilders/route/create.mjs';
-export { buildHookAfter, buildHookBefore, buildHookErrorBefore, createHookResponse, exitHookFunction, nextHookFunction } from './functionsBuilders/route/default/hook.mjs';
-export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default/index.mjs';
+export { createRouterElementSystem } from './router/createRouterElementSystem.mjs';
+export { createRouterFunctionBuilder } from './functionsBuilders/router/create.mjs';
 export { createStepFunctionBuilder } from './functionsBuilders/steps/create.mjs';
+export { defaultBodyController } from './hub/defaultBodyController.mjs';
 export { defaultCheckerStepFunctionBuilder } from './functionsBuilders/steps/defaults/checkerStep.mjs';
 export { defaultCutStepFunctionBuilder } from './functionsBuilders/steps/defaults/cutStep.mjs';
-export { defaultHandlerStepFunctionBuilder } from './functionsBuilders/steps/defaults/handlerStep.mjs';
+export { defaultEmptyReaderImplementation } from './hub/defaultEmptyReaderImplementation.mjs';
+export { defaultExtractContract } from './hub/defaultExtractContract.mjs';
 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 { defaultHandlerStepFunctionBuilder } from './functionsBuilders/steps/defaults/handlerStep.mjs';
+export { defaultMalformedUrlHandler } from './hub/defaultMalformedUrlHandler.mjs';
+export { defaultNotfoundHandler } from './hub/defaultNotfoundHandler.mjs';
+export { defaultRouteFunctionBuilder } from './functionsBuilders/route/default/index.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 { NotFoundBodyReaderImplementationError } from './router/notFoundBodyReaderImplementationError.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';
-export { BodyParseWrongChunkReceived } from './errors/bodyParseWrongChunkReceived.mjs';
-export { BodySizeExceedsLimitError } from './errors/bodySizeExceedsLimitError.mjs';
-export { ParseJsonError } from './errors/parseJsonError.mjs';
+export { preflightBuilder, usePreflightBuilder } from './builders/preflight/builder.mjs';
+export { processBuilder, useProcessBuilder } from './builders/process/builder.mjs';
+export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
+export { routeStore } from './builders/route/store.mjs';
+export { stepIdentifier } from './steps/identifier.mjs';
+export { stepKind } from './steps/kind.mjs';

package/dist/core/response/contract.cjs

@@ -91,6 +91,27 @@ exports.ResponseContract = void 0;
         });
     }
     ResponseContract.serverSentEvents = serverSentEvents;
+    ResponseContract.streamContractKind = kind.createCoreLibKind("stream-response-contract");
+    function stream(information, schema) {
+        return ResponseContract.streamContractKind.setTo({
+            code: "200",
+            information,
+            flux: schema,
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.stream = stream;
+    ResponseContract.streamTextContractKind = kind.createCoreLibKind("stream-text-response-contract");
+    const defaultStreamTextSchema = utils.DP.string();
+    function streamText(information) {
+        return ResponseContract.streamTextContractKind.setTo({
+            code: "200",
+            information,
+            flux: defaultStreamTextSchema,
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.streamText = streamText;
     class Error extends utils.kindHeritage("contract-error", kind.createCoreLibKind("contract-error"), ErrorClass) {
         information;
         detail;

package/dist/core/response/contract.d.ts

@@ -1,6 +1,7 @@
-import { DP, type Kind, type NeverCoalescing } from "@duplojs/utils";
-import { type ResponseCode, type PredictedResponse, type ServerSentEventsPredictedResponse, type SuccessResponseCode } from ".";
+import { DP, type Kind, type IsEqual, type NeverCoalescing } from "@duplojs/utils";
+import { type ResponseCode, type PredictedResponse, type ServerSentEventsPredictedResponse, type SuccessResponseCode, type StreamTextPredictedResponse } from ".";
 import { type ForbiddenBigintDataParser } from "../types";
+import { type StreamPredictedResponse } from "./streamPredicted";
 export declare namespace ResponseContract {
     type SupportedDataParser = DP.DataParser;
     export const contractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/response-contract", unknown>>;
@@ -9,6 +10,11 @@ export declare namespace ResponseContract {
         information: GenericInformation;
         body: GenericSchema;
     }
+    const defaultSchema: DP.DataParserEmpty<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
+    }>;
     export const http100Continue: <GenericInformation extends string, GenericSchema extends SupportedDataParser = DP.DataParserEmpty<{
         readonly errorMessage?: string | undefined;
         readonly coerce: boolean;
@@ -287,15 +293,37 @@ export declare namespace ResponseContract {
         events: GenericEvents;
         body: GenericSchema;
     }
-    export function serverSentEvents<GenericInformation extends string, GenericMainEventSchema extends SupportedDataParser, GenericEvents extends Record<string, SupportedDataParser> = {}>(information: GenericInformation, mainEventSchema: GenericMainEventSchema, events?: GenericEvents): ServerSentEventsContract<"200", GenericInformation, GenericEvents & {
+    export function serverSentEvents<GenericInformation extends string, GenericMainEventSchema extends SupportedDataParser, GenericEvents extends Record<string, SupportedDataParser> = {}>(information: GenericInformation, mainEventSchema: GenericMainEventSchema, events?: GenericEvents): ServerSentEventsContract<"200", GenericInformation, (IsEqual<GenericEvents, Record<string, SupportedDataParser>> extends true ? {} : GenericEvents) & {
         message: GenericMainEventSchema;
+    }, typeof defaultSchema>;
+    export const streamContractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/stream-response-contract", unknown>>;
+    export interface StreamContract<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string, GenericFlux extends SupportedDataParser = SupportedDataParser, GenericSchema extends SupportedDataParser = SupportedDataParser> extends Kind<typeof streamContractKind.definition> {
+        code: GenericCode;
+        information: GenericInformation;
+        flux: GenericFlux;
+        body: GenericSchema;
+    }
+    export function stream<GenericInformation extends string, GenericSchema extends SupportedDataParser>(information: GenericInformation, schema: GenericSchema): StreamContract<"200", GenericInformation, GenericSchema, typeof defaultSchema>;
+    export const streamTextContractKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/stream-text-response-contract", unknown>>;
+    export interface StreamTextContract<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string, GenericFlux extends DP.Contract<string> = DP.Contract<string>, GenericSchema extends SupportedDataParser = SupportedDataParser> extends Kind<typeof streamTextContractKind.definition> {
+        code: GenericCode;
+        information: GenericInformation;
+        flux: GenericFlux;
+        body: GenericSchema;
+    }
+    const defaultStreamTextSchema: DP.DataParserString<{
+        readonly errorMessage?: string | undefined;
+        readonly coerce: boolean;
+        readonly checkers: readonly [];
     }>;
-    export type Convert<GenericContract extends Contract | ServerSentEventsContract> = GenericContract extends Contract ? PredictedResponse<GenericContract["code"], GenericContract["information"], DP.Input<GenericContract["body"]>> : GenericContract extends ServerSentEventsContract ? ServerSentEventsPredictedResponse<GenericContract["code"], GenericContract["information"], {
+    export function streamText<GenericInformation extends string>(information: GenericInformation): StreamTextContract<"200", GenericInformation, typeof defaultStreamTextSchema, typeof defaultSchema>;
+    export type Contracts = (Contract | ServerSentEventsContract | StreamContract | StreamTextContract);
+    export type Convert<GenericContract extends Contracts> = GenericContract extends Contract ? PredictedResponse<GenericContract["code"], GenericContract["information"], DP.Output<GenericContract["body"]>> : GenericContract extends ServerSentEventsContract ? ServerSentEventsPredictedResponse<GenericContract["code"], GenericContract["information"], {
         [Prop in keyof GenericContract["events"]]: [
             Extract<Prop, string>,
             DP.Output<GenericContract["events"][Prop]>
         ];
-    }[keyof GenericContract["events"]]> : never;
+    }[keyof GenericContract["events"]]> : GenericContract extends StreamContract ? StreamPredictedResponse<GenericContract["code"], GenericContract["information"], DP.Output<GenericContract["flux"]>> : GenericContract extends StreamTextContract ? StreamTextPredictedResponse<GenericContract["code"], GenericContract["information"]> : never;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
     }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => globalThis.Error & Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown>;

package/dist/core/response/contract.mjs

@@ -89,6 +89,27 @@ var ResponseContract;
         });
     }
     ResponseContract.serverSentEvents = serverSentEvents;
+    ResponseContract.streamContractKind = createCoreLibKind("stream-response-contract");
+    function stream(information, schema) {
+        return ResponseContract.streamContractKind.setTo({
+            code: "200",
+            information,
+            flux: schema,
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.stream = stream;
+    ResponseContract.streamTextContractKind = createCoreLibKind("stream-text-response-contract");
+    const defaultStreamTextSchema = DP.string();
+    function streamText(information) {
+        return ResponseContract.streamTextContractKind.setTo({
+            code: "200",
+            information,
+            flux: defaultStreamTextSchema,
+            body: defaultSchema,
+        });
+    }
+    ResponseContract.streamText = streamText;
     class Error extends kindHeritage("contract-error", createCoreLibKind("contract-error"), ErrorClass) {
         information;
         detail;

package/dist/core/response/index.cjs

@@ -5,6 +5,8 @@ var contract = require('./contract.cjs');
 var hook = require('./hook.cjs');
 var predicted = require('./predicted.cjs');
 var serverSentEventsPredicted = require('./serverSentEventsPredicted.cjs');
+var streamPredicted = require('./streamPredicted.cjs');
+var streamTextPredicted = require('./streamTextPredicted.cjs');
 
 
 
@@ -16,3 +18,5 @@ Object.defineProperty(exports, "ResponseContract", {
 exports.HookResponse = hook.HookResponse;
 exports.PredictedResponse = predicted.PredictedResponse;
 exports.ServerSentEventsPredictedResponse = serverSentEventsPredicted.ServerSentEventsPredictedResponse;
+exports.StreamPredictedResponse = streamPredicted.StreamPredictedResponse;
+exports.StreamTextPredictedResponse = streamTextPredicted.StreamTextPredictedResponse;

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

@@ -1,5 +1,12 @@
+import { type PredictedResponse } from "./predicted";
+import { type ServerSentEventsPredictedResponse } from "./serverSentEventsPredicted";
+import { type StreamPredictedResponse } from "./streamPredicted";
+import { type StreamTextPredictedResponse } from "./streamTextPredicted";
 export * from "./base";
 export * from "./contract";
 export * from "./hook";
 export * from "./predicted";
 export * from "./serverSentEventsPredicted";
+export * from "./streamPredicted";
+export * from "./streamTextPredicted";
+export type PredictedResponses = (PredictedResponse | ServerSentEventsPredictedResponse | StreamPredictedResponse | StreamTextPredictedResponse);

package/dist/core/response/index.mjs

@@ -3,3 +3,5 @@ export { ResponseContract } from './contract.mjs';
 export { HookResponse } from './hook.mjs';
 export { PredictedResponse } from './predicted.mjs';
 export { ServerSentEventsPredictedResponse } from './serverSentEventsPredicted.mjs';
+export { StreamPredictedResponse } from './streamPredicted.mjs';
+export { StreamTextPredictedResponse } from './streamTextPredicted.mjs';

package/dist/core/response/streamPredicted.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+require('./index.cjs');
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class StreamPredictedResponse extends utils.kindHeritage("stream-predicted-response", kind.createCoreLibKind("stream-predicted-response"), base.Response) {
+    startStream;
+    code;
+    information;
+    body = undefined;
+    constructor(code, information, startStream) {
+        super(defaultParams, defaultParamsParent);
+        this.startStream = startStream;
+        this.code = code;
+        this.information = information;
+    }
+}
+
+exports.StreamPredictedResponse = StreamPredictedResponse;

package/dist/core/response/streamPredicted.d.ts

@@ -0,0 +1,14 @@
+import { Response, type SuccessResponseCode } from "../response";
+import { type Stream } from "../stream";
+import { type MaybePromise } from "@duplojs/utils";
+declare const StreamPredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/stream-predicted-response"?: unknown;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/stream-predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"stream-predicted-response", unknown>, unknown>;
+export declare class StreamPredictedResponse<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string, GenericFlux extends unknown = unknown> extends StreamPredictedResponse_base {
+    startStream: (params: Stream.StartSendingParams<GenericFlux>) => MaybePromise<void>;
+    code: GenericCode;
+    information: GenericInformation;
+    body: undefined;
+    constructor(code: GenericCode, information: GenericInformation, startStream: (params: Stream.StartSendingParams<GenericFlux>) => MaybePromise<void>);
+}
+export {};

package/dist/core/response/streamPredicted.mjs

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

package/dist/core/response/streamTextPredicted.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+require('./index.cjs');
+var utils = require('@duplojs/utils');
+var base = require('./base.cjs');
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class StreamTextPredictedResponse extends utils.kindHeritage("stream-text-predicted-response", kind.createCoreLibKind("stream-text-predicted-response"), base.Response) {
+    startStream;
+    code;
+    information;
+    body = undefined;
+    constructor(code, information, startStream) {
+        super(defaultParams, defaultParamsParent);
+        this.startStream = startStream;
+        this.code = code;
+        this.information = information;
+    }
+}
+
+exports.StreamTextPredictedResponse = StreamTextPredictedResponse;

package/dist/core/response/streamTextPredicted.d.ts

@@ -0,0 +1,14 @@
+import { Response, type SuccessResponseCode } from "../response";
+import { type Stream } from "../stream";
+import { type MaybePromise } from "@duplojs/utils";
+declare const StreamTextPredictedResponse_base: new (params: {
+    "@DuplojsHttpCore/stream-text-predicted-response"?: unknown;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/stream-text-predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"stream-text-predicted-response", unknown>, unknown>;
+export declare class StreamTextPredictedResponse<GenericCode extends SuccessResponseCode = SuccessResponseCode, GenericInformation extends string = string> extends StreamTextPredictedResponse_base {
+    startStream: (params: Stream.StartSendingParams<string>) => MaybePromise<void>;
+    code: GenericCode;
+    information: GenericInformation;
+    body: undefined;
+    constructor(code: GenericCode, information: GenericInformation, startStream: (params: Stream.StartSendingParams<string>) => MaybePromise<void>);
+}
+export {};

package/dist/core/response/streamTextPredicted.mjs

@@ -0,0 +1,21 @@
+import { createCoreLibKind } from '../kind.mjs';
+import './index.mjs';
+import { kindHeritage } from '@duplojs/utils';
+import { Response } from './base.mjs';
+
+const defaultParamsParent = [undefined, undefined, undefined];
+const defaultParams = {};
+class StreamTextPredictedResponse extends kindHeritage("stream-text-predicted-response", createCoreLibKind("stream-text-predicted-response"), Response) {
+    startStream;
+    code;
+    information;
+    body = undefined;
+    constructor(code, information, startStream) {
+        super(defaultParams, defaultParamsParent);
+        this.startStream = startStream;
+        this.code = code;
+        this.information = information;
+    }
+}
+
+export { StreamTextPredictedResponse };

package/dist/core/serverSentEvents.cjs

@@ -1,96 +1,44 @@
 'use strict';
 
 var utils = require('@duplojs/utils');
+var stream = require('./stream.cjs');
 
 /* eslint-disable @typescript-eslint/prefer-for-of */
 exports.ServerSentEvents = void 0;
 (function (ServerSentEvents) {
     const regexServerSentEventSplitStringData = /\r\n|\r|\n/;
     const nullIdRegexp = /\0|\n|\r/;
-    function init(response, initParams) {
-        const abortSubscribers = [];
-        let isAbort = false;
-        const handler = {
-            async start(send, close) {
-                if (isAbort) {
-                    return;
+    function init(startSendingEvents, initParams) {
+        return stream.Stream.init((streamParams) => startSendingEvents({
+            ...streamParams,
+            lastId: initParams.lastId,
+            send: (event, data, params) => {
+                if (streamParams.isClose()) {
+                    return Promise.resolve();
                 }
-                let isClose = false;
-                const closeSubscribers = [];
-                const errorSubscribers = [];
-                const params = {
-                    send: (event, data, params) => {
-                        if (isClose) {
-                            return Promise.resolve();
-                        }
-                        else if (isAbort) {
-                            return Promise.resolve();
-                        }
-                        let content = `event: ${event || "message"}\n`;
-                        if (typeof data === "string") {
-                            const splitData = data.split(regexServerSentEventSplitStringData);
-                            for (let index = 0; index < splitData.length; index++) {
-                                content += `data: ${splitData[index]}\n`;
-                            }
-                        }
-                        else if (data !== undefined) {
-                            content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
-                        }
-                        if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
-                            content += `id: ${params.id}\n`;
-                        }
-                        if (params?.retry !== undefined) {
-                            content += `retry: ${utils.stringToMillisecond(params.retry)}\n`;
-                        }
-                        content += "\n";
-                        return send(content);
-                    },
-                    abort: handler.abort,
-                    isAbort: () => isAbort,
-                    onAbort: (theFunction) => void abortSubscribers.push(theFunction),
-                    close: () => {
-                        if (isClose === true) {
-                            return;
-                        }
-                        isClose = true;
-                        close();
-                        for (let index = 0; index < closeSubscribers.length; index++) {
-                            closeSubscribers[index]();
-                        }
-                    },
-                    isClose: () => isClose,
-                    onClose: (theFunction) => void closeSubscribers.push(theFunction),
-                    error: (error) => {
-                        for (let index = 0; index < errorSubscribers.length; index++) {
-                            errorSubscribers[index](error);
-                        }
-                    },
-                    onError: (theFunction) => void errorSubscribers.push(theFunction),
-                    lastId: initParams.lastId && !nullIdRegexp.test(initParams.lastId)
-                        ? initParams.lastId
-                        : null,
-                };
-                try {
-                    await response.startSendingEvents(params);
+                else if (streamParams.isAbort()) {
+                    return Promise.resolve();
                 }
-                catch (error) {
-                    params.error(error);
+                let content = `event: ${event || "message"}\n`;
+                if (typeof data === "string") {
+                    const splitData = data.split(regexServerSentEventSplitStringData);
+                    for (let index = 0; index < splitData.length; index++) {
+                        content += `data: ${splitData[index]}\n`;
+                    }
                 }
-                finally {
-                    params.close();
+                else if (data !== undefined) {
+                    content += `content-type: application/json\ndata: ${JSON.stringify(data)}\n`;
                 }
-            },
-            abort() {
-                if (isAbort === true) {
-                    return;
+                if (typeof params?.id === "string" && !nullIdRegexp.test(params.id)) {
+                    content += `id: ${params.id}\n`;
                 }
-                isAbort = true;
-                for (let index = 0; index < abortSubscribers.length; index++) {
-                    abortSubscribers[index]();
+                if (params?.retry !== undefined) {
+                    content += `retry: ${utils.stringToMillisecond(params.retry)}\n`;
                 }
+                content += "\n";
+                return streamParams.send(content);
             },
-        };
-        return handler;
+        }));
     }
     ServerSentEvents.init = init;
 })(exports.ServerSentEvents || (exports.ServerSentEvents = {}));

package/dist/core/serverSentEvents.d.ts

@@ -1,33 +1,21 @@
-import { type MillisecondInString } from "@duplojs/utils";
-import { type ServerSentEventsPredictedResponse } from "./response";
+import { type MaybePromise, type MillisecondInString } from "@duplojs/utils";
+import { Stream } from "./stream";
 export declare namespace ServerSentEvents {
     type DefinitionShape = [string, unknown];
     interface SendParams {
         id?: string;
         retry?: number | MillisecondInString;
     }
-    interface StartSendingParams<GenericEvents extends DefinitionShape = DefinitionShape> {
+    interface StartSendingParams<GenericEvents extends DefinitionShape = DefinitionShape> extends Stream.StartSendingParams {
         send(...args: GenericEvents extends any ? [
             event: GenericEvents[0],
             ...(GenericEvents[1] extends undefined ? [data?: GenericEvents[1]] : [data: GenericEvents[1]]),
             params?: SendParams
         ] : never): Promise<void>;
-        abort(): void;
-        onAbort(theFunction: () => void): void;
-        isAbort(): boolean;
-        close(): void;
-        onClose(theFunction: () => void): void;
-        isClose(): boolean;
-        error(error: unknown): void;
-        onError(theFunction: (error: unknown) => void): void;
         readonly lastId: string | null;
     }
-    interface Handler {
-        start(send: (value: string) => Promise<void>, close: () => void): Promise<void>;
-        abort(): void;
-    }
     interface InitParams {
         readonly lastId: string | null;
     }
-    function init(response: ServerSentEventsPredictedResponse, initParams: InitParams): Handler;
+    function init(startSendingEvents: (params: StartSendingParams) => MaybePromise<void>, initParams: InitParams): Stream.Handler;
 }