spacetimedb 2.4.1 → 2.6.0

package/src/react/SpacetimeDBProvider.ts

@@ -1,84 +1,84 @@
-import {
-  DbConnectionBuilder,
-  type DbConnectionImpl,
-} from '../sdk/db_connection_impl';
-import * as React from 'react';
-import { SpacetimeDBContext } from './useSpacetimeDB';
-import type { ConnectionState } from './connection_state';
-import { ConnectionId } from '../lib/connection_id';
-import {
-  ConnectionManager,
-  type ConnectionState as ManagerConnectionState,
-} from '../sdk/connection_manager';
-
-export interface SpacetimeDBProviderProps<
-  DbConnection extends DbConnectionImpl<any>,
-> {
-  connectionBuilder: DbConnectionBuilder<DbConnection>;
-  children?: React.ReactNode;
-}
-
-export function SpacetimeDBProvider<
-  DbConnection extends DbConnectionImpl<any>,
->({
-  connectionBuilder,
-  children,
-}: SpacetimeDBProviderProps<DbConnection>): React.JSX.Element {
-  const uri = connectionBuilder.getUri();
-  const moduleName = connectionBuilder.getModuleName();
-  const key = React.useMemo(
-    () => ConnectionManager.getKey(uri, moduleName),
-    [uri, moduleName]
-  );
-
-  const fallbackStateRef = React.useRef<ManagerConnectionState>({
-    isActive: false,
-    identity: undefined,
-    token: undefined,
-    connectionId: ConnectionId.random(),
-    connectionError: undefined,
-  });
-
-  const subscribe = React.useCallback(
-    (onStoreChange: () => void) =>
-      ConnectionManager.subscribe(key, onStoreChange),
-    [key]
-  );
-  const getSnapshot = React.useCallback(
-    () => ConnectionManager.getSnapshot(key) ?? fallbackStateRef.current,
-    [key]
-  );
-  const getServerSnapshot = React.useCallback(
-    () => fallbackStateRef.current,
-    []
-  );
-
-  const state = React.useSyncExternalStore(
-    subscribe,
-    getSnapshot,
-    getServerSnapshot
-  );
-
-  const getConnection = React.useCallback(
-    () => ConnectionManager.getConnection<DbConnection>(key),
-    [key]
-  );
-
-  const contextValue = React.useMemo<ConnectionState>(
-    () => ({ ...state, getConnection }),
-    [state, getConnection]
-  );
-
-  React.useEffect(() => {
-    ConnectionManager.retain(key, connectionBuilder);
-    return () => {
-      ConnectionManager.release(key);
-    };
-  }, [key, connectionBuilder]);
-
-  return React.createElement(
-    SpacetimeDBContext.Provider,
-    { value: contextValue },
-    children
-  );
-}
+import {
+  DbConnectionBuilder,
+  type DbConnectionImpl,
+} from '../sdk/db_connection_impl';
+import * as React from 'react';
+import { SpacetimeDBContext } from './useSpacetimeDB';
+import type { ConnectionState } from './connection_state';
+import { ConnectionId } from '../lib/connection_id';
+import {
+  ConnectionManager,
+  type ConnectionState as ManagerConnectionState,
+} from '../sdk/connection_manager';
+
+export interface SpacetimeDBProviderProps<
+  DbConnection extends DbConnectionImpl<any>,
+> {
+  connectionBuilder: DbConnectionBuilder<DbConnection>;
+  children?: React.ReactNode;
+}
+
+export function SpacetimeDBProvider<
+  DbConnection extends DbConnectionImpl<any>,
+>({
+  connectionBuilder,
+  children,
+}: SpacetimeDBProviderProps<DbConnection>): React.JSX.Element {
+  const uri = connectionBuilder.getUri();
+  const moduleName = connectionBuilder.getModuleName();
+  const key = React.useMemo(
+    () => ConnectionManager.getKey(uri, moduleName),
+    [uri, moduleName]
+  );
+
+  const fallbackStateRef = React.useRef<ManagerConnectionState>({
+    isActive: false,
+    identity: undefined,
+    token: undefined,
+    connectionId: ConnectionId.random(),
+    connectionError: undefined,
+  });
+
+  const subscribe = React.useCallback(
+    (onStoreChange: () => void) =>
+      ConnectionManager.subscribe(key, onStoreChange),
+    [key]
+  );
+  const getSnapshot = React.useCallback(
+    () => ConnectionManager.getSnapshot(key) ?? fallbackStateRef.current,
+    [key]
+  );
+  const getServerSnapshot = React.useCallback(
+    () => fallbackStateRef.current,
+    []
+  );
+
+  const state = React.useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot
+  );
+
+  const getConnection = React.useCallback(
+    () => ConnectionManager.getConnection<DbConnection>(key),
+    [key]
+  );
+
+  const contextValue = React.useMemo<ConnectionState>(
+    () => ({ ...state, getConnection }),
+    [state, getConnection]
+  );
+
+  React.useEffect(() => {
+    ConnectionManager.retain(key, connectionBuilder);
+    return () => {
+      ConnectionManager.release(key);
+    };
+  }, [key, connectionBuilder]);
+
+  return React.createElement(
+    SpacetimeDBContext.Provider,
+    { value: contextValue },
+    children
+  );
+}

