@outfoxx/sunday 1.0.8 → 1.1.0-alpha.10

package/src/event-parser.ts

@@ -0,0 +1,190 @@
+export interface EventInfo {
+  id?: string;
+  event?: string;
+  data?: string;
+  retry?: string;
+}
+
+export class EventParser {
+  private decoder: TextDecoder = new TextDecoder('utf-8');
+  private unprocessedBuffer?: ArrayBuffer;
+
+  process(
+    buffer: ArrayBuffer,
+    dispatcher: (eventInfo: EventInfo) => void
+  ): void {
+    const availableBuffer = this.buildAvailableBuffer(buffer);
+    if (!availableBuffer) {
+      return;
+    }
+
+    const eventStrings = this.extractEventStringsFromBuffer(availableBuffer);
+
+    if (!eventStrings.length) {
+      return;
+    }
+
+    EventParser.parseAndDispatchEvents(eventStrings, dispatcher);
+  }
+
+  private buildAvailableBuffer(buffer: ArrayBuffer): ArrayBuffer | undefined {
+    const unprocessedBuffer = this.unprocessedBuffer;
+    this.unprocessedBuffer = undefined;
+
+    if (!buffer.byteLength) {
+      return unprocessedBuffer;
+    } else if (!unprocessedBuffer?.byteLength) {
+      return buffer;
+    }
+
+    const newBuffer = new Uint8Array(
+      unprocessedBuffer.byteLength + buffer.byteLength
+    );
+    newBuffer.set(new Uint8Array(unprocessedBuffer), 0);
+    newBuffer.set(new Uint8Array(buffer), unprocessedBuffer.byteLength);
+
+    return newBuffer.buffer;
+  }
+
+  private extractEventStringsFromBuffer(buffer: ArrayBuffer): string[] {
+    const eventStrings: string[] = [];
+
+    while (buffer.byteLength) {
+      // Find end of next event separator in buffer, exiting if none found.
+      const eventSeparator = EventParser.findEventSeparator(buffer);
+      if (!eventSeparator) {
+        // Save unprocessed data
+        this.unprocessedBuffer = buffer;
+        break;
+      }
+
+      const [endOfCurrentEventIdx, startOfNextEventIdx] = eventSeparator;
+
+      const eventBuffer = buffer.slice(0, endOfCurrentEventIdx);
+      buffer = buffer.slice(startOfNextEventIdx);
+
+      const eventString = this.decoder.decode(eventBuffer, {
+        stream: true,
+      });
+
+      eventStrings.push(eventString);
+    }
+
+    return eventStrings;
+  }
+
+  private static findEventSeparator(
+    buffer: ArrayBuffer
+  ): [number, number] | undefined {
+    const bytes = new Uint8Array(buffer);
+
+    for (let idx = 0; idx < bytes.length; ++idx) {
+      const byte = bytes[idx];
+
+      switch (byte) {
+        // line-feed
+        case 0xa: {
+          // if next byte is same,
+          // we found a separator
+          if (bytes[idx + 1] == 0xa) {
+            return [idx, idx + 2];
+          }
+          break;
+        }
+
+        // carriage-return
+        case 0xd: {
+          // if next byte is same,
+          // we found a separator
+          if (bytes[idx + 1] == 0xd) {
+            return [idx, idx + 2];
+          }
+
+          // if next is line-feed, and pattern
+          // repeats, we found a separator.
+          if (
+            bytes[idx + 1] == 0xa &&
+            bytes[idx + 2] == 0xd &&
+            bytes[idx + 3] == 0xa
+          ) {
+            return [idx, idx + 4];
+          }
+
+          break;
+        }
+
+        default:
+      }
+    }
+    return undefined;
+  }
+
+  private static parseAndDispatchEvents(
+    eventStrings: string[],
+    dispatcher: (eventInfo: EventInfo) => void
+  ) {
+    for (const eventString of eventStrings) {
+      if (!eventString.length) {
+        continue;
+      }
+
+      const parsedEvent = EventParser.parseEvent(eventString);
+
+      dispatcher(parsedEvent);
+    }
+  }
+
+  private static parseEvent(eventString: string): EventInfo {
+    const event: EventInfo = {};
+
+    for (const line of eventString.split(lineSeparatorsRegEx)) {
+      const keyValueSeparatorIdx = line.indexOf(':');
+
+      let key: string;
+      let value: string;
+      if (keyValueSeparatorIdx != -1) {
+        key = line.slice(0, keyValueSeparatorIdx);
+        value = line.slice(keyValueSeparatorIdx + 1);
+      } else {
+        key = line;
+        value = '';
+      }
+
+      switch (key) {
+        case 'retry':
+          event.retry = EventParser.trimFieldValue(value);
+          break;
+
+        case 'data': {
+          const data = event.data ?? '';
+          event.data = `${data}${EventParser.trimFieldValue(value)}\n`;
+          break;
+        }
+
+        case '':
+          // comment do nothing
+          break;
+
+        default: {
+          (event as Record<string, string>)[key] =
+            EventParser.trimFieldValue(value);
+        }
+      }
+    }
+
+    if (event.data?.[event.data?.length - 1] == '\n') {
+      event.data = event.data.slice(0, -1);
+    }
+
+    return event;
+  }
+
+  private static trimFieldValue(value: string): string {
+    if (value[0] != ' ') {
+      return value;
+    }
+    return value.slice(1);
+  }
+}
+
+const lineSeparatorsRegEx = /\r\n|\r|\n/;

