FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@trpc/server/src/observable/behaviorSubject.ts

@@ -0,0 +1,55 @@
+import { observable } from './observable';
+import type { Observable, Observer } from './types';
+
+export interface BehaviorSubject<TValue> extends Observable<TValue, never> {
+  observable: Observable<TValue, never>;
+  next: (value: TValue) => void;
+  get: () => TValue;
+}
+
+export interface ReadonlyBehaviorSubject<TValue>
+  extends Omit<BehaviorSubject<TValue>, 'next'> {}
+
+/**
+ * @internal
+ * An observable that maintains and provides a "current value" to subscribers
+ * @see https://www.learnrxjs.io/learn-rxjs/subjects/behaviorsubject
+ */
+export function behaviorSubject<TValue>(
+  initialValue: TValue,
+): BehaviorSubject<TValue> {
+  let value: TValue = initialValue;
+
+  const observerList: Observer<TValue, never>[] = [];
+
+  const addObserver = (observer: Observer<TValue, never>) => {
+    if (value !== undefined) {
+      observer.next(value);
+    }
+    observerList.push(observer);
+  };
+  const removeObserver = (observer: Observer<TValue, never>) => {
+    observerList.splice(observerList.indexOf(observer), 1);
+  };
+
+  const obs = observable<TValue, never>((observer) => {
+    addObserver(observer);
+    return () => {
+      removeObserver(observer);
+    };
+  }) as BehaviorSubject<TValue>;
+
+  obs.next = (nextValue: TValue) => {
+    if (value === nextValue) {
+      return;
+    }
+    value = nextValue;
+    for (const observer of observerList) {
+      observer.next(nextValue);
+    }
+  };
+
+  obs.get = () => value;
+
+  return obs;
+}

node_modules/@trpc/server/src/observable/index.ts

@@ -0,0 +1,29 @@
+export {
+  isObservable,
+  observable,
+  observableToAsyncIterable,
+  observableToPromise,
+  type inferObservableValue,
+} from './observable';
+
+export {
+  distinctUntilChanged,
+  distinctUntilDeepChanged,
+  map,
+  share,
+  tap,
+} from './operators';
+
+export type {
+  Observable,
+  Observer,
+  TeardownLogic,
+  Unsubscribable,
+  UnsubscribeFn,
+} from './types';
+
+export {
+  behaviorSubject,
+  type BehaviorSubject,
+  type ReadonlyBehaviorSubject,
+} from './behaviorSubject';

node_modules/@trpc/server/src/observable/observable.ts