package/src/react/connection_state.ts

@@ -1,6 +1,6 @@
-import type { DbConnectionImpl } from '../sdk/db_connection_impl';
-import type { ConnectionState as ManagerConnectionState } from '../sdk/connection_manager';
-
-export type ConnectionState = ManagerConnectionState & {
-  getConnection(): DbConnectionImpl<any> | null;
-};
+import type { DbConnectionImpl } from '../sdk/db_connection_impl';
+import type { ConnectionState as ManagerConnectionState } from '../sdk/connection_manager';
+
+export type ConnectionState = ManagerConnectionState & {
+  getConnection(): DbConnectionImpl<any> | null;
+};

package/src/react/index.ts

@@ -1,5 +1,5 @@
-export * from './SpacetimeDBProvider.ts';
-export { useSpacetimeDB } from './useSpacetimeDB.ts';
-export { useTable } from './useTable.ts';
-export { useReducer } from './useReducer.ts';
-export { useProcedure } from './useProcedure.ts';
+export * from './SpacetimeDBProvider.ts';
+export { useSpacetimeDB } from './useSpacetimeDB.ts';
+export { useTable } from './useTable.ts';
+export { useReducer } from './useReducer.ts';
+export { useProcedure } from './useProcedure.ts';

package/src/react/useProcedure.ts