package/src/fetch-event-source.ts

@@ -1,9 +1,10 @@
-import { EMPTY, Observable, of, Subscription } from 'rxjs';
-import { map, switchMap, tap } from 'rxjs/operators';
+import { EMPTY, map, Observable, of, Subscription, switchMap, tap } from 'rxjs';
+import { EventInfo, EventParser } from './event-parser';
 import { validate } from './fetch';
 import { Logger } from './logger';
 import { MediaType } from './media-type';
 import { ExtEventSource } from './request-factory';
+import { unknownSet } from './util/any';
 import { fromStream } from './util/stream-rxjs';
 
 export class FetchEventSource extends EventTarget implements ExtEventSource {
@@ -23,22 +24,27 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
   onmessage: ((this: EventSource, ev: MessageEvent) => unknown) | null = null;
   onopen: ((this: EventSource, ev: Event) => unknown) | null = null;
 
+  get retryTime(): number {
+    return this.internalRetryTime;
+  }
+
   private adapter: (
     url: string,
     requestInit: RequestInit
   ) => Observable<Request>;
   private connectionSubscription?: Subscription;
-  private decoder: TextDecoder = new TextDecoder('utf-8');
-  private retryTime = 100;
+  private internalRetryTime = 100;
   private retryAttempt = 0;
   private connectionAttemptTime = 0;
+  private connectionOrigin?: string;
+  private reconnectTimeoutHandle?: number;
   private lastEventId?: string;
   private logger?: Logger;
-  private unprocessedBuffers: ArrayBuffer[] = [];
-  private unprocessedText = '';
-  private eventTimeout?: number;
+  private readonly eventTimeout?: number;
   private eventTimeoutCheckHandle?: number;
-  private lastEventTime?: number;
+  private lastEventReceivedTime = 0;
+  private eventParser = new EventParser();
+  private readonly externalAbortController?: AbortController;
 
   constructor(
     url: string,
@@ -46,6 +52,7 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
       adapter?: (url: string, requestInit: RequestInit) => Observable<Request>;
       eventTimeout?: number;
       logger?: Logger;
+      abortController?: AbortController;
     }
   ) {
     super();
@@ -57,8 +64,13 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
       eventSourceInit?.eventTimeout ??
       FetchEventSource.EVENT_TIMEOUT_DEFAULT * 1000;
     this.logger = eventSourceInit?.logger;
+    this.externalAbortController = eventSourceInit?.abortController;
   }
 
