@bitwarden/sdk-internal 0.2.0-main.157 → 0.2.0-main.158

package/VERSION

@@ -1 +1 @@
-6a9ca8ce0d1559c52dacd21225c32528dedabf44
+6e9768b88baec149ab5713b291d9965b9e53aa09

package/bitwarden_wasm_internal.d.ts

@@ -435,11 +435,16 @@ export type Endpoint =
   | "DesktopRenderer"
   | "DesktopMain";
 
-export interface CommunicationBackend {
+export interface IpcCommunicationBackendSender {
   send(message: OutgoingMessage): Promise<void>;
-  receive(): Promise<IncomingMessage>;
 }
 
+export interface ChannelError extends Error {
+  name: "ChannelError";
+}
+
+export function isChannelError(error: any): error is ChannelError;
+
 export interface DeserializeError extends Error {
   name: "DeserializeError";
 }
@@ -1122,9 +1127,21 @@ export class IncomingMessage {
 }
 export class IpcClient {
   free(): void;
-  constructor(communication_provider: CommunicationBackend);
+  constructor(communication_provider: IpcCommunicationBackend);
   send(message: OutgoingMessage): Promise<void>;
-  receive(): Promise<IncomingMessage>;
+  subscribe(): Promise<IpcClientSubscription>;
+}
+export class IpcClientSubscription {
+  private constructor();
+  free(): void;
+}
+export class IpcCommunicationBackend {
+  free(): void;
+  constructor(sender: IpcCommunicationBackendSender);
+  /**
+   * JavaScript function to provide a received message to the backend/IPC framework.
+   */
+  deliver_message(message: IncomingMessage): void;
 }
 export class OutgoingMessage {
   free(): void;

package/bitwarden_wasm_internal_bg.js

@@ -347,6 +347,19 @@ function _assertClass(instance, klass) {
     throw new Error(`expected instance of ${klass.name}`);
   }
 }
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+export function isChannelError(error) {
+  try {
+    const ret = wasm.isChannelError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+}
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -587,7 +600,7 @@ function __wbg_adapter_53(arg0, arg1, arg2) {
   );
 }
 
-function __wbg_adapter_233(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_232(arg0, arg1, arg2, arg3) {
   wasm.wasm_bindgen__convert__closures__invoke2_mut__h2a33b0877ef96682(
     arg0,
     arg1,
@@ -1553,14 +1566,6 @@ const IncomingMessageFinalization =
     : new FinalizationRegistry((ptr) => wasm.__wbg_incomingmessage_free(ptr >>> 0, 1));
 
 export class IncomingMessage {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(IncomingMessage.prototype);
-    obj.__wbg_ptr = ptr;
-    IncomingMessageFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
@@ -1704,10 +1709,12 @@ export class IpcClient {
     wasm.__wbg_ipcclient_free(ptr, 0);
   }
   /**
-   * @param {CommunicationBackend} communication_provider
+   * @param {IpcCommunicationBackend} communication_provider
    */
   constructor(communication_provider) {
-    const ret = wasm.ipcclient_new(addHeapObject(communication_provider));
+    _assertClass(communication_provider, IpcCommunicationBackend);
+    var ptr0 = communication_provider.__destroy_into_raw();
+    const ret = wasm.ipcclient_new(ptr0);
     this.__wbg_ptr = ret >>> 0;
     IpcClientFinalization.register(this, this.__wbg_ptr, this);
     return this;
@@ -1723,14 +1730,88 @@ export class IpcClient {
     return takeObject(ret);
   }
   /**
-   * @returns {Promise<IncomingMessage>}
+   * @returns {Promise<IpcClientSubscription>}
    */
-  receive() {
-    const ret = wasm.ipcclient_receive(this.__wbg_ptr);
+  subscribe() {
+    const ret = wasm.ipcclient_subscribe(this.__wbg_ptr);
     return takeObject(ret);
   }
 }
 
+const IpcClientSubscriptionFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipcclientsubscription_free(ptr >>> 0, 1));
+
+export class IpcClientSubscription {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(IpcClientSubscription.prototype);
+    obj.__wbg_ptr = ptr;
+    IpcClientSubscriptionFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IpcClientSubscriptionFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ipcclientsubscription_free(ptr, 0);
+  }
+}
+
+const IpcCommunicationBackendFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipccommunicationbackend_free(ptr >>> 0, 1));
+
+export class IpcCommunicationBackend {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    IpcCommunicationBackendFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ipccommunicationbackend_free(ptr, 0);
+  }
+  /**
+   * @param {IpcCommunicationBackendSender} sender
+   */
+  constructor(sender) {
+    const ret = wasm.ipccommunicationbackend_new(addHeapObject(sender));
+    this.__wbg_ptr = ret >>> 0;
+    IpcCommunicationBackendFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * JavaScript function to provide a received message to the backend/IPC framework.
+   * @param {IncomingMessage} message
+   */
+  deliver_message(message) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      _assertClass(message, IncomingMessage);
+      var ptr0 = message.__destroy_into_raw();
+      wasm.ipccommunicationbackend_deliver_message(retptr, this.__wbg_ptr, ptr0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      if (r1) {
+        throw takeObject(r0);
+      }
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
+
 const OutgoingMessageFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -2052,14 +2133,6 @@ const ReceiveErrorFinalization =
     : new FinalizationRegistry((ptr) => wasm.__wbg_receiveerror_free(ptr >>> 0, 1));
 
 export class ReceiveError {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(ReceiveError.prototype);
-    obj.__wbg_ptr = ptr;
-    ReceiveErrorFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-
   __destroy_into_raw() {
     const ptr = this.__wbg_ptr;
     this.__wbg_ptr = 0;
@@ -2447,11 +2520,6 @@ export function __wbg_headers_9cb51cfd2ac780a4(arg0) {
   return addHeapObject(ret);
 }
 
-export function __wbg_incomingmessage_new(arg0) {
-  const ret = IncomingMessage.__wrap(arg0);
-  return addHeapObject(ret);
-}
-
 export function __wbg_info_033d8b8a0838f1d3(arg0, arg1, arg2, arg3) {
   console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 }
@@ -2500,6 +2568,11 @@ export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
   return ret;
 }
 
+export function __wbg_ipcclientsubscription_new(arg0) {
+  const ret = IpcClientSubscription.__wrap(arg0);
+  return addHeapObject(ret);
+}
+
 export function __wbg_isArray_a1eab7e0d067391b(arg0) {
   const ret = Array.isArray(getObject(arg0));
   return ret;
@@ -2553,7 +2626,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
       const a = state0.a;
       state0.a = 0;
       try {
-        return __wbg_adapter_233(a, state0.b, arg0, arg1);
+        return __wbg_adapter_232(a, state0.b, arg0, arg1);
       } finally {
         state0.a = a;
       }
@@ -2695,18 +2768,6 @@ export function __wbg_randomFillSync_ac0988aba3254290() {
   }, arguments);
 }
 
-export function __wbg_receive_9512d555fb8b5130() {
-  return handleError(function (arg0) {
-    const ret = getObject(arg0).receive();
-    return addHeapObject(ret);
-  }, arguments);
-}
-
-export function __wbg_receiveerror_new(arg0) {
-  const ret = ReceiveError.__wrap(arg0);
-  return addHeapObject(ret);
-}
-
 export function __wbg_require_60cc747a6bc5215a() {
   return handleError(function () {
     const ret = module.require;
@@ -2719,7 +2780,7 @@ export function __wbg_resolve_4851785c9c5f573d(arg0) {
   return addHeapObject(ret);
 }
 
-export function __wbg_send_c9eacaae08065b18() {
+export function __wbg_send_9b8fc6bb517867dd() {
   return handleError(function (arg0, arg1) {
     const ret = getObject(arg0).send(OutgoingMessage.__wrap(arg1));
     return addHeapObject(ret);
@@ -2927,13 +2988,13 @@ export function __wbindgen_cb_drop(arg0) {
   return ret;
 }
 
-export function __wbindgen_closure_wrapper2851(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 662, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper2861(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 658, __wbg_adapter_50);
   return addHeapObject(ret);
 }
 
-export function __wbindgen_closure_wrapper3236(arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 783, __wbg_adapter_53);
+export function __wbindgen_closure_wrapper3246(arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 779, __wbg_adapter_53);
   return addHeapObject(ret);
 }
 

package/bitwarden_wasm_internal_bg.wasm.d.ts

@@ -47,6 +47,9 @@ export const __wbg_get_incomingmessage_source: (a: number) => number;
 export const __wbg_set_incomingmessage_source: (a: number, b: number) => void;
 export const __wbg_get_incomingmessage_topic: (a: number, b: number) => void;
 export const __wbg_set_incomingmessage_topic: (a: number, b: number, c: number) => void;
+export const __wbg_ipccommunicationbackend_free: (a: number, b: number) => void;
+export const ipccommunicationbackend_new: (a: number) => number;
+export const ipccommunicationbackend_deliver_message: (a: number, b: number, c: number) => void;
 export const __wbg_senderror_free: (a: number, b: number) => void;
 export const __wbg_receiveerror_free: (a: number, b: number) => void;
 export const __wbg_get_receiveerror_timeout: (a: number) => number;
@@ -56,9 +59,10 @@ export const __wbg_set_receiveerror_crypto: (a: number, b: number) => void;
 export const __wbg_get_receiveerror_communication: (a: number) => number;
 export const __wbg_set_receiveerror_communication: (a: number, b: number) => void;
 export const __wbg_ipcclient_free: (a: number, b: number) => void;
+export const __wbg_ipcclientsubscription_free: (a: number, b: number) => void;
 export const ipcclient_new: (a: number) => number;
 export const ipcclient_send: (a: number, b: number) => number;
-export const ipcclient_receive: (a: number) => number;
+export const ipcclient_subscribe: (a: number) => number;
 export const outgoingmessage_new: (a: number, b: number, c: number, d: number, e: number) => number;
 export const outgoingmessage_new_json_payload: (
   a: number,
@@ -76,6 +80,7 @@ export const incomingmessage_new: (
   f: number,
 ) => number;
 export const incomingmessage_parse_payload_as_json: (a: number) => number;
+export const isChannelError: (a: number) => number;
 export const isDeserializeError: (a: number) => number;
 export const __wbg_set_senderror_crypto: (a: number, b: number) => void;
 export const __wbg_set_senderror_communication: (a: number, b: number) => void;