@simplito/privmx-webendpoint 2.6.5 → 2.7.1

package/{extra → dist/extra}/__tests__/userEventManager.test.js

@@ -22,9 +22,7 @@ describe("User event manager", () => {
             id: "ctx-1",
             callbacks: [callback],
         });
-        const [subscriptionId] = await userEventsManager.subscribeFor([
-            subscription,
-        ]);
+        const [subscriptionId] = await userEventsManager.subscribeFor([subscription]);
         q.dispatchEvent((0, constants_1.MOCK_CONNECTION_USER_ADDED_EVENT)(subscriptionId));
         await (0, utils_1.waitForNextTick)();
         expect(callback).toHaveBeenCalledTimes(1);
@@ -41,9 +39,7 @@ describe("User event manager", () => {
             id: "ctx-1",
             callbacks: [callback],
         });
-        const [subscriptionId] = await userEventsManager.subscribeFor([
-            subscription,
-        ]);
+        const [subscriptionId] = await userEventsManager.subscribeFor([subscription]);
         await userEventsManager.unsubscribeFrom([subscriptionId]);
         q.dispatchEvent((0, constants_1.MOCK_CONNECTION_USER_STATUS_EVENT)(subscriptionId));
         await (0, utils_1.waitForNextTick)();

package/{extra → dist/extra}/__tests__/utils.test.js

