chore(release): 0.0.2-develop.1 [skip ci]

## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/hyperswarm-web/compare/v0.0.1...v0.0.2-develop.1) (2023-07-01)

### Reverts

* Revert "*Store copy of activeRelay size to prevent infinite loop" ([cb16b87](cb16b87b73))

.github/workflows/ci.yml

@@ -0,0 +1,13 @@
+name: Build/Publish
+
+on:
+    push:
+        branches:
+            - master
+            - develop
+            - develop-*
+
+jobs:
+    main:
+        uses: lumeweb/github-node-deploy-workflow/.github/workflows/main.yml@master
+        secrets: inherit

.presetterrc.json

@@ -0,0 +1,3 @@
+{
+  "preset": ["@lumeweb/node-library-preset"]
+}

CHANGELOG.md

@@ -0,0 +1,6 @@
+## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/hyperswarm-web/compare/v0.0.1...v0.0.2-develop.1) (2023-07-01)
+
+
+### Reverts
+
+* Revert "*Store copy of activeRelay size to prevent infinite loop" ([cb16b87](https://git.lumeweb.com/LumeWeb/hyperswarm-web/commit/cb16b87b73e104aa2e6ad3dad1b827cb0a85243a))

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Lume Web
+Copyright (c) 2022 Hammer Technologies LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@lumeweb/hyperswarm-web",
+    "type": "module",
+    "version": "0.0.2-develop.1",
+    "main": "lib/index.js",
+    "repository": {
+        "type": "git",
+        "url": "gitea@git.lumeweb.com:LumeWeb/hyperswarm-web.git"
+    },
+    "scripts": {
+        "prepare": "presetter bootstrap",
+        "build": "run build",
+        "semantic-release": "semantic-release"
+    },
+    "devDependencies": {
+        "@lumeweb/node-library-preset": "^0.2.5",
+        "@types/random-number-csprng": "^1.0.0",
+        "@types/ws": "^8.5.5",
+        "async-mutex": "^0.4.0",
+        "esbuild": "^0.14.54",
+        "eventemitter2": "^6.4.9",
+        "hyperswarm": "^4.5.1",
+        "presetter": "*",
+        "prettier": "^2.8.8",
+        "rimraf": "^3.0.2",
+        "typescript": "^4.9.5"
+    },
+    "dependencies": {
+        "@hyperswarm/dht-relay": "^0.4.1",
+        "@lumeweb/kernel-peer-discovery-client": "^0.0.2-develop.1",
+        "@lumeweb/libkernel": "^0.1.0-develop.6",
+        "async-mutex": "^0.4.0",
+        "eventemitter2": "^6.4.9",
+        "hyperswarm": "^4.5.1"
+    },
+    "readme": "ERROR: No README data found!",
+    "files": [
+        "lib/**"
+    ],
+    "publishConfig": {
+        "access": "public"
+    }
+}

src/index.ts

@@ -0,0 +1,271 @@
+// @ts-ignore
+import DhtNode from "@hyperswarm/dht-relay";
+// @ts-ignore
+import Stream from "@hyperswarm/dht-relay/ws";
+import { createClient } from "@lumeweb/kernel-peer-discovery-client";
+import type {
+  PeerDiscoveryClient,
+  Peer,
+} from "@lumeweb/kernel-peer-discovery-client";
+// @ts-ignore
+import Hyperswarm from "hyperswarm";
+import randomNumber from "random-number-csprng";
+import EventEmitter, { OnOptions } from "eventemitter2";
+import { Mutex } from "async-mutex";
+import { logErr } from "@lumeweb/libkernel";
+
+export default class HyperswarmWeb extends EventEmitter.default {
+  private _options: any;
+  private _discovery: PeerDiscoveryClient;
+  private _queuedEmActions: [string, any][] = [];
+  private _connectionMutex: Mutex = new Mutex();
+
+  constructor(opts: any = {}) {
+    super();
+    opts.custodial = false;
+    this._options = opts;
+    this._discovery = createClient();
+  }
+
+  private _relays: Set<string> = new Set();
+
+  get relays(): string[] {
+    return [...this._relays.values()];
+  }
+
+  private _activeRelay: Hyperswarm;
+
+  get activeRelay(): Hyperswarm {
+    return this._activeRelay;
+  }
+
+  private _ready = false;
+
+  get ready(): boolean {
+    return this._ready;
+  }
+
+  init(): Promise<void> {
+    return this.ensureConnection();
+  }
+
+  async connect(pubkey: string, options = {}): Promise<DhtNode> {
+    if (!this._activeRelay) {
+      await this.ensureConnection();
+    }
+
+    return this._activeRelay.connect(pubkey, options);
+  }
+
+  public async addRelay(pubkey: string): Promise<void> {
+    this._relays.add(pubkey);
+  }
+
+  public removeRelay(pubkey: string): boolean {
+    if (!this._relays.has(pubkey)) {
+      return false;
+    }
+
+    this._relays.delete(pubkey);
+
+    return true;
+  }
+
+  public clearRelays(): void {
+    this._relays.clear();
+  }
+
+  on(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): Hyperswarm {
+    return this._processOrQueueAction("on", ...arguments);
+  }
+
+  onSelf(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+    options?: boolean | OnOptions,
+  ): Hyperswarm {
+    return super.on(eventName, listener, options);
+  }
+
+  addListener(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): this {
+    return this.on(eventName, listener);
+  }
+
+  off(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): Hyperswarm {
+    return this._processOrQueueAction("off", ...arguments);
+  }
+
+  offSelf(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): Hyperswarm {
+    return super.off(eventName, listener);
+  }
+
+  removeListener(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): this {
+    return this.off(eventName, listener);
+  }
+
+  emit(eventName: string | symbol, ...args: any[]): boolean {
+    return this._processOrQueueAction("emit", ...arguments);
+  }
+
+  emitSelf(eventName: string | symbol, ...args: any[]): boolean {
+    return super.emit(eventName, ...args);
+  }
+
+  once(eventName: string | symbol, listener: (...args: any[]) => void): this {
+    return this._processOrQueueAction("once", ...arguments);
+  }
+
+  onceSelf(
+    eventName: string | symbol,
+    listener: (...args: any[]) => void,
+  ): this {
+    return this.once(eventName, listener);
+  }
+
+  public join(topic: Uint8Array, opts = {}): void {
+    return this._processOrQueueAction("join", ...arguments);
+  }
+
+  public joinPeer(publicKey: Uint8Array): void {
+    return this._processOrQueueAction("joinPeer", ...arguments);
+  }
+
+  public leave(topic: Uint8Array): void {
+    return this._processOrQueueAction("leave", ...arguments);
+  }
+
+  public leavePeer(publicKey: Uint8Array): void {
+    return this._processOrQueueAction("leavePeer", ...arguments);
+  }
+
+  public status(publicKey: Uint8Array) {
+    return this._activeRelay?.status(publicKey);
+  }
+
+  public topics(): string[] {
+    return this._activeRelay?.topics();
+  }
+
+  public async flush(): Promise<any> {
+    return this._activeRelay?.flush();
+  }
+
+  public async clear(): Promise<any> {
+    return this._activeRelay?.clear();
+  }
+
+  private async ensureConnection(): Promise<any> {
+    await this._connectionMutex.acquire();
+
+    if (this._activeRelay) {
+      this._connectionMutex.release();
+      return;
+    }
+
+    const relays = this.relays;
+
+    if (relays.length > 0) {
+      do {
+        const index =
+          relays.length > 1 ? await randomNumber(0, relays.length - 1) : 0;
+        const relay = relays[index];
+
+        let ret;
+        try {
+          ret = await this._discovery.discover(relay);
+        } catch (e) {
+          logErr(e);
+          relays.splice(index, 1);
+          continue;
+        }
+
+        if (!ret) {
+          relays.splice(index, 1);
+          continue;
+        }
+
+        ret = ret as Peer;
+
+        const connection = `wss://${ret.host}:${ret.port}`;
+
+        if (!(await this.isServerAvailable(connection))) {
+          relays.splice(index, 1);
+          continue;
+        }
+
+        this._activeRelay = new Hyperswarm({
+          dht: new DhtNode(
+            new Stream(true, new WebSocket(connection)),
+            this._options,
+          ),
+          keyPair: this._options.keyPair,
+        });
+
+        this._activeRelay.dht._protocol._stream.once("close", () => {
+          this._activeRelay = undefined;
+          this._ready = false;
+          this.emitSelf("close");
+        });
+      } while (relays.length > 0 && !this._activeRelay);
+    }
+
+    if (!this._activeRelay) {
+      this._connectionMutex.release();
+      throw new Error("Failed to find an available relay");
+    }
+
+    this.emitSelf("init");
+
+    this._processQueuedActions();
+    await this._activeRelay.dht.ready();
+    this._connectionMutex.release();
+
+    this._ready = true;
+    this.emit("ready");
+  }
+
+  private async isServerAvailable(connection: string): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      const ws = new WebSocket(connection);
+      ws.addEventListener("open", () => {
+        ws.close();
+        resolve(true);
+      });
+      ws.addEventListener("error", () => {
+        resolve(false);
+      });
+    });
+  }
+
+  private _processOrQueueAction(method: string, ...args: any[]) {
+    if (this._activeRelay) {
+      return this._activeRelay[method](...args);
+    }
+
+    this._queuedEmActions.push([method, args]);
+    return this;
+  }
+
+  private _processQueuedActions(): void {
+    for (const action of this._queuedEmActions) {
+      this._activeRelay[action[0]](...action[1]);
+    }
+
+    this._queuedEmActions = [];
+  }
+}