@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/eventsource/node_modules/eventsource-parser/dist/stream.js

@@ -0,0 +1,59 @@
+import { createParser } from './parse.js';
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({onError: 'terminate'}))
+ * ```
+ *
+ * @public
+ */
+export class EventSourceParserStream extends TransformStream {
+    constructor({ onError, onRetry, onComment, onId, maxBufferSize } = {}) {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser({
+                    onEvent: (event) => {
+                        controller.enqueue(event);
+                    },
+                    onError(error) {
+                        if (typeof onError === 'function') {
+                            onError(error);
+                        }
+                        // `max-buffer-size-exceeded` is fatal — the parser is unusable until
+                        // `reset()`, which the stream wrapper has no way to call. Always
+                        // terminate the stream in that case so consumers see the meaningful
+                        // `ParseError` instead of an opaque "cannot feed terminated parser"
+                        // throw from the next chunk.
+                        if (onError === 'terminate' || error.type === 'max-buffer-size-exceeded') {
+                            controller.error(error);
+                        }
+                        // Ignore by default
+                    },
+                    onRetry,
+                    onComment,
+                    onId,
+                    maxBufferSize,
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}
+export { ParseError } from './errors.js';
+//# sourceMappingURL=stream.js.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAA;AAwDvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,uBAAwB,SAAQ,eAA2C;IACtF,YAAY,EAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,aAAa,EAAC,GAAkB,EAAE;QAChF,IAAI,MAA0B,CAAA;QAE9B,KAAK,CAAC;YACJ,KAAK,CAAC,UAAU;gBACd,MAAM,GAAG,YAAY,CAAC;oBACpB,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;wBACjB,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;oBAC3B,CAAC;oBACD,OAAO,CAAC,KAAK;wBACX,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;4BAClC,OAAO,CAAC,KAAK,CAAC,CAAA;wBAChB,CAAC;wBAED,qEAAqE;wBACrE,iEAAiE;wBACjE,oEAAoE;wBACpE,oEAAoE;wBACpE,6BAA6B;wBAC7B,IAAI,OAAO,KAAK,WAAW,IAAI,KAAK,CAAC,IAAI,KAAK,0BAA0B,EAAE,CAAC;4BACzE,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;wBACzB,CAAC;wBAED,oBAAoB;oBACtB,CAAC;oBACD,OAAO;oBACP,SAAS;oBACT,IAAI;oBACJ,aAAa;iBACd,CAAC,CAAA;YACJ,CAAC;YACD,SAAS,CAAC,KAAK;gBACb,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YACpB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;CACF;AAED,OAAO,EAAiB,UAAU,EAAC,MAAM,aAAa,CAAA"}

package/node_modules/eventsource/node_modules/eventsource-parser/dist/types.d.ts

@@ -0,0 +1,130 @@
+import type { ParseError } from './errors.ts';
+/**
+ * EventSource parser instance.
+ *
+ * Needs to be reset between reconnections/when switching data source, using the `reset()` method.
+ *
+ * @public
+ */
+export interface EventSourceParser {
+    /**
+     * Feeds the parser another chunk. The method _does not_ return a parsed message.
+     * Instead, callbacks passed when creating the parser will be triggered once we see enough data
+     * for a valid/invalid parsing step (see {@link ParserCallbacks}).
+     *
+     * @param chunk - The chunk to parse. Can be a partial, eg in the case of streaming messages.
+     * @public
+     */
+    feed(chunk: string): void;
+    /**
+     * Resets the parser state. This is required when you have a new stream of messages -
+     * for instance in the case of a client being disconnected and reconnecting.
+     *
+     * Previously received, incomplete data will NOT be parsed unless you pass `consume: true`,
+     * which tells the parser to attempt to consume any incomplete data as if it ended with a newline
+     * character. This is useful for cases when a server sends a non-EventSource message that you
+     * want to be able to react to in an `onError` callback.
+     *
+     * @public
+     */
+    reset(options?: {
+        consume?: boolean;
+    }): void;
+}
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export interface EventSourceMessage {
+    /**
+     * The event type sent from the server. Note that this differs from the browser `EventSource`
+     * implementation in that browsers will default this to `message`, whereas this parser will
+     * leave this as `undefined` if not explicitly declared.
+     */
+    event?: string | undefined;
+    /**
+     * ID of the message, if any was provided by the server. Can be used by clients to keep the
+     * last received message ID in sync when reconnecting.
+     */
+    id?: string | undefined;
+    /**
+     * The data received for this message
+     */
+    data: string;
+}
+/**
+ * Callbacks that can be passed to the parser to handle different types of parsed messages
+ * and errors.
+ *
+ * @public
+ */
+export interface ParserCallbacks {
+    /**
+     * Callback for an `id` field when a blank line ends an event block.
+     *
+     * Called once with the last valid `id` value in the block, whether or not the block contains a
+     * `data` field. When the block produces an event, `onId` is called before `onEvent`. An empty
+     * `id` field is reported as an empty string. An `id` field containing U+0000 is ignored.
+     *
+     * @param id - The value of the last valid `id` field in the block
+     */
+    onId?: ((id: string) => void) | undefined;
+    /**
+     * Callback for when a new event/message is parsed from the stream.
+     * This is the main callback that clients will use to handle incoming messages.
+     *
+     * @param event - The parsed event/message
+     */
+    onEvent?: ((event: EventSourceMessage) => void) | undefined;
+    /**
+     * Callback for when the server sends a new reconnection interval through the `retry` field.
+     *
+     * @param retry - The number of milliseconds to wait before reconnecting.
+     */
+    onRetry?: ((retry: number) => void) | undefined;
+    /**
+     * Callback for when a comment is encountered in the stream.
+     *
+     * @param comment - The comment encountered in the stream.
+     */
+    onComment?: ((comment: string) => void) | undefined;
+    /**
+     * Callback for when an error occurs during parsing. This is a catch-all for any errors
+     * that occur during parsing, and can be used to handle them in a custom way. Most clients
+     * tend to silently ignore any errors and instead retry, but it can be helpful to log/debug.
+     *
+     * Incomplete lines that cannot become valid SSE fields may be discarded before completion
+     * to avoid unbounded buffering. Those discarded lines do not trigger `onError`.
+     *
+     * @param error - The error that occurred during parsing
+     */
+    onError?: ((error: ParseError) => void) | undefined;
+}
+/**
+ * Configuration accepted by {@link createParser}. Extends {@link ParserCallbacks} with
+ * additional options that control parser behavior.
+ *
+ * @public
+ */
+export interface ParserConfig extends ParserCallbacks {
+    /**
+     * Maximum number of characters the parser is allowed to buffer across calls to `feed()`.
+     *
+     * Two buffered surfaces exist in a streaming SSE parser:
+     * - A valid partial line that has not yet been terminated by `\n`, `\r`, or `\r\n`.
+     * - A multi-line event whose terminating blank line has not yet arrived (each `data:`
+     *   field gets appended to the buffered event).
+     *
+     * Lines that cannot become valid SSE fields are discarded without buffering.
+     *
+     * When the combined size of these buffers exceeds `maxBufferSize`, the parser emits a
+     * `ParseError` with `type: 'max-buffer-size-exceeded'` to `onError` and becomes
+     * terminated — subsequent calls to `feed()` will throw until `reset()` is called.
+     * This protects against unbounded memory growth from malformed or malicious streams.
+     *
+     * @defaultValue `undefined` (unbounded)
+     */
+    maxBufferSize?: number | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AAE3C;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAEzB;;;;;;;;;;OAUG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,IAAI,CAAA;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAE1B;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAEvB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAEzC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAE3D;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAE/C;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;IAEnD;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;CACpD;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,eAAe;IACnD;;;;;;;;;;;;;;;;OAgBG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC"}

package/node_modules/eventsource/node_modules/eventsource-parser/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/node_modules/eventsource/node_modules/eventsource-parser/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "eventsource-parser",
+  "version": "4.1.3",
+  "description": "Streaming, source-agnostic EventSource/Server-Sent Events parser",
+  "keywords": [
+    "eventsource",
+    "server-sent-events",
+    "sse"
+  ],
+  "homepage": "https://github.com/rexxars/eventsource-parser#readme",
+  "bugs": {
+    "url": "https://github.com/rexxars/eventsource-parser/issues"
+  },
+  "license": "MIT",
+  "author": "Espen Hovlandsdal <espen@hovlandsdal.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/rexxars/eventsource-parser.git"
+  },
+  "files": [
+    "dist",
+    "!dist/stats.html",
+    "!dist/*.min.js",
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./stream": {
+      "source": "./src/stream.ts",
+      "default": "./dist/stream.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "default": "./dist/index.js"
+      },
+      "./stream": {
+        "default": "./dist/stream.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && tsc --build tsconfig.build.json",
+    "clean": "tsc --build tsconfig.build.json --clean",
+    "check": "npm run format && npm run lint && npm run build && vitest run",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "bench": "node --expose-gc bench/parse.bench.ts",
+    "bundle-size": "node scripts/bundle-size.ts",
+    "knip": "knip",
+    "lint": "oxlint && tsc --noEmit",
+    "posttest": "npm run lint",
+    "prepublishOnly": "npm run build",
+    "release:publish": "changeset publish",
+    "release:version": "changeset version && npm install --package-lock-only --ignore-scripts",
+    "test": "npm run test:node",
+    "test:bun": "bun test",
+    "test:deno": "deno run --allow-write --allow-net --allow-run --allow-sys --allow-ffi --allow-env --allow-read npm:vitest",
+    "test:node": "vitest --reporter=verbose"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^1.0.1",
+    "@changesets/cli": "^3.0.3",
+    "@types/node": "^22.12.0",
+    "esbuild": "^0.28.2",
+    "eventsource-encoder": "^1.0.2",
+    "knip": "^6.41.0",
+    "mitata": "^1.0.34",
+    "oxfmt": "^0.72.0",
+    "oxlint": "^1.87.0",
+    "terser": "^5.51.2",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.4"
+  },
+  "browserslist": [
+    "node >= 22.12",
+    "chrome >= 71",
+    "safari >= 14.1",
+    "firefox >= 105",
+    "edge >= 79"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
+  "packageManager": "npm@11.19.0"
+}

package/node_modules/eventsource/node_modules/eventsource-parser/src/errors.ts

@@ -0,0 +1,44 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export type ErrorType = 'invalid-retry' | 'unknown-field' | 'max-buffer-size-exceeded'
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+
+  /**
+   * In the case of a completed unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string | undefined
+
+  /**
+   * In the case of a completed unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string | undefined
+
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string | undefined
+
+  constructor(
+    message: string,
+    options: {type: ErrorType; field?: string; value?: string; line?: string},
+  ) {
+    super(message)
+    this.name = 'ParseError'
+    this.type = options.type
+    this.field = options.field
+    this.value = options.value
+    this.line = options.line
+  }
+}

package/node_modules/eventsource/node_modules/eventsource-parser/src/index.ts

@@ -0,0 +1,3 @@
+export {type ErrorType, ParseError} from './errors.ts'
+export {createParser} from './parse.ts'
+export type {EventSourceMessage, EventSourceParser, ParserCallbacks, ParserConfig} from './types.ts'