@ai-sdk/rsc 2.0.45 → 2.0.46

package/src/types/index.ts

@@ -0,0 +1 @@
+export type * from '../index';

package/src/types.test-d.ts

@@ -0,0 +1,17 @@
+import { expectTypeOf } from 'vitest';
+import { describe, it } from 'vitest';
+import type { StreamableValue } from '.';
+
+describe('StreamableValue type', () => {
+  it('should yield a type error when assigning a wrong value', () => {
+    expectTypeOf<StreamableValue<string>>().not.toEqualTypeOf<
+      StreamableValue<boolean>
+    >();
+
+    expectTypeOf<StreamableValue<string>>().not.toEqualTypeOf<string>();
+
+    expectTypeOf<
+      StreamableValue<string>
+    >().not.toEqualTypeOf<'THIS IS NOT A STREAMABLE VALUE'>();
+  });
+});

package/src/types.ts

@@ -0,0 +1,71 @@
+export type JSONValue = string | number | boolean | JSONObject | JSONArray;
+
+interface JSONObject {
+  [x: string]: JSONValue | undefined;
+}
+
+interface JSONArray extends Array<JSONValue> {}
+
+export type AIAction<T = any, R = any> = (...args: T[]) => Promise<R>;
+export type AIActions<T = any, R = any> = Record<string, AIAction<T, R>>;
+
+export type ServerWrappedAction<T = unknown> = (
+  aiState: T,
+  ...args: unknown[]
+) => Promise<[Promise<T>, unknown]>;
+export type ServerWrappedActions<T = unknown> = Record<
+  string,
+  ServerWrappedAction<T>
+>;
+
+export type InternalAIProviderProps<AIState = any, UIState = any> = {
+  children: React.ReactNode;
+  initialUIState: UIState;
+  initialAIState: AIState;
+  initialAIStatePatch: undefined | Promise<AIState>;
+  wrappedActions: ServerWrappedActions<AIState>;
+  wrappedSyncUIState?: ServerWrappedAction<AIState>;
+};
+
+export type AIProviderProps<AIState = any, UIState = any, Actions = any> = {
+  children: React.ReactNode;
+  initialAIState?: AIState;
+  initialUIState?: UIState;
+  /** $ActionTypes is only added for type inference and is never used at runtime **/
+  $ActionTypes?: Actions;
+};
+
+export type AIProvider<AIState = any, UIState = any, Actions = any> = (
+  props: AIProviderProps<AIState, UIState, Actions>,
+) => Promise<React.ReactElement>;
+
+export type InferAIState<T, Fallback> =
+  T extends AIProvider<infer AIState, any, any> ? AIState : Fallback;
+export type InferUIState<T, Fallback> =
+  T extends AIProvider<any, infer UIState, any> ? UIState : Fallback;
+export type InferActions<T, Fallback> =
+  T extends AIProvider<any, any, infer Actions> ? Actions : Fallback;
+
+export type InternalAIStateStorageOptions = {
+  onSetAIState?: OnSetAIState<any>;
+};
+
+export type OnSetAIState<S> = ({
+  key,
+  state,
+  done,
+}: {
+  key: string | number | symbol | undefined;
+  state: S;
+  done: boolean;
+}) => void | Promise<void>;
+
+export type OnGetUIState<S> = AIAction<void, S | undefined>;
+
+export type ValueOrUpdater<T> = T | ((current: T) => T);
+
+export type MutableAIState<AIState> = {
+  get: () => AIState;
+  update: (newState: ValueOrUpdater<AIState>) => void;
+  done: ((newState: AIState) => void) | (() => void);
+};

package/src/util/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * Warning time for notifying developers that a stream is hanging in dev mode
+ * using a console.warn.
+ */
+export const HANGING_STREAM_WARNING_TIME_MS = 15 * 1000;

package/src/util/create-resolvable-promise.ts

@@ -0,0 +1,28 @@
+/**
+ * Creates a Promise with externally accessible resolve and reject functions.
+ *
+ * @template T - The type of the value that the Promise will resolve to.
+ * @returns An object containing:
+ *   - promise: A Promise that can be resolved or rejected externally.
+ *   - resolve: A function to resolve the Promise with a value of type T.
+ *   - reject: A function to reject the Promise with an error.
+ */
+export function createResolvablePromise<T = any>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: unknown) => void;
+} {
+  let resolve: (value: T) => void;
+  let reject: (error: unknown) => void;
+
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return {
+    promise,
+    resolve: resolve!,
+    reject: reject!,
+  };
+}

package/src/util/is-async-generator.ts

@@ -0,0 +1,7 @@
+export function isAsyncGenerator<T, TReturn, TNext>(
+  value: unknown,
+): value is AsyncGenerator<T, TReturn, TNext> {
+  return (
+    value != null && typeof value === 'object' && Symbol.asyncIterator in value
+  );
+}

package/src/util/is-function.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the given value is a function.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} True if the value is a function, false otherwise.
+ */
+export const isFunction = (value: unknown): value is Function =>
+  typeof value === 'function';

package/src/util/is-generator.ts

@@ -0,0 +1,5 @@
+export function isGenerator<T, TReturn, TNext>(
+  value: unknown,
+): value is Generator<T, TReturn, TNext> {
+  return value != null && typeof value === 'object' && Symbol.iterator in value;
+}