@kaito-http/core 3.0.0-beta.8 → 3.0.2

package/dist/stream/stream.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/stream/stream.ts
+var stream_exports = {};
+__export(stream_exports, {
+  KaitoSSEResponse: () => KaitoSSEResponse,
+  SSEController: () => SSEController,
+  sse: () => sse,
+  sseEventToString: () => sseEventToString,
+  sseFromAnyReadable: () => sseFromAnyReadable
+});
+module.exports = __toCommonJS(stream_exports);
+var KaitoSSEResponse = class extends Response {
+  constructor(body, init) {
+    const headers = new Headers(init?.headers);
+    headers.set("Content-Type", "text/event-stream");
+    headers.set("Cache-Control", "no-cache");
+    headers.set("Connection", "keep-alive");
+    super(body, {
+      ...init,
+      headers
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const chunk of this.body) {
+      yield chunk;
+    }
+  }
+};
+function sseEventToString(event) {
+  let result = "";
+  if (event.event) {
+    result += `event:${event.event}
+`;
+  }
+  if (event.id) {
+    result += `id:${event.id}
+`;
+  }
+  if (event.retry) {
+    result += `retry:${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
+  }
+  return result;
+}
+var SSEController = class {
+  controller;
+  constructor(controller) {
+    this.controller = controller;
+  }
+  enqueue(event) {
+    this.controller.enqueue(sseEventToString(event) + "\n\n");
+  }
+  close() {
+    this.controller.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+function sseFromSource(source) {
+  const start = source.start;
+  const pull = source.pull;
+  const cancel = source.cancel;
+  const readable = new ReadableStream({
+    ...cancel ? { cancel } : {},
+    ...start ? {
+      start: async (controller) => {
+        await start(new SSEController(controller));
+      }
+    } : {},
+    ...pull ? {
+      pull: async (controller) => {
+        await pull(new SSEController(controller));
+      }
+    } : {}
+  });
+  return new KaitoSSEResponse(readable);
+}
+function sse(source) {
+  const evaluated = typeof source === "function" ? source() : source;
+  if ("next" in evaluated) {
+    const generator = evaluated;
+    return sseFromSource({
+      async start(controller) {
+        try {
+          for await (const event of generator) {
+            controller.enqueue(event);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  } else {
+    return sseFromSource(evaluated);
+  }
+}
+function sseFromAnyReadable(stream, transform) {
+  const transformer = new TransformStream({
+    transform: (chunk, controller) => {
+      controller.enqueue(transform(chunk));
+    }
+  });
+  return sse(stream.pipeThrough(transformer));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KaitoSSEResponse,
+  SSEController,
+  sse,
+  sseEventToString,
+  sseFromAnyReadable
+});

package/dist/stream/stream.d.cts

@@ -0,0 +1,36 @@
+declare class KaitoSSEResponse<_T> extends Response {
+    constructor(body: ReadableStream<string>, init?: ResponseInit);
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+}
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
+} | {
+    data?: T | undefined;
+    event: E;
+}) & {
+    retry?: number;
+    id?: string;
+};
+/**
+ * Converts an SSE Event into a string, ready for sending to the client
+ * @param event The SSE Event
+ * @returns A stringified version
+ */
+declare function sseEventToString(event: SSEEvent<unknown, string>): string;
+declare class SSEController<U, E extends string> implements Disposable {
+    private readonly controller;
+    constructor(controller: ReadableStreamDefaultController<string>);
+    enqueue(event: SSEEvent<U, E>): void;
+    close(): void;
+    [Symbol.dispose](): void;
+}
+interface SSESource<U, E extends string> {
+    cancel?: UnderlyingSourceCancelCallback;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
+}
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
+
+export { KaitoSSEResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable };

package/dist/stream/stream.d.ts

@@ -0,0 +1,36 @@
+declare class KaitoSSEResponse<_T> extends Response {
+    constructor(body: ReadableStream<string>, init?: ResponseInit);
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array<ArrayBufferLike>, void, unknown>;
+}
+type SSEEvent<T, E extends string> = ({
+    data: T;
+    event?: E | undefined;
+} | {
+    data?: T | undefined;
+    event: E;
+}) & {
+    retry?: number;
+    id?: string;
+};
+/**
+ * Converts an SSE Event into a string, ready for sending to the client
+ * @param event The SSE Event
+ * @returns A stringified version
+ */
+declare function sseEventToString(event: SSEEvent<unknown, string>): string;
+declare class SSEController<U, E extends string> implements Disposable {
+    private readonly controller;
+    constructor(controller: ReadableStreamDefaultController<string>);
+    enqueue(event: SSEEvent<U, E>): void;
+    close(): void;
+    [Symbol.dispose](): void;
+}
+interface SSESource<U, E extends string> {
+    cancel?: UnderlyingSourceCancelCallback;
+    start?(controller: SSEController<U, E>): Promise<void>;
+    pull?(controller: SSEController<U, E>): Promise<void>;
+}
+declare function sse<U, E extends string, T extends SSEEvent<U, E>>(source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>)): KaitoSSEResponse<T>;
+declare function sseFromAnyReadable<R, U, E extends string>(stream: ReadableStream<R>, transform: (chunk: R) => SSEEvent<U, E>): KaitoSSEResponse<SSEEvent<U, E>>;
+
+export { KaitoSSEResponse, SSEController, type SSEEvent, type SSESource, sse, sseEventToString, sseFromAnyReadable };

package/dist/stream/stream.js

@@ -0,0 +1,105 @@
+// src/stream/stream.ts
+var KaitoSSEResponse = class extends Response {
+  constructor(body, init) {
+    const headers = new Headers(init?.headers);
+    headers.set("Content-Type", "text/event-stream");
+    headers.set("Cache-Control", "no-cache");
+    headers.set("Connection", "keep-alive");
+    super(body, {
+      ...init,
+      headers
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const chunk of this.body) {
+      yield chunk;
+    }
+  }
+};
+function sseEventToString(event) {
+  let result = "";
+  if (event.event) {
+    result += `event:${event.event}
+`;
+  }
+  if (event.id) {
+    result += `id:${event.id}
+`;
+  }
+  if (event.retry) {
+    result += `retry:${event.retry}
+`;
+  }
+  if (event.data !== void 0) {
+    result += `data:${JSON.stringify(event.data)}`;
+  }
+  return result;
+}
+var SSEController = class {
+  controller;
+  constructor(controller) {
+    this.controller = controller;
+  }
+  enqueue(event) {
+    this.controller.enqueue(sseEventToString(event) + "\n\n");
+  }
+  close() {
+    this.controller.close();
+  }
+  [Symbol.dispose]() {
+    this.close();
+  }
+};
+function sseFromSource(source) {
+  const start = source.start;
+  const pull = source.pull;
+  const cancel = source.cancel;
+  const readable = new ReadableStream({
+    ...cancel ? { cancel } : {},
+    ...start ? {
+      start: async (controller) => {
+        await start(new SSEController(controller));
+      }
+    } : {},
+    ...pull ? {
+      pull: async (controller) => {
+        await pull(new SSEController(controller));
+      }
+    } : {}
+  });
+  return new KaitoSSEResponse(readable);
+}
+function sse(source) {
+  const evaluated = typeof source === "function" ? source() : source;
+  if ("next" in evaluated) {
+    const generator = evaluated;
+    return sseFromSource({
+      async start(controller) {
+        try {
+          for await (const event of generator) {
+            controller.enqueue(event);
+          }
+        } finally {
+          controller.close();
+        }
+      }
+    });
+  } else {
+    return sseFromSource(evaluated);
+  }
+}
+function sseFromAnyReadable(stream, transform) {
+  const transformer = new TransformStream({
+    transform: (chunk, controller) => {
+      controller.enqueue(transform(chunk));
+    }
+  });
+  return sse(stream.pipeThrough(transformer));
+}
+export {
+  KaitoSSEResponse,
+  SSEController,
+  sse,
+  sseEventToString,
+  sseFromAnyReadable
+};

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "@kaito-http/core",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.2",
   "type": "module",
   "author": "Alistair Smith <hi@alistair.sh>",
   "description": "Functional HTTP Framework for TypeScript",
   "scripts": {
-    "build": "tsup"
+    "build": "tsup",
+    "attw": "attw --profile node16 --pack .",
+    "test": "node --test --import=tsx ./src/**/*.test.ts"
   },
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./stream": {
+      "import": "./dist/stream/stream.js",
+      "require": "./dist/stream/stream.cjs"
+    },
+    "./cors": {
+      "import": "./dist/cors/cors.js",
+      "require": "./dist/cors/cors.cjs"
     }
   },
   "homepage": "https://github.com/kaito-http/kaito",
@@ -23,11 +33,10 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@types/content-type": "^1.1.8",
-    "@types/cookie": "^0.6.0",
-    "@types/node": "^22.7.4",
-    "tsup": "^8.3.0",
-    "typescript": "^5.6.2"
+    "@arethetypeswrong/cli": "^0.17.2",
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
   },
   "files": [
     "package.json",
@@ -36,11 +45,5 @@
   ],
   "bugs": {
     "url": "https://github.com/kaito-http/kaito/issues"
-  },
-  "dependencies": {
-    "content-type": "^1.0.5",
-    "cookie": "^0.6.0",
-    "find-my-way": "^9.1.0",
-    "raw-body": "^3.0.0"
   }
 }