@@ -0,0 +1,206 @@
+import type { Result } from '../unstable-core-do-not-import';
+import type {
+  Observable,
+  Observer,
+  OperatorFunction,
+  TeardownLogic,
+  UnaryFunction,
+  Unsubscribable,
+} from './types';
+
+/** @public */
+export type inferObservableValue<TObservable> =
+  TObservable extends Observable<infer TValue, unknown> ? TValue : never;
+
+/** @public */
+export function isObservable(x: unknown): x is Observable<unknown, unknown> {
+  return typeof x === 'object' && x !== null && 'subscribe' in x;
+}
+
+/** @public */
+export function observable<TValue, TError = unknown>(
+  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,
+): Observable<TValue, TError> {
+  const self: Observable<TValue, TError> = {
+    subscribe(observer) {
+      let teardownRef: TeardownLogic | null = null;
+      let isDone = false;
+      let unsubscribed = false;
+      let teardownImmediately = false;
+      function unsubscribe() {
+        if (teardownRef === null) {
+          teardownImmediately = true;
+          return;
+        }
+        if (unsubscribed) {
+          return;
+        }
+        unsubscribed = true;
+
+        if (typeof teardownRef === 'function') {
+          teardownRef();
+        } else if (teardownRef) {
+          teardownRef.unsubscribe();
+        }
+      }
+      teardownRef = subscribe({
+        next(value) {
+          if (isDone) {
+            return;
+          }
+          observer.next?.(value);
+        },
+        error(err) {
+          if (isDone) {
+            return;
+          }
+          isDone = true;
+          observer.error?.(err);
+          unsubscribe();
+        },
+        complete() {
+          if (isDone) {
+            return;
+          }
+          isDone = true;
+          observer.complete?.();
+          unsubscribe();
+        },
+      });
+      if (teardownImmediately) {
+        unsubscribe();
+      }
+      return {
+        unsubscribe,
+      };
+    },
+    pipe(
+      ...operations: OperatorFunction<any, any, any, any>[]
+    ): Observable<any, any> {
+      return operations.reduce(pipeReducer, self);
+    },
+  };
+  return self;
+}
+
+function pipeReducer(prev: any, fn: UnaryFunction<any, any>) {
+  return fn(prev);
+}
+
+/** @internal */
+export function observableToPromise<TValue>(
+  observable: Observable<TValue, unknown>,
+) {
+  const ac = new AbortController();
+  const promise = new Promise<TValue>((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone) {
+        return;
+      }
+      isDone = true;
+      obs$.unsubscribe();
+    }
+    ac.signal.addEventListener('abort', () => {
+      reject(ac.signal.reason);
+    });
+    const obs$ = observable.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        reject(data);
+      },
+      complete() {
+        ac.abort();
+        onDone();
+      },
+    });
+  });
+  return promise;
+}
+
+/**
+ * @internal
+ */
+function observableToReadableStream<TValue>(
+  observable: Observable<TValue, unknown>,
+  signal: AbortSignal,
+): ReadableStream<Result<TValue>> {
+  let unsub: Unsubscribable | null = null;
+
+  const onAbort = () => {
+    unsub?.unsubscribe();
+    unsub = null;
+    signal.removeEventListener('abort', onAbort);
+  };
+
+  return new ReadableStream<Result<TValue>>({
+    start(controller) {
+      unsub = observable.subscribe({
+        next(data) {
+          controller.enqueue({ ok: true, value: data });
+        },
+        error(error) {
+          controller.enqueue({ ok: false, error });
+          controller.close();
+        },
+        complete() {
+          controller.close();
+        },
+      });
+
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener('abort', onAbort, { once: true });
+      }
+    },
+    cancel() {
+      onAbort();
+    },
+  });
+}
+
+/** @internal */
+export function observableToAsyncIterable<TValue>(
+  observable: Observable<TValue, unknown>,
+  signal: AbortSignal,
+): AsyncIterable<TValue> {
+  const stream = observableToReadableStream(observable, signal);
+
+  const reader = stream.getReader();
+  const iterator: AsyncIterator<TValue> = {
+    async next() {
+      const value = await reader.read();
+      if (value.done) {
+        return {
+          value: undefined,
+          done: true,
+        };
+      }
+      const { value: result } = value;
+      if (!result.ok) {
+        throw result.error;
+      }
+      return {
+        value: result.value,
+        done: false,
+      };
+    },
+    async return() {
+      await reader.cancel();
+      return {
+        value: undefined,
+        done: true,
+      };
+    },
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return iterator;
+    },
+  };
+}

node_modules/@trpc/server/src/observable/operators.ts

