@xmtp/browser-sdk 1.0.0-rc1 → 1.1.0

package/src/Preferences.ts

@@ -0,0 +1,85 @@
+import type { ConsentEntityType, UserPreference } from "@xmtp/wasm-bindings";
+import { v4 } from "uuid";
+import { AsyncStream, type StreamCallback } from "@/AsyncStream";
+import type { SafeConsent } from "@/utils/conversions";
+import type { Client } from "./Client";
+
+export class Preferences {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async inboxState(refreshFromNetwork?: boolean) {
+    return this.#client.sendMessage("inboxState", {
+      refreshFromNetwork: refreshFromNetwork ?? false,
+    });
+  }
+
+  async inboxStateFromInboxIds(
+    inboxIds: string[],
+    refreshFromNetwork?: boolean,
+  ) {
+    return this.#client.sendMessage("inboxStateFromInboxIds", {
+      inboxIds,
+      refreshFromNetwork: refreshFromNetwork ?? false,
+    });
+  }
+
+  async getLatestInboxState(inboxId: string) {
+    return this.#client.sendMessage("getLatestInboxState", { inboxId });
+  }
+
+  async setConsentStates(records: SafeConsent[]) {
+    return this.#client.sendMessage("setConsentStates", { records });
+  }
+
+  async getConsentState(entityType: ConsentEntityType, entity: string) {
+    return this.#client.sendMessage("getConsentState", { entityType, entity });
+  }
+
+  async streamConsent(callback?: StreamCallback<SafeConsent[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<SafeConsent[]>();
+    const endStream = this.#client.handleStreamMessage<SafeConsent[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamConsent", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+
+  async streamPreferences(callback?: StreamCallback<UserPreference[]>) {
+    const streamId = v4();
+    const asyncStream = new AsyncStream<UserPreference[]>();
+    const endStream = this.#client.handleStreamMessage<UserPreference[]>(
+      streamId,
+      (error, value) => {
+        void asyncStream.callback(error, value ?? undefined);
+        void callback?.(error, value ?? undefined);
+      },
+    );
+    await this.#client.sendMessage("streamPreferences", {
+      streamId,
+    });
+    asyncStream.onReturn = () => {
+      void this.#client.sendMessage("endStream", {
+        streamId,
+      });
+      endStream();
+    };
+    return asyncStream;
+  }
+}

package/src/WorkerClient.ts

@@ -1,23 +1,24 @@
 import {
   verifySignedWithPublicKey,
   type Client,
-  type ConsentEntityType,
   type Identifier,
   type SignatureRequestType,
 } from "@xmtp/wasm-bindings";
 import type { ClientOptions } from "@/types";
-import { fromSafeConsent, type SafeConsent } from "@/utils/conversions";
 import { createClient } from "@/utils/createClient";
 import { WorkerConversations } from "@/WorkerConversations";