+  //
+  // Connect
+  //
+
   connect(): void {
     if (this.readyState === this.CONNECTING || this.readyState === this.OPEN) {
       // this.logger?.debug?.('skipping connect', { state: this.readyState });
@@ -74,19 +86,20 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
     this.readyState = this.CONNECTING;
 
     const headers = new Headers({
-      accept: MediaType.EVENT_STREAM,
+      accept: MediaType.EventStream.toString(),
     });
     if (this.lastEventId) {
       headers.append(FetchEventSource.LAST_EVENT_ID_HEADER, this.lastEventId);
     }
 
-    const abort = new AbortController();
+    const abortController =
+      this.externalAbortController ?? new AbortController();
 
     const requestInit: RequestInit = {
       headers,
       cache: 'no-store',
       redirect: 'follow',
-      signal: abort.signal,
+      signal: abortController.signal,
     };
 
     this.connectionAttemptTime = Date.now();
@@ -95,7 +108,7 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
       .pipe(
         switchMap((request) => fetch(request)),
         switchMap((response) => validate(response, true)),
-        tap(() => this.receivedHeaders()),
+        tap((response) => this.receivedHeaders(response)),
         switchMap((response) => {
           const body = response.body;
           if (!body) {
@@ -108,19 +121,23 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
       )
       .subscribe({
         error: (error: unknown) => {
-          abort.abort();
           this.receivedError(error);
         },
         complete: () => {
-          abort.abort();
           this.receivedComplete();
         },
       });
-    this.connectionSubscription.add(() => abort.abort());
+    this.connectionSubscription.add(() => {
+      abortController.abort();
+    });
   }
 
+  //
+  // Close
+  //
+
   close(): void {
-    this.logger?.debug?.('closed');
+    this.logger?.debug?.('close requested');
 
     this.readyState = this.CLOSED;
 
@@ -131,19 +148,27 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
     this.connectionSubscription?.unsubscribe();
     this.connectionSubscription = undefined;
 
+    this.clearReconnect();
+
     this.stopEventTimeoutCheck();
   }
 
-  private startEventTimeoutCheck() {
+  //
+  // Event Timeout
+  //
+
+  private startEventTimeoutCheck(lastEventReceivedTime: number) {
     this.stopEventTimeoutCheck();
 
     if (!this.eventTimeout) {
       return;
     }
 
+    this.lastEventReceivedTime = lastEventReceivedTime;
+
     // this.logger?.debug?.('starting event timeout checks');
 
-    this.eventTimeoutCheckHandle = setInterval(
+    this.eventTimeoutCheckHandle = window.setInterval(
       () => this.checkEventTimeout(),
       FetchEventSource.EVENT_TIMEOUT_CHECK_INTERVAL * 1000
     );
@@ -167,107 +192,95 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
     // this.logger?.debug?.('checking event timeout');
 
     // Check elapsed time since last received event
-    const elapsed = Date.now() - (this.lastEventTime ?? 0);
+    const elapsed = Date.now() - this.lastEventReceivedTime;
     if (elapsed > this.eventTimeout) {
       this.logger?.debug?.('event timeout reached', {
         elapsed,
       });
-
-      this.internalClose();
+      this.fireErrorEvent(Error('EventTimeout'));
 
       this.scheduleReconnect();
     }
   }
 
-  private receivedHeaders() {
+  //
+  // Connection Handlers
+  //
+
+  private receivedHeaders(response: Response) {
     if (this.readyState !== this.CONNECTING) {
-      this.close();
-      throw Error('Invalid readyState');
+      this.logger?.error?.('Invalid readyState for receiveHaders', {
+        readyState: this.readyState,
+      });
+
+      this.fireErrorEvent(Error('InvalidState'));
+
+      this.scheduleReconnect();
+      return;
     }
 
-    this.logger?.debug?.('connected');
+    this.logger?.debug?.('opened');
 
+    this.connectionOrigin = response.url;
     this.retryAttempt = 0;
     this.readyState = this.OPEN;
 
-    this.startEventTimeoutCheck();
+    // Start event timeout check, treating this
+    // connect as last time we received an event
+    this.startEventTimeoutCheck(Date.now());
 
     const event = new Event('open');
     this.onopen?.(event);
     this.dispatchEvent(event);
   }
 
-  private receivedData(value: ArrayBuffer) {
-    this.unprocessedBuffers.push(value);
-
-    while (this.unprocessedBuffers.length) {
-      const latest = this.unprocessedBuffers[
-        this.unprocessedBuffers.length - 1
-      ];
-      const latestBytes = new Uint8Array(latest);
-      const latestNewLine = latestBytes.indexOf(0xa);
-      if (latestNewLine == -1) {
-        return;
-      }
-      const nextLine = latestNewLine + 1;
-
-      const readyToProcess = this.unprocessedBuffers.slice(0, -1);
-      readyToProcess.push(latest.slice(0, nextLine));
-
-      const leftOver = latest.slice(nextLine);
-      this.unprocessedBuffers = leftOver.byteLength ? [leftOver] : [];
+  private receivedData(buffer: ArrayBuffer) {
+    if (this.readyState !== this.OPEN) {
+      this.logger?.error?.('Invalid readyState for receiveData', {
+        readyState: this.readyState,
+      });
 
-      let text = '';
-      for (const buffer of readyToProcess) {
-        text += this.decoder.decode(buffer, { stream: true });
-      }
+      this.fireErrorEvent(Error('InvalidState'));
 
-      this.receivedText(text);
+      this.scheduleReconnect();
+      return;
     }
-  }
 
-  private receivedText(text: string) {
-    // Clear out carriage returns
-    text = text.replace('\r\n', '\n');
+    this.logger?.debug?.('received data', { length: validate.length });
 
-    this.unprocessedText += text;
-
-    const eventStrings = this.extractEventStrings();
-
-    this.parseEvents(eventStrings);
+    this.eventParser.process(buffer, this.dispatchParsedEvent);
   }
 
   private receivedError(error: unknown) {
-    if (
-      error instanceof DOMException &&
-      error.code === DOMException.ABORT_ERR
-    ) {
-      // this.logger?.debug?.('aborted');
-
+    if (this.readyState === this.CLOSED) {
       return;
     }
 
     this.logger?.debug?.('received error', { error });
-
-    this.scheduleReconnect();
-
-    const event = new Event('error');
-    ((event as unknown) as Record<string, unknown>).error = error;
-
-    this.onerror?.(event);
-  }
-
-  private receivedComplete() {
-    this.logger?.debug?.('received complete');
+    this.fireErrorEvent(error);
 
     if (this.readyState !== this.CLOSED) {
       this.scheduleReconnect();
+    }
+  }
 
+  private receivedComplete() {
+    if (this.readyState == this.CLOSED) {
       return;
     }
+
+    this.logger?.debug?.('received complete');
+
+    this.scheduleReconnect();
   }
 
+  //
+  // Reconnection
+  //
+
   private scheduleReconnect() {
+    this.internalClose();
+
     // calculate total delay
     const backOffDelay = Math.pow(this.retryAttempt, 2) * this.retryTime;
     let retryDelay = Math.min(
@@ -275,113 +288,90 @@ export class FetchEventSource extends EventTarget implements ExtEventSource {
       this.retryTime * FetchEventSource.MAX_RETRY_TIME_MULTIPLE
     );
 
-    // Adjust delay by amount of time last reconnect cycle took, except
-    // on the first attempt
+    // Adjust delay by amount of time last connect
+    // cycle took, except on the first attempt
     if (this.retryAttempt > 0) {
       const connectionTime = Date.now() - this.connectionAttemptTime;
-      retryDelay = Math.max(retryDelay - connectionTime, 0);
+      // Ensure delay is at least as large as
+      // minimum retry time interval
+      retryDelay = Math.max(retryDelay - connectionTime, this.retryTime);
     }
 
     this.retryAttempt++;
+    this.readyState = this.CONNECTING;
 
     this.logger?.debug?.('scheduling reconnect', { retryDelay });
 
-    setTimeout(() => this.internalConnect(), retryDelay);
+    this.reconnectTimeoutHandle = window.setTimeout(
+      () => this.internalConnect(),
+      retryDelay
+    );
   }
 
-  private extractEventStrings(): string[] {
-    const received = this.unprocessedText;
-    if (!received.length) {
-      return [];
+  private clearReconnect() {
+    if (this.reconnectTimeoutHandle) {
+      clearTimeout(this.reconnectTimeoutHandle);
     }
-
-    const eventStrings = received.split(EVENT_SEPARATOR);
-
-    const last = eventStrings.pop();
-    this.unprocessedText = last?.length ? last : '';
-
-    return eventStrings;
+    this.reconnectTimeoutHandle = undefined;
   }
 
-  private parseEvents(eventStrings: string[]) {
-    for (const eventString of eventStrings) {
-      const line = eventString.trim();
-      if (!line.length) {
-        continue;
-      }
-
-      const parsedEvent = FetchEventSource.parseEvent(eventString);
+  //
+  // Event Dispatch
+  //
 
-      if (parsedEvent.retry) {
-        const retryTime = Number.parseInt(parsedEvent.retry, 10);
+  private dispatchParsedEvent = (eventInfo: EventInfo) => {
+    this.lastEventReceivedTime = Date.now();
 
-        if (
-          Number.isSafeInteger(retryTime) &&
-          parsedEvent.id == null &&
-          parsedEvent.event == null &&
-          parsedEvent.data == null
-        ) {
-          this.logger?.debug?.('updating retry timeout', { retryTime });
+    if (eventInfo.retry) {
+      const retryTime = Number.parseInt(eventInfo.retry, 10);
 
-          this.retryTime = retryTime;
-        } else {
-          this.logger?.debug?.('ignoring invalid retry timeout event', {
-            parsedEvent,
-          });
-        }
+      if (Number.isSafeInteger(retryTime)) {
+        this.logger?.debug?.('updating retry timeout', { retryTime });
 
-        continue;
+        this.internalRetryTime = retryTime;
+      } else {
+        this.logger?.debug?.('ignoring invalid retry timeout event', {
+          eventInfo,
+        });
       }
+    }
 
-      this.lastEventTime = Date.now();
-      this.lastEventId = parsedEvent.id ?? this.lastEventId;
-
-      // Skip empty or comment only events
-      if (!parsedEvent.id && !parsedEvent.event && !parsedEvent.data) {
-        // this.logger?.debug?.('skipping empty event');
-        continue;
-      }
-
-      // Dispatch event
-      const event = new MessageEvent(parsedEvent.event ?? 'message', {
-        data: parsedEvent.data,
-        lastEventId: this.lastEventId,
-      });
-
-      this.onmessage?.(event);
-      this.dispatchEvent(event);
+    // skip empty events
+    if (
+      eventInfo.id == null &&
+      eventInfo.event == null &&
+      eventInfo.data == null
+    ) {
+      // skip empty event
+      return;
     }
-  }
 
-  private static parseEvent(eventString: string): EventInfo {
-    const event: EventInfo = {};
-
-    for (const line of eventString.split('\n')) {
-      const fields = line.split(':');
-      const key = fields[0].trim();
-      const value = fields.splice(1).join(':');
-
-      switch (key) {
-        case 'retry':
-          event.retry = value;
-          break;
-        case '':
-          // comment do nothing
-          break;
-        default:
-          (event as Record<string, string>)[key] = value.trim();
+    // Save last-event-id if the new id is valid
+    if (eventInfo.id != null) {
+      // Check for NULL as it is not allowed
+      if (eventInfo.id.indexOf('\0') == -1) {
+        this.lastEventId = eventInfo.id;
+      } else {
+        this.logger?.debug?.(
+          'event id contains null, unable to use for last-event-id'
+        );
       }
     }
 
-    return event;
-  }
-}
+    // Dispatch event
+    const event = new MessageEvent(eventInfo.event ?? 'message', {
+      data: eventInfo.data,
+      lastEventId: this.lastEventId,
+      origin: this.connectionOrigin,
+    });
 
-const EVENT_SEPARATOR = /\n\n/;
+    this.onmessage?.(event);
+    this.dispatchEvent(event);
+  };
 
-interface EventInfo {
-  id?: string;
-  event?: string;
-  data?: string;
-  retry?: string;
+  fireErrorEvent(error: unknown): void {
+    const event = new Event('error');
+    unknownSet(event, 'error', error);
+    this.onerror?.(event);
+  }
 }