@@ -0,0 +1,161 @@
+import { observable } from './observable';
+import type {
+  MonoTypeOperatorFunction,
+  Observer,
+  OperatorFunction,
+  Unsubscribable,
+} from './types';
+
+export function map<TValueBefore, TError, TValueAfter>(
+  project: (value: TValueBefore, index: number) => TValueAfter,
+): OperatorFunction<TValueBefore, TError, TValueAfter, TError> {
+  return (source) => {
+    return observable((destination) => {
+      let index = 0;
+      const subscription = source.subscribe({
+        next(value) {
+          destination.next(project(value, index++));
+        },
+        error(error) {
+          destination.error(error);
+        },
+        complete() {
+          destination.complete();
+        },
+      });
+      return subscription;
+    });
+  };
+}
+
+interface ShareConfig {}
+export function share<TValue, TError>(
+  _opts?: ShareConfig,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (source) => {
+    let refCount = 0;
+
+    let subscription: Unsubscribable | null = null;
+    const observers: Partial<Observer<TValue, TError>>[] = [];
+
+    function startIfNeeded() {
+      if (subscription) {
+        return;
+      }
+      subscription = source.subscribe({
+        next(value) {
+          for (const observer of observers) {
+            observer.next?.(value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            observer.error?.(error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            observer.complete?.();
+          }
+        },
+      });
+    }
+    function resetIfNeeded() {
+      // "resetOnRefCountZero"
+      if (refCount === 0 && subscription) {
+        const _sub = subscription;
+        subscription = null;
+        _sub.unsubscribe();
+      }
+    }
+
+    return observable((subscriber) => {
+      refCount++;
+
+      observers.push(subscriber);
+      startIfNeeded();
+      return {
+        unsubscribe() {
+          refCount--;
+          resetIfNeeded();
+
+          const index = observers.findIndex((v) => v === subscriber);
+
+          if (index > -1) {
+            observers.splice(index, 1);
+          }
+        },
+      };
+    });
+  };
+}
+
+export function tap<TValue, TError>(
+  observer: Partial<Observer<TValue, TError>>,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (source) => {
+    return observable((destination) => {
+      return source.subscribe({
+        next(value) {
+          observer.next?.(value);
+          destination.next(value);
+        },
+        error(error) {
+          observer.error?.(error);
+          destination.error(error);
+        },
+        complete() {
+          observer.complete?.();
+          destination.complete();
+        },
+      });
+    });
+  };
+}
+
+const distinctUnsetMarker = Symbol();
+export function distinctUntilChanged<TValue, TError>(
+  compare: (a: TValue, b: TValue) => boolean = (a, b) => a === b,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (source) => {
+    return observable((destination) => {
+      let lastValue: TValue | typeof distinctUnsetMarker = distinctUnsetMarker;
+
+      return source.subscribe({
+        next(value) {
+          if (lastValue !== distinctUnsetMarker && compare(lastValue, value)) {
+            return;
+          }
+          lastValue = value;
+          destination.next(value);
+        },
+        error(error) {
+          destination.error(error);
+        },
+        complete() {
+          destination.complete();
+        },
+      });
+    });
+  };
+}
+
+const isDeepEqual = <T>(a: T, b: T): boolean => {
+  if (a === b) {
+    return true;
+  }
+  const bothAreObjects =
+    a && b && typeof a === 'object' && typeof b === 'object';
+
+  return (
+    !!bothAreObjects &&
+    Object.keys(a).length === Object.keys(b).length &&
+    Object.entries(a).every(([k, v]) => isDeepEqual(v, b[k as keyof T]))
+  );
+};
+export function distinctUntilDeepChanged<
+  TValue,
+  TError,
+>(): MonoTypeOperatorFunction<TValue, TError> {
+  return distinctUntilChanged(isDeepEqual);
+}

node_modules/@trpc/server/src/observable/types.ts

@@ -0,0 +1,76 @@
+export interface Unsubscribable {
+  unsubscribe(): void;
+}
+export type UnsubscribeFn = () => void;
+interface Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+export interface Observable<TValue, TError>
+  extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<TValue1, TError1>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+  ): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+  ): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+  ): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
+  ): Observable<TValue2, TError2>;
+  pipe<
+    TValue1,
+    TError1,
+    TValue2,
+    TError2,
+    TValue3,
+    TError3,
+    TValue4,
+    TError4,
+    TValue5,
+    TError5,
+  >(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
+    op5: OperatorFunction<TValue4, TError4, TValue5, TError5>,
+  ): Observable<TValue2, TError2>;
+}
+
+export interface Observer<TValue, TError> {
+  next: (value: TValue) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+
+export type TeardownLogic =
+  // | SubscriptionLike
+  Unsubscribable | UnsubscribeFn | void;
+
+export type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
+
+export type OperatorFunction<
+  TValueBefore,
+  TErrorBefore,
+  TValueAfter,
+  TErrorAfter,
+> = UnaryFunction<
+  Subscribable<TValueBefore, TErrorBefore>,
+  Subscribable<TValueAfter, TErrorAfter>
+>;
+
+export type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<
+  TValue,
+  TError,
+  TValue,
+  TError
+>;