stream-chat 9.50.3 → 10.0.0-rc.2

package/src/client_state.ts

@@ -1,13 +1,13 @@
-import type { UserResponse } from './types';
+import type { OwnUserResponse, UserResponse } from './types';
 import type { StreamChat } from './client';
 
 /**
- * ClientState - A container class for the client state.
+ * Container class for the client state.
  */
 export class ClientState {
   private client: StreamChat;
   users: {
-    [key: string]: UserResponse;
+    [key: string]: UserResponse | OwnUserResponse;
   };
   userChannelReferences: { [key: string]: { [key: string]: boolean } };
   constructor({ client }: { client: StreamChat }) {
@@ -25,7 +25,7 @@ export class ClientState {
     }
   }
 
-  updateUser(user?: UserResponse) {
+  updateUser(user?: UserResponse | OwnUserResponse) {
     if (user != null && this.client._cacheEnabled()) {
       this.users[user.id] = user;
     }

package/src/configuration/InstanceConfigurationService.ts

@@ -0,0 +1,73 @@
+/**
+ * InstanceConfigurationService is a singleton class that is used to store the configuration for the instances of classes exposed by the SKD such as:
+ * - StreamChat
+ * - Channel
+ * - Thread
+ * - MessageComposer
+ *
+ * Every existing and future instance configuration of the above classes will be setup using the following pattern:
+ * - StreamChat: StreamChat.setClientSetupFunction(setupFunction)
+ * - Channel: StreamChat.setChannelSetupFunction(setupFunction)
+ * - Thread: StreamChat.setThreadSetupFunction(setupFunction)
+ * - MessageComposer: StreamChat.setMessageComposerSetupFunction(setupFunction)
+ *
+ * The setupFunction is a function that is used to set up the instance configuration.
+ */
+
+import { StateStore } from '../store';
+import type {
+  ChannelSetupState,
+  MessageComposerSetupState,
+  SetInstanceConfigurationFunctions,
+  SetInstanceConfigurationServiceStates,
+  StreamChatSetupState,
+  ThreadSetupState,
+} from './types';
+
+type InstanceKey = keyof SetInstanceConfigurationServiceStates;
+
+export class InstanceConfigurationService {
+  private static instance: InstanceConfigurationService;
+  private setupStates: SetInstanceConfigurationServiceStates = {
+    Channel: new StateStore<ChannelSetupState>({
+      setupFunction: null,
+    }),
+    MessageComposer: new StateStore<MessageComposerSetupState>({
+      setupFunction: null,
+    }),
+    StreamChat: new StateStore<StreamChatSetupState>({
+      setupFunction: null,
+    }),
+    Thread: new StateStore<ThreadSetupState>({
+      setupFunction: null,
+    }),
+  };
+
+  setSetupFunctions(setupFunctions: SetInstanceConfigurationFunctions) {
+    for (const [instance, setupFunction] of Object.entries(setupFunctions)) {
+      const setupState =
+        this.setupStates[instance as keyof SetInstanceConfigurationServiceStates];
+      if (typeof setupState === 'undefined') return; // null is allowed
+      // todo: fix typing
+      (setupState as StateStore<{ setupFunction: unknown }>).partialNext({
+        setupFunction: setupFunction as SetInstanceConfigurationFunctions[InstanceKey],
+      });
+    }
+  }
+
+  get Channel() {
+    return this.setupStates.Channel;
+  }
+
+  get MessageComposer() {
+    return this.setupStates.MessageComposer;
+  }
+
+  get StreamChat() {
+    return this.setupStates.StreamChat;
+  }
+
+  get Thread() {
+    return this.setupStates.Thread;
+  }
+}

package/src/configuration/index.ts

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

package/src/configuration/types.ts

@@ -0,0 +1,81 @@
+import type { StreamChat } from '../client';
+import type { MessageComposer } from '../messageComposer';
+import type { Channel } from '../channel';
+import type { Thread } from '../thread';
+import type { StateStore } from '../store';
+
+export type MessageComposerTearDownFunction = () => void;
+
+export type MessageComposerSetupFunction = ({
+  composer,
+}: {
+  composer: MessageComposer;
+}) => void | MessageComposerTearDownFunction;
+
+export type MessageComposerSetupState = {
+  /**
+   * Each `MessageComposer` runs this function each time its signature changes or
+   * whenever you run `MessageComposer.registerSubscriptions`. Function returned
+   * from `applyModifications` will be used as a cleanup function - it will be stored
+   * and ran before new modification is applied. Cleaning up only the
+   * modified parts is the general way to go but if your setup gets a bit
+   * complicated, feel free to restore the whole composer with `MessageComposer.restore`.
+   */
+  setupFunction: MessageComposerSetupFunction | null;
+};
+
+export type StreamChatTearDownFunction = () => void;
+
+export type StreamChatSetupFunction = ({
+  client,
+}: {
+  client: StreamChat;
+}) => void | StreamChatTearDownFunction;
+
+export type StreamChatSetupState = {
+  setupFunction: StreamChatSetupFunction | null;
+};
+
+export type ChannelTearDownFunction = () => void;
+
+export type ChannelSetupFunction = ({
+  channel,
+}: {
+  channel: Channel;
+}) => void | ChannelTearDownFunction;
+
+export type ChannelSetupState = {
+  setupFunction: ChannelSetupFunction | null;
+};
+
+export type ThreadTearDownFunction = () => void;
+
+export type ThreadSetupFunction = ({
+  thread,
+}: {
+  thread: Thread;
+}) => void | ThreadTearDownFunction;
+
+export type ThreadSetupState = {
+  setupFunction: ThreadSetupFunction | null;
+};
+
+export type SetInstanceConfigurationServiceStates = {
+  Channel: StateStore<ChannelSetupState>;
+  MessageComposer: StateStore<MessageComposerSetupState>;
+  StreamChat: StateStore<StreamChatSetupState>;
+  Thread: StateStore<ThreadSetupState>;
+};
+
+export type SetupFnOf<T> =
+  T extends StateStore<infer S>
+    ? S extends { setupFunction?: infer F }
+      ? F
+      : never
+    : never;
+
+export type SetInstanceConfigurationFunctions = {
+  [K in keyof SetInstanceConfigurationServiceStates]?: SetupFnOf<
+    SetInstanceConfigurationServiceStates[K]
+  >;
+};