@@ -1,60 +1,60 @@
-import { useCallback, useEffect, useRef } from 'react';
-import type { UntypedProcedureDef } from '../sdk/procedures';
-import { useSpacetimeDB } from './useSpacetimeDB';
-import type {
-  ProcedureParamsType,
-  ProcedureReturnType,
-} from '../sdk/type_utils';
-
-export function useProcedure<ProcedureDef extends UntypedProcedureDef>(
-  procedureDef: ProcedureDef
-): (
-  ...params: ProcedureParamsType<ProcedureDef>
-) => Promise<ProcedureReturnType<ProcedureDef>> {
-  const { getConnection, isActive } = useSpacetimeDB();
-  const procedureName = procedureDef.accessorName;
-
-  // Holds calls made before the connection exists
-  const queueRef = useRef<
-    {
-      params: ProcedureParamsType<ProcedureDef>;
-      resolve: (val: any) => void;
-      reject: (err: unknown) => void;
-    }[]
-  >([]);
-
-  // Flush when we finally have a connection
-  useEffect(() => {
-    const conn = getConnection();
-    if (!conn) {
-      return;
-    }
-    const fn = (conn.procedures as any)[procedureName] as (
-      ...p: ProcedureParamsType<ProcedureDef>
-    ) => Promise<ProcedureReturnType<ProcedureDef>>;
-    if (queueRef.current.length) {
-      const pending = queueRef.current.splice(0);
-      for (const item of pending) {
-        fn(...item.params).then(item.resolve, item.reject);
-      }
-    }
-  }, [getConnection, procedureName, isActive]);
-
-  return useCallback(
-    (...params: ProcedureParamsType<ProcedureDef>) => {
-      const conn = getConnection();
-      if (!conn) {
-        return new Promise<ProcedureReturnType<ProcedureDef>>(
-          (resolve, reject) => {
-            queueRef.current.push({ params, resolve, reject });
-          }
-        );
-      }
-      const fn = (conn.procedures as any)[procedureName] as (
-        ...p: ProcedureParamsType<ProcedureDef>
-      ) => Promise<ProcedureReturnType<ProcedureDef>>;
-      return fn(...params);
-    },
-    [getConnection, procedureName]
-  );
-}
+import { useCallback, useEffect, useRef } from 'react';
+import type { UntypedProcedureDef } from '../sdk/procedures';
+import { useSpacetimeDB } from './useSpacetimeDB';
+import type {
+  ProcedureParamsType,
+  ProcedureReturnType,
+} from '../sdk/type_utils';
+
+export function useProcedure<ProcedureDef extends UntypedProcedureDef>(
+  procedureDef: ProcedureDef
+): (
+  ...params: ProcedureParamsType<ProcedureDef>
+) => Promise<ProcedureReturnType<ProcedureDef>> {
+  const { getConnection, isActive } = useSpacetimeDB();
+  const procedureName = procedureDef.accessorName;
+
+  // Holds calls made before the connection exists
+  const queueRef = useRef<
+    {
+      params: ProcedureParamsType<ProcedureDef>;
+      resolve: (val: any) => void;
+      reject: (err: unknown) => void;
+    }[]
+  >([]);
+
+  // Flush when we finally have a connection
+  useEffect(() => {
+    const conn = getConnection();
+    if (!conn) {
+      return;
+    }
+    const fn = (conn.procedures as any)[procedureName] as (
+      ...p: ProcedureParamsType<ProcedureDef>
+    ) => Promise<ProcedureReturnType<ProcedureDef>>;
+    if (queueRef.current.length) {
+      const pending = queueRef.current.splice(0);
+      for (const item of pending) {
+        fn(...item.params).then(item.resolve, item.reject);
+      }
+    }
+  }, [getConnection, procedureName, isActive]);
+
+  return useCallback(
+    (...params: ProcedureParamsType<ProcedureDef>) => {
+      const conn = getConnection();
+      if (!conn) {
+        return new Promise<ProcedureReturnType<ProcedureDef>>(
+          (resolve, reject) => {
+            queueRef.current.push({ params, resolve, reject });
+          }
+        );
+      }
+      const fn = (conn.procedures as any)[procedureName] as (
+        ...p: ProcedureParamsType<ProcedureDef>
+      ) => Promise<ProcedureReturnType<ProcedureDef>>;
+      return fn(...params);
+    },
+    [getConnection, procedureName]
+  );
+}

package/src/react/useReducer.ts