@@ -1,51 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-describe('Serialization Helpers', () => {
-    test('serializeObject should correctly serialize objects', () => {
-        const obj = { key: 'value', num: 42 };
+describe("Serialization Helpers", () => {
+    test("serializeObject should correctly serialize objects", () => {
+        const obj = { key: "value", num: 42 };
         const result = (0, utils_1.serializeObject)(obj);
         expect(result).toBeInstanceOf(Uint8Array);
         expect((0, utils_1.uint8ToStr)(result)).toBe(JSON.stringify(obj));
     });
-    test('serializeObject should throw an error for invalid inputs', () => {
+    test("serializeObject should throw an error for invalid inputs", () => {
         expect(() => (0, utils_1.serializeObject)(null)).toThrow(TypeError);
-        expect(() => (0, utils_1.serializeObject)('string')).toThrow(TypeError);
+        expect(() => (0, utils_1.serializeObject)("string")).toThrow(TypeError);
     });
-    test('deserializeObject should correctly deserialize Uint8Array', () => {
-        const obj = { key: 'value', num: 42 };
+    test("deserializeObject should correctly deserialize Uint8Array", () => {
+        const obj = { key: "value", num: 42 };
         const serialized = (0, utils_1.strToUint8)(JSON.stringify(obj));
         const result = (0, utils_1.deserializeObject)(serialized);
         expect(result).toEqual(obj);
     });
-    test('deserializeObject should handle empty input gracefully', () => {
+    test("deserializeObject should handle empty input gracefully", () => {
         const empty = new Uint8Array();
         const result = (0, utils_1.deserializeObject)(empty);
         expect(result).toEqual({});
     });
-    test('deserializeObject should throw an error for invalid inputs', () => {
+    test("deserializeObject should throw an error for invalid inputs", () => {
         expect(() => (0, utils_1.deserializeObject)(null)).toThrow(TypeError);
-        expect(() => (0, utils_1.deserializeObject)('string')).toThrow(TypeError);
-        const invalidJson = (0, utils_1.strToUint8)('{ key: value }');
+        expect(() => (0, utils_1.deserializeObject)("string")).toThrow(TypeError);
+        const invalidJson = (0, utils_1.strToUint8)("{ key: value }");
         expect(() => (0, utils_1.deserializeObject)(invalidJson)).toThrow(SyntaxError);
     });
-    test('uint8ToStr should correctly convert Uint8Array to string', () => {
-        const str = 'Hello, world!';
+    test("uint8ToStr should correctly convert Uint8Array to string", () => {
+        const str = "Hello, world!";
         const arr = (0, utils_1.strToUint8)(str);
         const result = (0, utils_1.uint8ToStr)(arr);
         expect(result).toBe(str);
     });
-    test('uint8ToStr should throw an error for invalid inputs', () => {
+    test("uint8ToStr should throw an error for invalid inputs", () => {
         expect(() => (0, utils_1.uint8ToStr)(null)).toThrow(TypeError);
-        expect(() => (0, utils_1.uint8ToStr)('string')).toThrow(TypeError);
+        expect(() => (0, utils_1.uint8ToStr)("string")).toThrow(TypeError);
     });
-    test('strToUint8 should correctly convert string to Uint8Array', () => {
-        const str = 'Hello, world!';
+    test("strToUint8 should correctly convert string to Uint8Array", () => {
+        const str = "Hello, world!";
         const result = (0, utils_1.strToUint8)(str);
         expect(result).toBeInstanceOf(Uint8Array);
         expect((0, utils_1.uint8ToStr)(result)).toBe(str);
     });
-    test('strToUint8 should throw an error for invalid inputs', () => {
+    test("strToUint8 should throw an error for invalid inputs", () => {
         expect(() => (0, utils_1.strToUint8)(null)).toThrow(TypeError);
         expect(() => (0, utils_1.strToUint8)(42)).toThrow(TypeError);
     });

package/{extra → dist/extra}/events.js

@@ -5,12 +5,27 @@ const subscriptions_1 = require("./subscriptions");
 const managers_1 = require("./managers");
 function normalizeConnectionEvent(e) {
     switch (e.type) {
-        case 'libDisconnected':
-            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_DISCONNECTED]}`] };
-        case 'libPlatformDisconnected':
-            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_PLATFORM_DISCONNECTED]}`] };
-        case 'libConnected':
-            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED]}`] };
+        case "libDisconnected":
+            return {
+                ...e,
+                subscriptions: [
+                    `${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_DISCONNECTED]}`,
+                ],
+            };
+        case "libPlatformDisconnected":
+            return {
+                ...e,
+                subscriptions: [
+                    `${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_PLATFORM_DISCONNECTED]}`,
+                ],
+            };
+        case "libConnected":
+            return {
+                ...e,
+                subscriptions: [
+                    `${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED]}`,
+                ],
+            };
         default:
             return e;
     }
@@ -19,14 +34,16 @@ class EventManager {
     _isEventLoopRunning = false;
     dispatchers = [];
     eventsQueue = null;
-    constructor() {
-    }
+    constructor() { }
     listenForEvents() {
         if (this.eventsQueue) {
-            this.eventsQueue.waitEvent().then((event) => {
+            this.eventsQueue
+                .waitEvent()
+                .then((event) => {
                 this.onEvent(event);
                 this.listenForEvents();
-            }).catch(() => {
+            })
+                .catch(() => {
                 this.listenForEvents();
             });
         }
@@ -35,12 +52,15 @@ class EventManager {
         const manager = new EventManager();
         manager.eventsQueue = eventQueue;
         manager._isEventLoopRunning = true;
-        manager.eventsQueue.waitEvent().then((event) => {
+        manager.eventsQueue
+            .waitEvent()
+            .then((event) => {
             if (!manager._isEventLoopRunning)
                 return;
             manager.onEvent(event);
             manager.listenForEvents();
-        }).catch(() => {
+        })
+            .catch(() => {
             manager.listenForEvents();
         });
         return manager;

package/{extra → dist/extra}/files.d.ts

@@ -1,7 +1,7 @@
 /**
  * Represents a stream reader for reading a file in chunks.
  */
-import { InboxApi, StoreApi } from '..';
+import { InboxApi, StoreApi } from "..";
 export declare const FILE_DEFAULT_CHUNK_SIZE = 1048576;
 export declare class StreamReader {
     private _handle;
@@ -24,7 +24,7 @@ export declare class StreamReader {
      */
     [Symbol.asyncIterator](): AsyncGenerator<readonly [Uint8Array<ArrayBufferLike>, number], void, unknown>;
     readNextChunk(): Promise<Uint8Array>;
-    getFileContent(): Promise<Uint8Array<ArrayBuffer>>;
+    getFileContent(): Promise<Uint8Array>;
     /**
      * Aborts the reading process and closes the file handle.
      *
@@ -58,14 +58,14 @@ export declare class FileUploader {
      * @param {StoreApi} api {@link StoreApi `StoreApi`} instance
      */
     constructor(file: File, api: FileContainerApi);
-    static uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta }: {
+    static uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta, }: {
         storeId: string;
         file: File;
         storeApi: StoreApi;
         publicMeta?: Uint8Array;
         privateMeta?: Uint8Array;
     }): Promise<FileUploader>;
-    static uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload }: {
+    static uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload, }: {
         inboxHandle: number;
         preparedFileUpload: {
             file: File;
@@ -73,7 +73,7 @@ export declare class FileUploader {
         };
         inboxApi: InboxApi;
     }): Promise<FileUploader>;
-    static prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta }: {
+    static prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta, }: {
         inboxApi: InboxApi;
         file: File;
         publicMeta?: Uint8Array;

package/{extra → dist/extra}/files.js

@@ -94,10 +94,10 @@ class FileUploader {
         this._api = api;
         this._reader = file.stream().getReader();
     }
-    static async uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta }) {
+    static async uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta, }) {
         const meta = {
             publicMeta: publicMeta || new Uint8Array(),
-            privateMeta: privateMeta || new Uint8Array()
+            privateMeta: privateMeta || new Uint8Array(),
         };
         const handle = await storeApi.createFile(storeId, meta.publicMeta, meta.privateMeta, file.size);
         const streamer = new FileUploader(file, {
@@ -106,25 +106,25 @@ class FileUploader {
             },
             writeToFile(chunk) {
                 return storeApi.writeToFile(handle, chunk);
-            }
+            },
         });
         return streamer;
     }
-    static async uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload }) {
+    static async uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload, }) {
         const streamer = new FileUploader(preparedFileUpload.file, {
             closeFile() {
-                return Promise.resolve('');
+                return Promise.resolve("");
             },
             writeToFile(chunk) {
                 return inboxApi.writeToFile(inboxHandle, preparedFileUpload.handle, chunk);
-            }
+            },
         });
         return streamer;
     }
-    static async prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta }) {
+    static async prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta, }) {
         const meta = {
             publicMeta: publicMeta || new Uint8Array(),
-            privateMeta: privateMeta || new Uint8Array()
+            privateMeta: privateMeta || new Uint8Array(),
         };
         const handle = await inboxApi.createFileHandle(meta.publicMeta, meta.privateMeta, file.size);
         return { file: file, handle };
@@ -187,12 +187,12 @@ exports.FileUploader = FileUploader;
 async function downloadFile(api, fileId, targetFileName) {
     const filename = targetFileName || fileId;
     const apiReader = await StreamReader.readFile(api, fileId);
-    if ('showSaveFilePicker' in window && window.isSecureContext) {
+    if ("showSaveFilePicker" in window && window.isSecureContext) {
         //@ts-ignore
         const systemHandle = (await window.showSaveFilePicker({
             id: 0,
             suggestedName: filename,
-            startIn: 'downloads'
+            startIn: "downloads",
         }));
         const accessHandle = await systemHandle.createWritable();
         for await (const [file] of apiReader) {
@@ -202,7 +202,7 @@ async function downloadFile(api, fileId, targetFileName) {
     }
     else {
         const fileBuffer = await apiReader.getFileContent();
-        const anchor = document.createElement('a');
+        const anchor = document.createElement("a");
         const reader = new FileReader();
         reader.onload = (e) => {
             if (!e.target)

package/{extra → dist/extra}/generics.d.ts

@@ -1,4 +1,4 @@
-import { Types } from '..';
+import { Types } from "..";
 export interface CreateContainerPayload {
     contextId: string;
     users: Types.UserWithPubKey[];

package/{extra → dist/extra}/inbox.d.ts

@@ -1,4 +1,4 @@
-import { InboxApi } from '..';
+import { InboxApi } from "..";
 /**
  * Represents payload that is sent to an Inbox.
  */

package/{extra → dist/extra}/inbox.js

@@ -19,7 +19,7 @@ async function sendEntry(inboxApi, inboxId, payload) {
                 inboxApi,
                 file: file.content,
                 privateMeta: file.privateMeta,
-                publicMeta: file.publicMeta
+                publicMeta: file.publicMeta,
             });
         }))
         : [];
@@ -27,7 +27,7 @@ async function sendEntry(inboxApi, inboxId, payload) {
     const uploaders = await Promise.all(preparedFiles.map((file) => files_1.FileUploader.uploadInboxFile({
         inboxApi,
         inboxHandle: inboxEntryHandle,
-        preparedFileUpload: file
+        preparedFileUpload: file,
     })));
     await Promise.all(uploaders.map((uploader) => uploader.uploadFileContent()));
     await inboxApi.sendEntry(inboxEntryHandle);

package/{extra → dist/extra}/index.d.ts

@@ -1,10 +1,10 @@
-import * as Files from './files';
-import * as Utils from './utils';
-import * as Generics from './generics';
-import * as Inboxes from './inbox';
-import { FileUploader, StreamReader, downloadFile } from './files';
-import { PrivmxClient } from './PrivmxClient';
-import { PublicConnection } from './PublicConnection';
+import * as Files from "./files";
+import * as Utils from "./utils";
+import * as Generics from "./generics";
+import * as Inboxes from "./inbox";
+import { FileUploader, StreamReader, downloadFile } from "./files";
+import { PrivmxClient } from "./PrivmxClient";
+import { PublicConnection } from "./PublicConnection";
 export { EventManager } from "./events";
 export { createInboxSubscription, createThreadSubscription, createConnectionSubscription, createUserEventSubscription, createKvdbSubscription, createStoreSubscription, createEventSubscription, EventCallback, Subscription, ConnectionStatusEventType, ConnectionSubscription, } from "./subscriptions";
 export { Files, Inboxes, Utils, Generics, FileUploader, downloadFile, StreamReader, PrivmxClient, PublicConnection, };

package/{extra → dist/extra}/managers.js

@@ -44,7 +44,7 @@ class BaseEventDispatcherManager {
     async unsubscribeFrom(subscriptionsId) {
         const knownIds = [];
         for (const subscriptionId of subscriptionsId) {
-            for (const [key, callbackSubscription,] of this._listenersSymbols.entries()) {
+            for (const [key, callbackSubscription] of this._listenersSymbols.entries()) {
                 if (callbackSubscription === subscriptionId) {
                     knownIds.push(subscriptionId);
                     this.unregisterCallback(key);

package/{extra → dist/extra}/utils.js

@@ -10,8 +10,8 @@ exports.strToUint8 = strToUint8;
  * @returns {Uint8Array} object serialized to `Uint8Array`
  */
 function serializeObject(object) {
-    if (object === null || typeof object !== 'object') {
-        throw new TypeError('Input must be a non-null object.');
+    if (object === null || typeof object !== "object") {
+        throw new TypeError("Input must be a non-null object.");
     }
     const encoder = new TextEncoder();
     const parsed = JSON.stringify(object);
@@ -24,11 +24,11 @@ function serializeObject(object) {
  */
 function deserializeObject(data) {
     if (!(data instanceof Uint8Array)) {
-        throw new TypeError('Input must be a Uint8Array.');
+        throw new TypeError("Input must be a Uint8Array.");
     }
     const decoder = new TextDecoder();
     const decodedData = decoder.decode(data);
-    if (decodedData.trim() === '') {
+    if (decodedData.trim() === "") {
         return {};
     }
     try {
@@ -36,10 +36,10 @@ function deserializeObject(data) {
     }
     catch (error) {
         if (error instanceof SyntaxError) {
-            throw new SyntaxError('Failed to parse JSON: ' + error.message);
+            throw new SyntaxError("Failed to parse JSON: " + error.message);
         }
         else {
-            throw new Error('An unexpected error occurred: ' + String(error));
+            throw new Error("An unexpected error occurred: " + String(error));
         }
     }
 }
@@ -50,7 +50,7 @@ function deserializeObject(data) {
  */
 function uint8ToStr(arr) {
     if (!(arr instanceof Uint8Array)) {
-        throw new TypeError('Input must be a Uint8Array.');
+        throw new TypeError("Input must be a Uint8Array.");
     }
     return new TextDecoder().decode(arr);
 }
@@ -60,8 +60,8 @@ function uint8ToStr(arr) {
  * @returns {Uint8Array} The resulting Uint8Array
  */
 function strToUint8(text) {
-    if (typeof text !== 'string') {
-        throw new TypeError('Input must be a string.');
+    if (typeof text !== "string") {
+        throw new TypeError("Input must be a string.");
     }
     return new TextEncoder().encode(text);
 }

package/{index.d.ts → dist/index.d.ts}

@@ -9,6 +9,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 import { EndpointFactory } from "./service/EndpointFactory";
-import { EventQueue, StoreApi, ThreadApi, InboxApi, KvdbApi, Connection, CryptoApi, BaseApi, ExtKey, EventApi } from "./service";
+import { NativeError } from "./api/NativeError";
+import { EventQueue, StoreApi, ThreadApi, InboxApi, KvdbApi, Connection, CryptoApi, BaseApi, StreamApi, ExtKey, EventApi } from "./service";
 import * as Types from "./Types";
-export { EndpointFactory as Endpoint, Types, EventQueue, StoreApi, ThreadApi, InboxApi, KvdbApi, CryptoApi, Connection, BaseApi, ExtKey, EventApi };
+export { EndpointFactory as Endpoint, NativeError, Types, EventQueue, StoreApi, ThreadApi, InboxApi, KvdbApi, CryptoApi, StreamApi, Connection, BaseApi, ExtKey, EventApi, };

package/{index.js → dist/index.js}

@@ -10,9 +10,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventApi = exports.ExtKey = exports.BaseApi = exports.Connection = exports.CryptoApi = exports.KvdbApi = exports.InboxApi = exports.ThreadApi = exports.StoreApi = exports.EventQueue = exports.Types = exports.Endpoint = void 0;
+exports.EventApi = exports.ExtKey = exports.BaseApi = exports.Connection = exports.StreamApi = exports.CryptoApi = exports.KvdbApi = exports.InboxApi = exports.ThreadApi = exports.StoreApi = exports.EventQueue = exports.Types = exports.NativeError = exports.Endpoint = void 0;
 const EndpointFactory_1 = require("./service/EndpointFactory");
 Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return EndpointFactory_1.EndpointFactory; } });
+const NativeError_1 = require("./api/NativeError");
+Object.defineProperty(exports, "NativeError", { enumerable: true, get: function () { return NativeError_1.NativeError; } });
 const service_1 = require("./service");
 Object.defineProperty(exports, "EventQueue", { enumerable: true, get: function () { return service_1.EventQueue; } });
 Object.defineProperty(exports, "StoreApi", { enumerable: true, get: function () { return service_1.StoreApi; } });
@@ -22,6 +24,7 @@ Object.defineProperty(exports, "KvdbApi", { enumerable: true, get: function () {
 Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return service_1.Connection; } });
 Object.defineProperty(exports, "CryptoApi", { enumerable: true, get: function () { return service_1.CryptoApi; } });
 Object.defineProperty(exports, "BaseApi", { enumerable: true, get: function () { return service_1.BaseApi; } });
+Object.defineProperty(exports, "StreamApi", { enumerable: true, get: function () { return service_1.StreamApi; } });
 Object.defineProperty(exports, "ExtKey", { enumerable: true, get: function () { return service_1.ExtKey; } });
 Object.defineProperty(exports, "EventApi", { enumerable: true, get: function () { return service_1.EventApi; } });
 const Types = require("./Types");

package/{service → dist/service}/Connection.js

@@ -76,7 +76,11 @@ class Connection extends BaseApi_1.BaseApi {
      * @param {string} selectorId ID of the selector
      */
     async buildSubscriptionQuery(eventType, selectorType, selectorId) {
-        return this.native.buildSubscriptionQuery(this.servicePtr, [eventType, selectorType, selectorId]);
+        return this.native.buildSubscriptionQuery(this.servicePtr, [
+            eventType,
+            selectorType,
+            selectorId,
+        ]);
     }
     /**
      * Disconnects from the Platform backend.
@@ -101,11 +105,14 @@ class Connection extends BaseApi_1.BaseApi {
         return this.native.setUserVerifier(this.servicePtr, [this.servicePtr, verifier]);
     }
     async freeApis() {
-        for (const apiId in this.apisRefs) {
-            if (this.nativeApisDeps[apiId]) {
-                await this.nativeApisDeps[apiId].deleteApi(this.apisRefs[apiId]._apiServicePtr);
-            }
-        }
+        console.warn("freeApis disabled for debugging purposes. Please re-enable");
+        // for (const apiId in this.apisRefs) {
+        //   if (this.nativeApisDeps[apiId]) {
+        //     await this.nativeApisDeps[apiId].deleteApi(
+        //       this.apisRefs[apiId]._apiServicePtr
+        //     );
+        //   }
+        // }
     }
 }
 exports.Connection = Connection;

package/{service → dist/service}/CryptoApi.js

@@ -93,10 +93,7 @@ class CryptoApi extends BaseApi_1.BaseApi {
      * @returns {Uint8Array} encrypted data buffer
      */
     async encryptDataSymmetric(data, symmetricKey) {
-        return this.native.encryptDataSymmetric(this.servicePtr, [
-            data,
-            symmetricKey,
-        ]);
+        return this.native.encryptDataSymmetric(this.servicePtr, [data, symmetricKey]);
     }
     /**
      * Decrypts buffer with a given key using AES.
@@ -106,10 +103,7 @@ class CryptoApi extends BaseApi_1.BaseApi {
      * @returns {Uint8Array} plain (decrypted) data buffer
      */
     async decryptDataSymmetric(data, symmetricKey) {
-        return this.native.decryptDataSymmetric(this.servicePtr, [
-            data,
-            symmetricKey,
-        ]);
+        return this.native.decryptDataSymmetric(this.servicePtr, [data, symmetricKey]);
     }
     /**
      * Converts given private key in PEM format to its WIF format.

package/{service → dist/service}/EndpointFactory.d.ts

@@ -16,6 +16,7 @@ import { EventQueue } from "./EventQueue";
 import { InboxApi } from "./InboxApi";
 import { KvdbApi } from "./KvdbApi";
 import { StoreApi } from "./StoreApi";
+import { StreamApi } from "./StreamApi";
 import { ThreadApi } from "./ThreadApi";
 /**
  * Contains static factory methods - generators for Connection and APIs.
@@ -23,6 +24,7 @@ import { ThreadApi } from "./ThreadApi";
 export declare class EndpointFactory {
     private static api;
     private static eventQueueInstance;
+    private static assetsBasePath;
     /**
      * Load the Endpoint's WASM assets and initialize the Endpoint library.
      *
@@ -107,4 +109,13 @@ export declare class EndpointFactory {
      * @returns {EventApi} instance of EventApi
      */
     static createEventApi(connection: Connection): Promise<EventApi>;
+    /**
+     * Creates an instance of the Stream API.
+     *
+     * @param {Connection} connection instance of Connection
+     * @param {EventApi} eventApi instance of EventApi
+     * @param {StoreApi} storeApi instance of StoreApi
+     * @returns {StreamApi} instance of StreamApi
+     */
+    static createStreamApi(connection: Connection, eventApi: EventApi): Promise<StreamApi>;
 }

package/{service → dist/service}/EndpointFactory.js

@@ -20,8 +20,10 @@ const EventQueueNative_1 = require("../api/EventQueueNative");
 const InboxApiNative_1 = require("../api/InboxApiNative");
 const KvdbApiNative_1 = require("../api/KvdbApiNative");
 const StoreApiNative_1 = require("../api/StoreApiNative");
+const StreamApiNative_1 = require("../api/StreamApiNative");
 const ThreadApiNative_1 = require("../api/ThreadApiNative");
 const FinalizationHelper_1 = require("../FinalizationHelper");
+const WebRtcClient_1 = require("../webStreams/WebRtcClient");
 const Connection_1 = require("./Connection");
 const CryptoApi_1 = require("./CryptoApi");
 const EventApi_1 = require("./EventApi");
@@ -29,6 +31,7 @@ const EventQueue_1 = require("./EventQueue");
 const InboxApi_1 = require("./InboxApi");
 const KvdbApi_1 = require("./KvdbApi");
 const StoreApi_1 = require("./StoreApi");
+const StreamApi_1 = require("./StreamApi");
 const ThreadApi_1 = require("./ThreadApi");
 /**
  * Contains static factory methods - generators for Connection and APIs.
@@ -36,13 +39,16 @@ const ThreadApi_1 = require("./ThreadApi");
 class EndpointFactory {
     static api;
     static eventQueueInstance;
+    static assetsBasePath;
     /**
      * Load the Endpoint's WASM assets and initialize the Endpoint library.
      *
      * @param {string} [assetsBasePath] base path/url to the Endpoint's WebAssembly assets (like: endpoint-wasm-module.js, driver-web-context.js and others)
      */
     static async setup(assetsBasePath) {
-        const basePath = assetsBasePath || document.currentScript.src.split("/").slice(0, -1).join("/");
+        const basePath = assetsBasePath ||
+            document.currentScript.src.split("/").slice(0, -1).join("/");
+        this.assetsBasePath = basePath;
         const assets = ["driver-web-context.js", "endpoint-wasm-module.js"];
         for (const asset of assets) {
             await this.loadScript(basePath + "/" + asset);
@@ -51,10 +57,10 @@ class EndpointFactory {
         EndpointFactory.init(lib);
     }
     static async loadScript(url) {
-        return new Promise(resolve => {
-            const head = document.getElementsByTagName('head')[0];
-            const script = document.createElement('script');
-            script.type = 'text/javascript';
+        return new Promise((resolve) => {
+            const head = document.getElementsByTagName("head")[0];
+            const script = document.createElement("script");
+            script.type = "text/javascript";
             script.src = url;
             script.onload = () => {
                 resolve();
@@ -86,7 +92,7 @@ class EndpointFactory {
     static generateDefaultPKIVerificationOptions() {
         return {
             bridgeInstanceId: undefined,
-            bridgePubKey: undefined
+            bridgePubKey: undefined,
         };
     }
     /**
@@ -101,7 +107,12 @@ class EndpointFactory {
     static async connect(userPrivKey, solutionId, bridgeUrl, verificationOptions) {
         const nativeApi = new ConnectionNative_1.ConnectionNative(this.api);
         const ptr = await nativeApi.newConnection();
-        await nativeApi.connect(ptr, [userPrivKey, solutionId, bridgeUrl, verificationOptions || this.generateDefaultPKIVerificationOptions()]);
+        await nativeApi.connect(ptr, [
+            userPrivKey,
+            solutionId,
+            bridgeUrl,
+            verificationOptions || this.generateDefaultPKIVerificationOptions(),
+        ]);
         return new Connection_1.Connection(nativeApi, ptr);
     }
     /**
@@ -115,7 +126,11 @@ class EndpointFactory {
     static async connectPublic(solutionId, bridgeUrl, verificationOptions) {
         const nativeApi = new ConnectionNative_1.ConnectionNative(this.api);
         const ptr = await nativeApi.newConnection();
-        await nativeApi.connectPublic(ptr, [solutionId, bridgeUrl, verificationOptions || this.generateDefaultPKIVerificationOptions()]);
+        await nativeApi.connectPublic(ptr, [
+            solutionId,
+            bridgeUrl,
+            verificationOptions || this.generateDefaultPKIVerificationOptions(),
+        ]);
         return new Connection_1.Connection(nativeApi, ptr);
     }
     /**
@@ -168,9 +183,9 @@ class EndpointFactory {
         }
         const nativeApi = new InboxApiNative_1.InboxApiNative(this.api);
         const ptr = await nativeApi.newApi(connection.servicePtr, threadApi.servicePtr, storeApi.servicePtr);
+        await nativeApi.create(ptr, []);
         connection.apisRefs["inboxes"] = { _apiServicePtr: ptr };
         connection.nativeApisDeps["inboxes"] = nativeApi;
-        await nativeApi.create(ptr, []);
         return new InboxApi_1.InboxApi(nativeApi, ptr);
     }
     /**
@@ -215,10 +230,30 @@ class EndpointFactory {
         }
         const nativeApi = new EventApiNative_1.EventApiNative(this.api);
         const ptr = await nativeApi.newApi(connection.servicePtr);
+        await nativeApi.create(ptr, []);
         connection.apisRefs["events"] = { _apiServicePtr: ptr };
         connection.nativeApisDeps["events"] = nativeApi;
-        await nativeApi.create(ptr, []);
         return new EventApi_1.EventApi(nativeApi, ptr);
     }
+    /**
+     * Creates an instance of the Stream API.
+     *
+     * @param {Connection} connection instance of Connection
+     * @param {EventApi} eventApi instance of EventApi
+     * @param {StoreApi} storeApi instance of StoreApi
+     * @returns {StreamApi} instance of StreamApi
+     */
+    static async createStreamApi(connection, eventApi) {
+        if ("streams" in connection.apisRefs) {
+            throw new Error("StreamApi already registered for given connection.");
+        }
+        const webRtcClient = new WebRtcClient_1.WebRtcClient(this.assetsBasePath);
+        const nativeApi = new StreamApiNative_1.StreamApiNative(this.api, webRtcClient);
+        const ptr = await nativeApi.newApi(connection.servicePtr, eventApi.servicePtr);
+        await nativeApi.create(ptr, []);
+        connection.apisRefs["streams"] = { _apiServicePtr: ptr };
+        connection.nativeApisDeps["streams"] = nativeApi;
+        return new StreamApi_1.StreamApi(nativeApi, ptr, webRtcClient);
+    }
 }
 exports.EndpointFactory = EndpointFactory;