@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/src/unstable-core-do-not-import/stream/utils/asyncIterable.ts

@@ -0,0 +1,89 @@
+import { Unpromise } from '../../../vendor/unpromise';
+import { makeAsyncResource } from './disposable';
+import { disposablePromiseTimerResult, timerResource } from './timerResource';
+
+export function iteratorResource<TYield, TReturn, TNext>(
+  iterable: AsyncIterable<TYield, TReturn, TNext>,
+): AsyncIterator<TYield, TReturn, TNext> & AsyncDisposable {
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  return makeAsyncResource(iterator, async () => {
+    await iterator.return?.();
+  });
+}
+/**
+ * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
+ */
+export async function* withMaxDuration<T>(
+  iterable: AsyncIterable<T>,
+  opts: { maxDurationMs: number },
+): AsyncGenerator<T> {
+  await using iterator = iteratorResource(iterable);
+
+  using timer = timerResource(opts.maxDurationMs);
+
+  const timerPromise = timer.start();
+
+  // declaration outside the loop for garbage collection reasons
+  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+
+  while (true) {
+    result = await Unpromise.race([iterator.next(), timerPromise]);
+    if (result === disposablePromiseTimerResult) {
+      // cancelled due to timeout
+
+      const res = await iterator.return?.();
+      return res?.value;
+    }
+    if (result.done) {
+      return result;
+    }
+    yield result.value;
+    // free up reference for garbage collection
+    result = null;
+  }
+}
+
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
+ * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
+ * values may still come through. After this period, the generator stops.
+ */
+export async function* takeWithGrace<T>(
+  iterable: AsyncIterable<T>,
+  opts: {
+    count: number;
+    gracePeriodMs: number;
+  },
+): AsyncGenerator<T> {
+  await using iterator = iteratorResource(iterable);
+
+  // declaration outside the loop for garbage collection reasons
+  let result: null | IteratorResult<T> | typeof disposablePromiseTimerResult;
+
+  using timer = timerResource(opts.gracePeriodMs);
+
+  let count = opts.count;
+
+  let timerPromise = new Promise<typeof disposablePromiseTimerResult>(() => {
+    // never resolves
+  });
+
+  while (true) {
+    result = await Unpromise.race([iterator.next(), timerPromise]);
+    if (result === disposablePromiseTimerResult) {
+      // cancelled
+      const res = await iterator.return?.();
+      return res?.value;
+    }
+    if (result.done) {
+      return result.value;
+    }
+    yield result.value;
+    if (--count === 0) {
+      timerPromise = timer.start();
+    }
+    // free up reference for garbage collection
+    result = null;
+  }
+}

package/src/unstable-core-do-not-import/stream/utils/createDeferred.ts

@@ -10,39 +10,3 @@ export function createDeferred<TValue>() {
   return { promise, resolve: resolve!, reject: reject! };
 }
 export type Deferred<TValue> = ReturnType<typeof createDeferred<TValue>>;
-
-export const createTimeoutPromise = <TValue>(
-  timeoutMs: number,
-  value: TValue,
-) => {
-  let deferred = createDeferred<TValue>();
-  deferred = deferred as typeof deferred & { clear: () => void };
-
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  const clear = () => {
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-  };
-  const resolve = () => {
-    deferred.resolve(value);
-    clear();
-  };
-  if (timeoutMs !== Infinity) {
-    timeout = setTimeout(resolve, timeoutMs);
-    timeout.unref?.();
-  }
-
-  return {
-    promise: deferred.promise,
-    /**
-     * Clear the timeout without resolving the promise
-     */
-    clear,
-    /**
-     * Resolve the promise with the value
-     */
-    resolve,
-  };
-};

package/src/unstable-core-do-not-import/stream/utils/disposable.ts