@@ -1,53 +1,53 @@
-import { useCallback, useEffect, useRef } from 'react';
-import type { UntypedReducerDef } from '../sdk/reducers';
-import { useSpacetimeDB } from './useSpacetimeDB';
-import type { ParamsType } from '../sdk';
-
-export function useReducer<ReducerDef extends UntypedReducerDef>(
-  reducerDef: ReducerDef
-): (...params: ParamsType<ReducerDef>) => Promise<void> {
-  const { getConnection, isActive } = useSpacetimeDB();
-  const reducerName = reducerDef.accessorName;
-
-  // Holds calls made before the connection exists
-  const queueRef = useRef<
-    {
-      params: ParamsType<ReducerDef>;
-      resolve: () => void;
-      reject: (err: unknown) => void;
-    }[]
-  >([]);
-
-  // Flush when we finally have a connection
-  useEffect(() => {
-    const conn = getConnection();
-    if (!conn) {
-      return;
-    }
-    const fn = (conn.reducers as any)[reducerName] as (
-      ...p: ParamsType<ReducerDef>
-    ) => Promise<void>;
-    if (queueRef.current.length) {
-      const pending = queueRef.current.splice(0);
-      for (const item of pending) {
-        fn(...item.params).then(item.resolve, item.reject);
-      }
-    }
-  }, [getConnection, reducerName, isActive]);
-
-  return useCallback(
-    (...params: ParamsType<ReducerDef>) => {
-      const conn = getConnection();
-      if (!conn) {
-        return new Promise<void>((resolve, reject) => {
-          queueRef.current.push({ params, resolve, reject });
-        });
-      }
-      const fn = (conn.reducers as any)[reducerName] as (
-        ...p: ParamsType<ReducerDef>
-      ) => Promise<void>;
-      return fn(...params);
-    },
-    [getConnection, reducerName]
-  );
-}
+import { useCallback, useEffect, useRef } from 'react';
+import type { UntypedReducerDef } from '../sdk/reducers';
+import { useSpacetimeDB } from './useSpacetimeDB';
+import type { ParamsType } from '../sdk';
+
+export function useReducer<ReducerDef extends UntypedReducerDef>(
+  reducerDef: ReducerDef
+): (...params: ParamsType<ReducerDef>) => Promise<void> {
+  const { getConnection, isActive } = useSpacetimeDB();
+  const reducerName = reducerDef.accessorName;
+
+  // Holds calls made before the connection exists
+  const queueRef = useRef<
+    {
+      params: ParamsType<ReducerDef>;
+      resolve: () => void;
+      reject: (err: unknown) => void;
+    }[]
+  >([]);
+
+  // Flush when we finally have a connection
+  useEffect(() => {
+    const conn = getConnection();
+    if (!conn) {
+      return;
+    }
+    const fn = (conn.reducers as any)[reducerName] as (
+      ...p: ParamsType<ReducerDef>
+    ) => Promise<void>;
+    if (queueRef.current.length) {
+      const pending = queueRef.current.splice(0);
+      for (const item of pending) {
+        fn(...item.params).then(item.resolve, item.reject);
+      }
+    }
+  }, [getConnection, reducerName, isActive]);
+
+  return useCallback(
+    (...params: ParamsType<ReducerDef>) => {
+      const conn = getConnection();
+      if (!conn) {
+        return new Promise<void>((resolve, reject) => {
+          queueRef.current.push({ params, resolve, reject });
+        });
+      }
+      const fn = (conn.reducers as any)[reducerName] as (
+        ...p: ParamsType<ReducerDef>
+      ) => Promise<void>;
+      return fn(...params);
+    },
+    [getConnection, reducerName]
+  );
+}

package/src/react/useSpacetimeDB.ts

@@ -1,18 +1,18 @@
-import { createContext, useContext } from 'react';
-import type { ConnectionState } from './connection_state';
-
-export const SpacetimeDBContext = createContext<ConnectionState | undefined>(
-  undefined
-);
-
-// Throws an error if used outside of a SpacetimeDBProvider
-// Error is caught by other hooks like useTable so they can provide better error messages
-export function useSpacetimeDB(): ConnectionState {
-  const context = useContext(SpacetimeDBContext) as ConnectionState | undefined;
-  if (!context) {
-    throw new Error(
-      'useSpacetimeDB must be used within a SpacetimeDBProvider component. Did you forget to add a `SpacetimeDBProvider` to your component tree?'
-    );
-  }
-  return context;
-}
+import { createContext, useContext } from 'react';
+import type { ConnectionState } from './connection_state';
+
+export const SpacetimeDBContext = createContext<ConnectionState | undefined>(
+  undefined
+);
+
+// Throws an error if used outside of a SpacetimeDBProvider
+// Error is caught by other hooks like useTable so they can provide better error messages
+export function useSpacetimeDB(): ConnectionState {
+  const context = useContext(SpacetimeDBContext) as ConnectionState | undefined;
+  if (!context) {
+    throw new Error(
+      'useSpacetimeDB must be used within a SpacetimeDBProvider component. Did you forget to add a `SpacetimeDBProvider` to your component tree?'
+    );
+  }
+  return context;
+}