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

package/node/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/node/bitwarden_wasm_internal.js

@@ -341,6 +341,19 @@ function _assertClass(instance, klass) {
     throw new Error(`expected instance of ${klass.name}`);
   }
 }
+/**
+ * @param {any} error
+ * @returns {boolean}
+ */
+module.exports.isChannelError = function (error) {
+  try {
+    const ret = wasm.isChannelError(addBorrowedObject(error));
+    return ret !== 0;
+  } finally {
+    heap[stack_pointer++] = undefined;
+  }
+};
+
 /**
  * @param {any} error
  * @returns {boolean}
@@ -581,7 +594,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,
@@ -1554,14 +1567,6 @@ const IncomingMessageFinalization =
     : new FinalizationRegistry((ptr) => wasm.__wbg_incomingmessage_free(ptr >>> 0, 1));
 
 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;
@@ -1706,10 +1711,12 @@ 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;
@@ -1725,15 +1732,91 @@ 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);
   }
 }
 module.exports.IpcClient = IpcClient;
 
+const IpcClientSubscriptionFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipcclientsubscription_free(ptr >>> 0, 1));
+
+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);
+  }
+}
+module.exports.IpcClientSubscription = IpcClientSubscription;
+
+const IpcCommunicationBackendFinalization =
+  typeof FinalizationRegistry === "undefined"
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry((ptr) => wasm.__wbg_ipccommunicationbackend_free(ptr >>> 0, 1));
+
+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);
+    }
+  }
+}
+module.exports.IpcCommunicationBackend = IpcCommunicationBackend;
+
 const OutgoingMessageFinalization =
   typeof FinalizationRegistry === "undefined"
     ? { register: () => {}, unregister: () => {} }
@@ -2057,14 +2140,6 @@ const ReceiveErrorFinalization =
     : new FinalizationRegistry((ptr) => wasm.__wbg_receiveerror_free(ptr >>> 0, 1));
 
 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;
@@ -2456,11 +2531,6 @@ module.exports.__wbg_headers_9cb51cfd2ac780a4 = function (arg0) {
   return addHeapObject(ret);
 };
 
-module.exports.__wbg_incomingmessage_new = function (arg0) {
-  const ret = IncomingMessage.__wrap(arg0);
-  return addHeapObject(ret);
-};
-
 module.exports.__wbg_info_033d8b8a0838f1d3 = function (arg0, arg1, arg2, arg3) {
   console.info(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 };
@@ -2509,6 +2579,11 @@ module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function (arg0) {
   return ret;
 };
 
+module.exports.__wbg_ipcclientsubscription_new = function (arg0) {
+  const ret = IpcClientSubscription.__wrap(arg0);
+  return addHeapObject(ret);
+};
+
 module.exports.__wbg_isArray_a1eab7e0d067391b = function (arg0) {
   const ret = Array.isArray(getObject(arg0));
   return ret;
@@ -2562,7 +2637,7 @@ module.exports.__wbg_new_23a2665fac83c611 = function (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;
       }
@@ -2704,18 +2779,6 @@ module.exports.__wbg_randomFillSync_ac0988aba3254290 = function () {
   }, arguments);
 };
 
-module.exports.__wbg_receive_9512d555fb8b5130 = function () {
-  return handleError(function (arg0) {
-    const ret = getObject(arg0).receive();
-    return addHeapObject(ret);
-  }, arguments);
-};
-
-module.exports.__wbg_receiveerror_new = function (arg0) {
-  const ret = ReceiveError.__wrap(arg0);
-  return addHeapObject(ret);
-};
-
 module.exports.__wbg_require_60cc747a6bc5215a = function () {
   return handleError(function () {
     const ret = module.require;
@@ -2728,7 +2791,7 @@ module.exports.__wbg_resolve_4851785c9c5f573d = function (arg0) {
   return addHeapObject(ret);
 };
 
-module.exports.__wbg_send_c9eacaae08065b18 = function () {
+module.exports.__wbg_send_9b8fc6bb517867dd = function () {
   return handleError(function (arg0, arg1) {
     const ret = getObject(arg0).send(OutgoingMessage.__wrap(arg1));
     return addHeapObject(ret);
@@ -2936,13 +2999,13 @@ module.exports.__wbindgen_cb_drop = function (arg0) {
   return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper2851 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 662, __wbg_adapter_50);
+module.exports.__wbindgen_closure_wrapper2861 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 658, __wbg_adapter_50);
   return addHeapObject(ret);
 };
 
-module.exports.__wbindgen_closure_wrapper3236 = function (arg0, arg1, arg2) {
-  const ret = makeMutClosure(arg0, arg1, 783, __wbg_adapter_53);
+module.exports.__wbindgen_closure_wrapper3246 = function (arg0, arg1, arg2) {
+  const ret = makeMutClosure(arg0, arg1, 779, __wbg_adapter_53);
   return addHeapObject(ret);
 };
 

package/node/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitwarden/sdk-internal",
-  "version": "0.2.0-main.157",
+  "version": "0.2.0-main.158",
   "license": "GPL-3.0",
   "files": [
     "bitwarden_wasm_internal_bg.js",