@leofcoin/peernet 1.1.78 → 1.1.80

package/exports/browser/{browser-P2HFBJsB.js → browser-DQJ6xf_F.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './peernet-x3p3hKA5.js';
+import { g as getDefaultExportFromCjs } from './identity-CQ_ieRiz.js';
 
 var global;
 var hasRequiredGlobal;
@@ -62,7 +62,7 @@ var author = "Brian McKelvey <theturtle32@gmail.com> (https://github.com/theturt
 var contributors = [
 	"Iñaki Baz Castillo <ibc@aliax.net> (http://dev.sipdoc.net)"
 ];
-var version$1 = "1.0.34";
+var version$1 = "1.0.35";
 var repository = {
 	type: "git",
 	url: "https://github.com/theturtle32/WebSocket-Node.git"
@@ -74,7 +74,7 @@ var engines = {
 var dependencies = {
 	bufferutil: "^4.0.1",
 	debug: "^2.2.0",
-	"es5-ext": "^0.10.50",
+	"es5-ext": "^0.10.63",
 	"typedarray-to-buffer": "^3.1.5",
 	"utf-8-validate": "^5.0.2",
 	yaeti: "^0.0.6"

package/exports/browser/browser-store.js

@@ -1,22 +1,57 @@
-import { K as KeyPath, a as KeyValue } from './value-wzPYMxsX.js';
+import { K as KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
+if (!globalThis.DEBUG) {
+  let DEBUG = [];
+  if (globalThis.localStorage) {
+    DEBUG = globalThis.localStorage.getItem('DEBUG');
+    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+  }
+}
+
+const debug$1 = (target, text) => {
+  if (!globalThis.DEBUG && globalThis.DEBUG.length === 0) return;
+  if (
+    globalThis.DEBUG === 'true' ||
+    globalThis.DEBUG === true ||
+    globalThis.DEBUG?.indexOf(target) !== -1 ||
+    globalThis.DEBUG?.indexOf('*') !== -1 ||
+    globalThis.DEBUG?.indexOf(target.split('/')[0]) !== -1
+  )
+    if (text) console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+    else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+};
+
+if (!globalThis.debug) {
+  globalThis.debug = debug$1;
+
+  globalThis.createDebugger = (target) => (text) => debug$1(target, text);
+}
+
+const debug = globalThis.createDebugger('leofcoin/storage');
 const opfsRoot = await navigator.storage.getDirectory();
 class BrowerStore {
     db;
     name;
     root;
+    inWorker;
     version;
-    async init(name = 'storage', root = '.leofcoin', version = '1') {
-        console.log('init');
+    busy;
+    queue = [];
+    async init(name = 'storage', root = '.leofcoin', version = '1', inWorker = false) {
         this.version = version;
         this.name = name;
         this.root = opfsRoot;
-        console.log(`${this.root}/${this.name}`);
+        this.inWorker = inWorker;
         let directoryHandle;
         try {
             directoryHandle = await opfsRoot.getDirectoryHandle(this.name, {
                 create: true
             });
+            if (inWorker) {
+                // it's in a worker so that's why typings invalid?
+                // @ts-ignore
+                directoryHandle = await directoryHandle.createSyncAccessHandle();
+            }
         }
         catch (error) {
             console.error(error);
@@ -35,6 +70,7 @@ class BrowerStore {
         return value.uint8Array;
     }
     async has(key) {
+        debug(`has ${this.toKeyPath(key)}`);
         try {
             await this.db.getFileHandle(this.toKeyPath(key));
             return true;
@@ -44,39 +80,149 @@ class BrowerStore {
         }
     }
     async get(key) {
-        const handle = await this.db.getFileHandle(this.toKeyPath(key));
-        const file = await handle.getFile();
-        return new Uint8Array(await file.arrayBuffer());
+        let promiseResolve;
+        let promiseReject;
+        let result = new Promise((resolve, reject) => {
+            promiseResolve = resolve;
+            promiseReject = reject;
+        });
+        const promise = () => new Promise(async (resolve, reject) => {
+            debug(`get ${this.toKeyPath(key)}`);
+            setTimeout(async () => {
+                try {
+                    let handle = await this.db.getFileHandle(this.toKeyPath(key));
+                    let readBuffer;
+                    if (this.inWorker) {
+                        // it's in a worker so that's why typings invalid?
+                        // @ts-ignore
+                        handle = await handle.createSyncAccessHandle();
+                        // @ts-ignore
+                        const fileSize = handle.getSize();
+                        // Read file content to a buffer.
+                        const buffer = new DataView(new ArrayBuffer(fileSize));
+                        // @ts-ignore
+                        readBuffer = handle.read(buffer, { at: 0 });
+                        // @ts-ignore
+                        handle.close();
+                    }
+                    else {
+                        const file = await handle.getFile();
+                        readBuffer = await file.arrayBuffer();
+                    }
+                    this.runQueue();
+                    promiseResolve(new Uint8Array(readBuffer));
+                    resolve(new Uint8Array(readBuffer));
+                }
+                catch (error) {
+                    promiseReject(error);
+                    resolve(false);
+                }
+            }, 1);
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return result;
     }
     async put(key, value) {
-        const handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
-        const writeable = handle.createWritable();
-        (await writeable).write(this.toKeyValue(value));
-        (await writeable).close();
+        let promiseResolve;
+        let promiseReject;
+        let result = new Promise((resolve, reject) => {
+            promiseResolve = resolve;
+            promiseReject = reject;
+        });
+        const promise = () => new Promise(async (resolve, reject) => {
+            debug(`put ${this.toKeyPath(key)}`);
+            setTimeout(async () => {
+                try {
+                    let handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
+                    let writeable;
+                    if (this.inWorker) {
+                        // it's in a worker so that's why typings invalid?
+                        // @ts-ignore
+                        writeable = await handle.createSyncAccessHandle();
+                    }
+                    else {
+                        writeable = await handle.createWritable();
+                    }
+                    ;
+                    (await writeable).write(this.toKeyValue(value));
+                    (await writeable).close();
+                    this.runQueue();
+                    resolve(true);
+                    promiseResolve(true);
+                }
+                catch (error) {
+                    promiseReject(error);
+                    resolve(false);
+                }
+            }, 5);
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return result;
+    }
+    async runQueue() {
+        if (this.queue.length > 0 && !this.busy) {
+            this.busy = true;
+            const next = this.queue.shift();
+            await next();
+            this.busy = false;
+            return this.runQueue();
+        }
+        else if (this.queue.length === 0 && this.busy) {
+            this.busy = false;
+        }
     }
     async delete(key) {
-        return this.db.removeEntry(this.toKeyPath(key));
+        debug(`delete ${this.toKeyPath(key)}`);
+        return new Promise(async (resolve, reject) => {
+            try {
+                await this.db.getFileHandle(`${this.toKeyPath(key)}.crswap`);
+                setTimeout(() => resolve(this.delete(key)), 5);
+            }
+            catch (error) {
+                try {
+                    await this.db.removeEntry(this.toKeyPath(key));
+                    resolve(true);
+                }
+                catch (error) {
+                    if (error.name === 'NoModificationAllowedError')
+                        setTimeout(() => resolve(this.delete(key)), 5);
+                    else
+                        reject(error);
+                }
+            }
+        });
     }
     async clear() {
         for await (const key of this.db.keys()) {
-            await this.db.removeEntry(key);
+            debug(`clear ${this.toKeyPath(key)}`);
+            await this.delete(key);
+        }
+    }
+    async values() {
+        let values = [];
+        for await (const cursor of this.db.values()) {
+            // huh? Outdated typings?
+            // @ts-ignore
+            values.push(cursor.getFile());
         }
+        values = await Promise.all(values);
+        return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
     }
-    async values(limit = -1) {
-        const values = [];
+    async size() {
+        let size = 0;
         for await (const cursor of this.db.values()) {
-            values.push(cursor);
-            if (limit && values.length === limit)
-                return values;
+            // huh? Outdated typings?
+            // @ts-ignore
+            size += (await cursor.getFile()).size;
         }
-        return values;
+        return size;
     }
-    async keys(limit = -1) {
+    async keys() {
         const keys = [];
         for await (const cursor of this.db.keys()) {
             keys.push(cursor);
-            if (limit && keys.length === limit)
-                return keys;
         }
         return keys;
     }

package/exports/browser/{client-5mPwJbpC.js → client-Depp28gl.js}

@@ -1,5 +1,6 @@
-import { L as LittlePubSub } from './peernet-x3p3hKA5.js';
-import './value-wzPYMxsX.js';
+import { L as LittlePubSub } from './peernet-B7TZP-Wg.js';
+import './identity-CQ_ieRiz.js';
+import './value-C3vAp-wb.js';
 
 class Api {
     _pubsub;
@@ -188,14 +189,17 @@ class SocketRequestClient {
     #options;
     #protocol;
     #url;
+    #experimentalWebsocket = false;
     constructor(url, protocol, options) {
-        let { retry, timeout, times } = options || {};
+        let { retry, timeout, times, experimentalWebsocket } = options || {};
         if (retry !== undefined)
             this.#retry = retry;
         if (timeout !== undefined)
             this.#timeout = timeout;
         if (times !== undefined)
             this.#times = times;
+        if (experimentalWebsocket !== undefined)
+            this.#experimentalWebsocket;
         this.#url = url;
         this.#protocol = protocol;
         this.#options = options;
@@ -205,36 +209,62 @@ class SocketRequestClient {
         return new Promise(async (resolve, reject) => {
             const init = async () => {
                 // @ts-ignore
-                if (!globalThis.WebSocket)
-                    globalThis.WebSocket = (await import('./browser-P2HFBJsB.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                if (!globalThis.WebSocket && !this.#experimentalWebsocket)
+                    globalThis.WebSocket = (await import('./browser-DQJ6xf_F.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
-                client.onmessage = this.onmessage;
-                client.onerror = this.onerror;
-                client.onopen = () => {
-                    this.#tries = 0;
-                    resolve(new ClientConnection(client, this.api));
-                };
-                client.onclose = message => {
-                    this.#tries++;
-                    if (!this.#retry)
-                        return reject(this.#options);
-                    if (this.#tries > this.#times) {
-                        console.log(`${this.#options.protocol} Client Closed`);
-                        console.error(`could not connect to - ${this.#url}/`);
-                        return resolve(new ClientConnection(client, this.api));
-                    }
-                    if (message.code === 1006) {
-                        console.log(`Retrying in ${this.#timeout} ms`);
-                        setTimeout(() => {
-                            return init();
-                        }, this.#timeout);
-                    }
-                };
+                if (this.#experimentalWebsocket) {
+                    client.addEventListener('error', this.onerror);
+                    client.addEventListener('message', this.onmessage);
+                    client.addEventListener('open', () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    });
+                    client.addEventListener('close', (client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    }));
+                }
+                else {
+                    client.onmessage = this.onmessage;
+                    client.onerror = this.onerror;
+                    client.onopen = () => {
+                        this.#tries = 0;
+                        resolve(new ClientConnection(client, this.api));
+                    };
+                    client.onclose = (message) => {
+                        this.#tries++;
+                        if (!this.#retry)
+                            return reject(this.#options);
+                        if (this.#tries > this.#times) {
+                            console.log(`${this.#options.protocol} Client Closed`);
+                            console.error(`could not connect to - ${this.#url}/`);
+                            return resolve(new ClientConnection(client, this.api));
+                        }
+                        if (message.code === 1006) {
+                            console.log(`Retrying in ${this.#timeout} ms`);
+                            setTimeout(() => {
+                                return init();
+                            }, this.#timeout);
+                        }
+                    };
+                }
             };
             return init();
         });
     }
-    onerror = error => {
+    onerror = (error) => {
         if (globalThis.pubsub.subscribers['error']) {
             globalThis.pubsub.publish('error', error);
         }
@@ -243,6 +273,10 @@ class SocketRequestClient {
         }
     };
     onmessage(message) {
+        if (!message.data) {
+            console.warn(`message ignored because it contained no data`);
+            return;
+        }
         const { value, url, status, id } = JSON.parse(message.data.toString());
         const publisher = id ? id : url;
         if (status === 200) {
@@ -280,7 +314,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-00QxgDks.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-DqPlTtAJ.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
@@ -347,7 +381,7 @@ class Peer extends SimplePeer {
      */
     request(data, id = crypto.randomUUID()) {
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(`request for ${id} timed out`), 30000);
+            const timeout = setTimeout(() => reject(`request for ${id} timed out`), 30_000);
             const onrequest = ({ data }) => {
                 clearTimeout(timeout);
                 resolve(data);
@@ -359,7 +393,7 @@ class Peer extends SimplePeer {
     }
 }
 
-const debug = globalThis.createDebugger('@peernet/swarm/client');
+const debug = globalThis.createDebugger('@netpeer/swarm/client');
 class Client {
     #peerId;
     #connections = {};
@@ -408,7 +442,7 @@ class Client {
     async _init() {
         // reconnectJob()
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-AyxSBUXj.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-pguCHlVu.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 const client = new SocketRequestClient(star, this.networkVersion);