@@ -0,0 +1,52 @@
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+Symbol.dispose ??= Symbol();
+
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+Symbol.asyncDispose ??= Symbol();
+
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */
+export function makeResource<T>(thing: T, dispose: () => void): T & Disposable {
+  const it = thing as T & Disposable;
+
+  // eslint-disable-next-line no-restricted-syntax
+  if (it[Symbol.dispose]) {
+    throw new Error('Symbol.dispose already exists');
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  it[Symbol.dispose] = dispose;
+
+  return it;
+}
+
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */
+export function makeAsyncResource<T>(
+  thing: T,
+  dispose: () => Promise<void>,
+): T & AsyncDisposable {
+  const it = thing as T & AsyncDisposable;
+
+  // eslint-disable-next-line no-restricted-syntax
+  if (it[Symbol.asyncDispose]) {
+    throw new Error('Symbol.asyncDispose already exists');
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  it[Symbol.asyncDispose] = dispose;
+
+  return it;
+}

package/src/unstable-core-do-not-import/stream/utils/readableStreamFrom.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates a ReadableStream from an AsyncIterable.
+ *
+ * @param iterable - The source AsyncIterable to stream from
+ * @returns A ReadableStream that yields values from the AsyncIterable
+ */
+export function readableStreamFrom<TYield>(
+  iterable: AsyncIterable<TYield, void>,
+): ReadableStream<TYield> {
+  const iterator = iterable[Symbol.asyncIterator]();
+
+  return new ReadableStream({
+    async cancel() {
+      await iterator.return?.();
+    },
+
+    async pull(controller) {
+      const result = await iterator.next();
+
+      if (result.done) {
+        controller.close();
+        return;
+      }
+
+      controller.enqueue(result.value);
+    },
+  });
+}

package/src/unstable-core-do-not-import/stream/utils/timerResource.ts

@@ -0,0 +1,29 @@
+import { makeResource } from './disposable';
+
+export const disposablePromiseTimerResult = Symbol();
+
+export function timerResource(ms: number) {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  return makeResource(
+    {
+      start() {
+        if (timer) {
+          throw new Error('Timer already started');
+        }
+
+        const promise = new Promise<typeof disposablePromiseTimerResult>(
+          (resolve) => {
+            timer = setTimeout(() => resolve(disposablePromiseTimerResult), ms);
+          },
+        );
+        return promise;
+      },
+    },
+    () => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    },
+  );
+}

package/src/unstable-core-do-not-import/stream/utils/withPing.ts

@@ -0,0 +1,47 @@
+import { Unpromise } from '../../../vendor/unpromise';
+import { iteratorResource } from './asyncIterable';
+import { disposablePromiseTimerResult, timerResource } from './timerResource';
+
+export const PING_SYM = Symbol('ping');
+
+/**
+ * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
+ * whenever no value has been yielded for {@link pingIntervalMs}.
+ */
+export async function* withPing<TValue>(
+  iterable: AsyncIterable<TValue>,
+  pingIntervalMs: number,
+): AsyncGenerator<TValue | typeof PING_SYM> {
+  await using iterator = iteratorResource(iterable);
+
+  // declaration outside the loop for garbage collection reasons
+  let result:
+    | null
+    | IteratorResult<TValue>
+    | typeof disposablePromiseTimerResult;
+
+  let nextPromise = iterator.next();
+
+  while (true) {
+    using pingPromise = timerResource(pingIntervalMs);
+
+    result = await Unpromise.race([nextPromise, pingPromise.start()]);
+
+    if (result === disposablePromiseTimerResult) {
+      // cancelled
+
+      yield PING_SYM;
+      continue;
+    }
+
+    if (result.done) {
+      return result.value;
+    }
+
+    nextPromise = iterator.next();
+    yield result.value;
+
+    // free up reference for garbage collection
+    result = null;
+  }
+}

package/src/unstable-core-do-not-import/transformer.ts

@@ -175,7 +175,7 @@ export function transformResult<TRouter extends AnyRouter, TOutput>(
   try {
     // Use the data transformers on the JSON-response
     result = transformResultInner(response, transformer);
-  } catch (err) {
+  } catch {
     throw new TransformResultError();
   }
 

package/src/unstable-core-do-not-import/types.ts

@@ -11,7 +11,7 @@ export type Maybe<TType> = TType | null | undefined;
 
 /**
  * @internal
- * @link https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
  */
 export type Simplify<TType> = TType extends any[] | Date
   ? TType
@@ -31,6 +31,13 @@ export type FilterKeys<TObj extends object, TFilter> = {
   [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
 }[keyof TObj];
 
+/**
+ * @internal
+ */
+export type Result<TType, TErr = unknown> =
+  | { ok: true; value: TType }
+  | { ok: false; error: TErr };
+
 /**
  * @internal
  */
@@ -76,8 +83,8 @@ export type WithoutIndexSignature<TObj> = {
   [K in keyof TObj as string extends K
     ? never
     : number extends K
-    ? never
-    : K]: TObj[K];
+      ? never
+      : K]: TObj[K];
 };
 
 /**
@@ -94,14 +101,13 @@ export type Overwrite<TType, TWith> = TWith extends any
           | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith
           ? TWith[K]
           : K extends keyof TType
-          ? TType[K]
-          : never;
+            ? TType[K]
+            : never;
       } & (string extends keyof TWith // Handle cases with an index signature
         ? { [key: string]: TWith[string] }
         : number extends keyof TWith
-        ? { [key: number]: TWith[number] }
-        : // eslint-disable-next-line @typescript-eslint/ban-types
-          {})
+          ? { [key: number]: TWith[number] }
+          : {})
     : TWith
   : never;
 
@@ -124,6 +130,17 @@ export type PickFirstDefined<TType, TPick> = undefined extends TType
     : TPick
   : TType;
 
+export type KeyFromValue<
+  TValue,
+  TType extends Record<PropertyKey, PropertyKey>,
+> = {
+  [K in keyof TType]: TValue extends TType[K] ? K : never;
+}[keyof TType];
+
+export type InvertKeyValue<TType extends Record<PropertyKey, PropertyKey>> = {
+  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
+};
+
 /**
  * ================================
  * tRPC specific types
@@ -150,8 +167,16 @@ export type ProtectedIntersection<TType, TWith> = keyof TType &
  */
 export type GetRawInputFn = () => Promise<unknown>;
 
-export const ERROR_SYMBOL = Symbol('TypeError');
+const _errorSymbol = Symbol();
+export type ErrorSymbol = typeof _errorSymbol;
 export type TypeError<TMessage extends string> = TMessage & {
-  _: typeof ERROR_SYMBOL;
+  _: typeof _errorSymbol;
 };
 export type ValueOf<TObj> = TObj[keyof TObj];
+
+/**
+ * @internal
+ * Infers the type of the value yielded by an async iterable
+ */
+export type inferAsyncIterableYield<T> =
+  T extends AsyncIterable<infer U> ? U : T;

package/src/unstable-core-do-not-import/utils.ts

@@ -1,5 +1,5 @@
 /** @internal */
-export const unsetMarker = Symbol('unsetMarker');
+export const unsetMarker = Symbol();
 export type UnsetMarker = typeof unsetMarker;
 
 /**
@@ -61,3 +61,58 @@ export function isAsyncIterable<TValue>(
  * Run an IIFE
  */
 export const run = <TValue>(fn: () => TValue): TValue => fn();
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+export function noop(): void {}
+
+export function identity<T>(it: T): T {
+  return it;
+}
+
+/**
+ * Generic runtime assertion function. Throws, if the condition is not `true`.
+ *
+ * Can be used as a slightly less dangerous variant of type assertions. Code
+ * mistakes would be revealed at runtime then (hopefully during testing).
+ */
+export function assert(
+  condition: boolean,
+  msg = 'no additional info',
+): asserts condition {
+  if (!condition) {
+    throw new Error(`AssertionError: ${msg}`);
+  }
+}
+
+export function sleep(ms = 0): Promise<void> {
+  return new Promise<void>((res) => setTimeout(res, ms));
+}
+
+/**
+ * Ponyfill for
+ * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
+ */
+export function abortSignalsAnyPonyfill(signals: AbortSignal[]): AbortSignal {
+  if (typeof AbortSignal.any === 'function') {
+    return AbortSignal.any(signals);
+  }
+
+  const ac = new AbortController();
+
+  for (const signal of signals) {
+    if (signal.aborted) {
+      trigger();
+      break;
+    }
+    signal.addEventListener('abort', trigger, { once: true });
+  }
+
+  return ac.signal;
+
+  function trigger() {
+    ac.abort();
+    for (const signal of signals) {
+      signal.removeEventListener('abort', trigger);
+    }
+  }
+}

package/src/unstable-core-do-not-import.ts

@@ -15,14 +15,13 @@ export * from './unstable-core-do-not-import/createProxy';
 export * from './unstable-core-do-not-import/error/formatter';
 export * from './unstable-core-do-not-import/error/getErrorShape';
 export * from './unstable-core-do-not-import/error/TRPCError';
-export * from './unstable-core-do-not-import/http/batchStreamFormatter';
 export * from './unstable-core-do-not-import/http/contentType';
 export * from './unstable-core-do-not-import/http/contentTypeParsers';
 export * from './unstable-core-do-not-import/http/formDataToObject';
 export * from './unstable-core-do-not-import/http/getHTTPStatusCode';
+export * from './unstable-core-do-not-import/http/isAbortError';
 export * from './unstable-core-do-not-import/http/parseConnectionParams';
 export * from './unstable-core-do-not-import/http/resolveResponse';
-export * from './unstable-core-do-not-import/http/toURL';
 export * from './unstable-core-do-not-import/http/types';
 export * from './unstable-core-do-not-import/initTRPC';
 export * from './unstable-core-do-not-import/middleware';
@@ -33,9 +32,11 @@ export * from './unstable-core-do-not-import/rootConfig';
 export * from './unstable-core-do-not-import/router';
 export * from './unstable-core-do-not-import/rpc';
 export * from './unstable-core-do-not-import/stream/jsonl';
+export * from './unstable-core-do-not-import/stream/sse.types';
 export * from './unstable-core-do-not-import/stream/sse';
 export * from './unstable-core-do-not-import/stream/tracked';
 export * from './unstable-core-do-not-import/stream/utils/createDeferred';
+export * from './unstable-core-do-not-import/stream/utils/disposable';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';
 export * from './unstable-core-do-not-import/utils';

package/src/vendor/unpromise/ATTRIBUTION.txt

@@ -0,0 +1 @@
+Origin source: https://github.com/cefn/watchable/tree/main/packages/unpromise

package/src/vendor/unpromise/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2023 Cefn Hoile
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/src/vendor/unpromise/index.ts

@@ -0,0 +1,7 @@
+export { Unpromise } from "./unpromise";
+export type {
+  ProxyPromise,
+  SubscribedPromise,
+  PromiseExecutor,
+  PromiseWithResolvers,
+} from "./types";

package/src/vendor/unpromise/types.ts

@@ -0,0 +1,55 @@
+/** TYPES */
+
+/** A promise that exploits a single, memory-safe upstream subscription
+ * to a single re-used Unpromise that persists for the VM lifetime of a
+ * Promise.
+ *
+ * Calling unsubscribe() removes the subscription, eliminating
+ * all references to the SubscribedPromise. */
+export interface SubscribedPromise<T> extends Promise<T> {
+  unsubscribe: () => void;
+}
+
+/** Duplicate of Promise interface, except each call returns SubscribedPromise */
+export interface ProxyPromise<T> extends Promise<T> {
+  subscribe: () => SubscribedPromise<T>;
+
+  then: <TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+       ,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+       
+  ) => SubscribedPromise<TResult1 | TResult2>;
+
+  catch: <TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+       
+  ) => SubscribedPromise<T | TResult>;
+
+  finally: (
+    onfinally?: (() => void) | null  
+  ) => SubscribedPromise<T>;
+}
+
+export type PromiseExecutor<T> = (
+  resolve: (value: T | PromiseLike<T>) => void,
+  reject: (reason?: any) => void
+) => void;
+
+/** A standard pattern for a resolvable, rejectable Promise, based
+ * on the emerging ES2023 standard. Type ported from
+ * https://github.com/microsoft/TypeScript/pull/56593 */
+export interface PromiseWithResolvers<T> {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: any) => void;
+}
+
+/** Given an array, this is the union of its members' types. */
+// export type MemberOf<Arr extends readonly unknown[]> = Arr[number];