+import { WorkerPreferences } from "@/WorkerPreferences";
 
 export class WorkerClient {
   #client: Client;
-
   #conversations: WorkerConversations;
+  #preferences: WorkerPreferences;
 
   constructor(client: Client) {
     this.#client = client;
-    this.#conversations = new WorkerConversations(this, client.conversations());
+    const conversations = client.conversations();
+    this.#conversations = new WorkerConversations(this, conversations);
+    this.#preferences = new WorkerPreferences(client, conversations);
   }
 
   static async create(
@@ -49,6 +50,14 @@ export class WorkerClient {
     return this.#client.isRegistered;
   }
 
+  get conversations() {
+    return this.#conversations;
+  }
+
+  get preferences() {
+    return this.#preferences;
+  }
+
   createInboxSignatureText() {
     try {
       return this.#client.createInboxSignatureText();
@@ -122,26 +131,6 @@ export class WorkerClient {
     return this.#client.findInboxIdByIdentifier(identifier);
   }
 
-  async inboxState(refreshFromNetwork: boolean) {
-    return this.#client.inboxState(refreshFromNetwork);
-  }
-
-  async getLatestInboxState(inboxId: string) {
-    return this.#client.getLatestInboxState(inboxId);
-  }
-
-  async setConsentStates(records: SafeConsent[]) {
-    return this.#client.setConsentStates(records.map(fromSafeConsent));
-  }
-
-  async getConsentState(entityType: ConsentEntityType, entity: string) {
-    return this.#client.getConsentState(entityType, entity);
-  }
-
-  get conversations() {
-    return this.#conversations;
-  }
-
   signWithInstallationKey(signatureText: string) {
     return this.#client.signWithInstallationKey(signatureText);
   }

package/src/WorkerConversations.ts

@@ -1,13 +1,11 @@
 import {
   ConversationType,
-  type Consent,
   type ConsentState,
   type Conversation,
   type ConversationListItem,
   type Conversations,
   type Identifier,
   type Message,
-  type UserPreference,
 } from "@xmtp/wasm-bindings";
 import type { StreamCallback } from "@/AsyncStream";
 import {
@@ -178,27 +176,4 @@ export class WorkerConversations {
       conversationType,
     );
   }
-
-  streamConsent(callback?: StreamCallback<Consent[]>) {
-    const on_consent_update = (consent: Consent[]) => {
-      void callback?.(null, consent);
-    };
-    const on_error = (error: Error | null) => {
-      void callback?.(error, undefined);
-    };
-    return this.#conversations.streamConsent({ on_consent_update, on_error });
-  }
-
-  streamPreferences(callback?: StreamCallback<UserPreference[]>) {
-    const on_user_preference_update = (preferences: UserPreference[]) => {
-      void callback?.(null, preferences);
-    };
-    const on_error = (error: Error | null) => {
-      void callback?.(error, undefined);
-    };
-    return this.#conversations.streamPreferences({
-      on_user_preference_update,
-      on_error,
-    });
-  }
 }

package/src/WorkerPreferences.ts

@@ -0,0 +1,68 @@
+import {
+  type Client,
+  type Consent,
+  type ConsentEntityType,
+  type Conversations,
+  type UserPreference,
+} from "@xmtp/wasm-bindings";
+import type { StreamCallback } from "@/AsyncStream";
+import { fromSafeConsent, type SafeConsent } from "@/utils/conversions";
+
+export class WorkerPreferences {
+  #client: Client;
+  #conversations: Conversations;
+
+  constructor(client: Client, conversations: Conversations) {
+    this.#client = client;
+    this.#conversations = conversations;
+  }
+
+  async inboxState(refreshFromNetwork: boolean) {
+    return this.#client.inboxState(refreshFromNetwork);
+  }
+
+  async inboxStateFromInboxIds(
+    inboxIds: string[],
+    refreshFromNetwork?: boolean,
+  ) {
+    return this.#client.inboxStateFromInboxIds(
+      inboxIds,
+      refreshFromNetwork ?? false,
+    );
+  }
+
+  async getLatestInboxState(inboxId: string) {
+    return this.#client.getLatestInboxState(inboxId);
+  }
+
+  async setConsentStates(records: SafeConsent[]) {
+    return this.#client.setConsentStates(records.map(fromSafeConsent));
+  }
+
+  async getConsentState(entityType: ConsentEntityType, entity: string) {
+    return this.#client.getConsentState(entityType, entity);
+  }
+
+  streamConsent(callback?: StreamCallback<Consent[]>) {
+    const on_consent_update = (consent: Consent[]) => {
+      void callback?.(null, consent);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.streamConsent({ on_consent_update, on_error });
+  }
+
+  streamPreferences(callback?: StreamCallback<UserPreference[]>) {
+    const on_user_preference_update = (preferences: UserPreference[]) => {
+      void callback?.(null, preferences);
+    };
+    const on_error = (error: Error | null) => {
+      void callback?.(error, undefined);
+    };
+    return this.#conversations.streamPreferences({
+      on_user_preference_update,
+      on_error,
+    });
+  }
+}

package/src/index.ts

@@ -41,6 +41,7 @@ export {
   Message,
   MessageDisappearingSettings,
   MetadataField,
+  Opfs,
   PermissionLevel,
   PermissionPolicy,
   PermissionPolicySet,

package/src/types/clientEvents.ts

@@ -152,6 +152,15 @@ export type ClientEvents =
         refreshFromNetwork: boolean;
       };
     }
+  | {
+      action: "inboxStateFromInboxIds";
+      id: string;
+      result: SafeInboxState[];
+      data: {
+        inboxIds: string[];
+        refreshFromNetwork: boolean;
+      };
+    }
   | {
       action: "getLatestInboxState";
       id: string;

package/src/workers/client.ts

@@ -194,24 +194,37 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
         break;
       }
       case "inboxState": {
-        const inboxState = await client.inboxState(data.refreshFromNetwork);
+        const inboxState = await client.preferences.inboxState(
+          data.refreshFromNetwork,
+        );
         const result = toSafeInboxState(inboxState);
         postMessage({ id, action, result });
         break;
       }
+      case "inboxStateFromInboxIds": {
+        const inboxStates = await client.preferences.inboxStateFromInboxIds(
+          data.inboxIds,
+          data.refreshFromNetwork,
+        );
+        const result = inboxStates.map(toSafeInboxState);
+        postMessage({ id, action, result });
+        break;
+      }
       case "getLatestInboxState": {
-        const inboxState = await client.getLatestInboxState(data.inboxId);
+        const inboxState = await client.preferences.getLatestInboxState(
+          data.inboxId,
+        );
         const result = toSafeInboxState(inboxState);
         postMessage({ id, action, result });
         break;
       }
       case "setConsentStates": {
-        await client.setConsentStates(data.records);
+        await client.preferences.setConsentStates(data.records);
         postMessage({ id, action, result: undefined });
         break;
       }
       case "getConsentState": {
-        const result = await client.getConsentState(
+        const result = await client.preferences.getConsentState(
           data.entityType,
           data.entity,
         );
@@ -325,7 +338,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
             });
           }
         };
-        const streamCloser = client.conversations.streamConsent(streamCallback);
+        const streamCloser = client.preferences.streamConsent(streamCallback);
         streamClosers.set(data.streamId, streamCloser);
         postMessage({
           id,
@@ -354,7 +367,7 @@ self.onmessage = async (event: MessageEvent<ClientEventsClientMessageData>) => {
           }
         };
         const streamCloser =
-          client.conversations.streamPreferences(streamCallback);
+          client.preferences.streamPreferences(streamCallback);
         streamClosers.set(data.streamId, streamCloser);
         postMessage({
           id,