@leofcoin/peernet 1.1.47 → 1.1.49

package/exports/browser/browser-store.js

@@ -1,65 +1,4 @@
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode$1 = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
-};
-
-const decode$1 = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
-};
-
-class KeyValue {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode$1(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyValue) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
-    }
-  }
-
-  isKeyValue() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'utf8') {
-    return decode$1(this.uint8Array)
-  }
-
-}
+import { K as KeyValue } from './value-157ab062.js';
 
 const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
 

package/exports/browser/{index-96b718dc.js → index-5f6ba5a4.js}

@@ -1,4 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-20a06ecc.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './peernet-9c2a381a.js';
+import './value-157ab062.js';
 
 /**
  * @params {String} network

package/exports/browser/{messages-591e0b2c.js → messages-5569e6ce.js}

@@ -1,4 +1,5 @@
-import { F as FormatInterface } from './peernet-20a06ecc.js';
+import { F as FormatInterface } from './peernet-9c2a381a.js';
+import './value-157ab062.js';
 
 var proto$b = {
   data: new Uint8Array(),

package/exports/browser/{peernet-20a06ecc.js → peernet-9c2a381a.js}

@@ -1,3 +1,5 @@
+import { K as KeyValue } from './value-157ab062.js';
+
 if (!globalThis.DEBUG) {
   if (globalThis.localStorage) globalThis.DEBUG = Boolean(globalThis.localStorage.getItem('DEBUG') === 'true');
 }
@@ -204,16 +206,16 @@ const ALPHABET$3 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
 const ALPHABET_HEX$1 = '0123456789ABCDEFGHIJKLMNOPQRSTUV';
 const base32 = base$1(ALPHABET$3);
 const base32Hex = base$1(ALPHABET_HEX$1);
-const decode$8 = base32.decode;
+const decode$9 = base32.decode;
 const decodeHex$2 = base32Hex.decode;
-const encode$7 = base32.encode;
+const encode$8 = base32.encode;
 const encodeHex$2 = base32Hex.encode;
 const isBase32 = (string, hex = false) => {
     try {
         if (hex)
             decodeHex$2(string);
         else
-            decode$8(string);
+            decode$9(string);
         return true;
     }
     catch (e) {
@@ -224,8 +226,8 @@ const isBase32Hex = (string) => {
     return isBase32(string, true);
 };
 var index$8 = {
-    encode: encode$7,
-    decode: decode$8,
+    encode: encode$8,
+    decode: decode$9,
     encodeHex: encodeHex$2,
     decodeHex: decodeHex$2,
     isBase32,
@@ -236,13 +238,13 @@ var ALPHABET$2 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 var ALPHABET_HEX = '0123456789ABCDEFGHJKLMNPQRSTUVabcdefghijklmnopqrstuv';
 var base58 = base$1(ALPHABET$2);
 var base58Hex = base$1(ALPHABET_HEX);
-var encode$6 = base58.encode;
-var decode$7 = base58.decode;
+var encode$7 = base58.encode;
+var decode$8 = base58.decode;
 var encodeHex$1 = base58Hex.encode;
 var decodeHex$1 = base58Hex.decode;
 var isBase58 = function (string) {
     try {
-        decode$7(string);
+        decode$8(string);
         return true;
     }
     catch (e) {
@@ -260,7 +262,7 @@ var isBase58Hex = function (string) {
 };
 var whatType = function (string) {
     try {
-        decode$7(string);
+        decode$8(string);
         return 'base58';
     }
     catch (e) {
@@ -273,15 +275,15 @@ var whatType = function (string) {
         }
     }
 };
-var base58$1 = { encode: encode$6, decode: decode$7, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$1, decodeHex: decodeHex$1, whatType: whatType };
+var base58$1 = { encode: encode$7, decode: decode$8, isBase58: isBase58, isBase58Hex: isBase58Hex, encodeHex: encodeHex$1, decodeHex: decodeHex$1, whatType: whatType };
 
 const MSB$1 = 0x80;
 const REST$1 = 0x7F;
 const MSBALL = ~REST$1;
 const INT = Math.pow(2, 31);
-const encode$5 = (num, out, offset) => {
+const encode$6 = (num, out, offset) => {
     if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-        encode$5.bytes = 0;
+        encode$6.bytes = 0;
         throw new RangeError('Could not encode varint');
     }
     out = out || [];
@@ -296,13 +298,13 @@ const encode$5 = (num, out, offset) => {
         num >>>= 7;
     }
     out[offset] = num | 0;
-    encode$5.bytes = offset - oldOffset + 1;
+    encode$6.bytes = offset - oldOffset + 1;
     return out;
 };
 
 const MSB = 0x80;
 const REST = 0x7F;
-const decode$6 = (buf, offset) => {
+const decode$7 = (buf, offset) => {
     offset = offset || 0;
     const l = buf.length;
     let counter = offset;
@@ -311,7 +313,7 @@ const decode$6 = (buf, offset) => {
     let b;
     do {
         if (counter >= l || shift > 49) {
-            decode$6.bytes = 0;
+            decode$7.bytes = 0;
             throw new RangeError('Could not decode varint');
         }
         b = buf[counter++];
@@ -320,7 +322,7 @@ const decode$6 = (buf, offset) => {
             : (b & REST) * Math.pow(2, shift);
         shift += 7;
     } while (b >= MSB);
-    decode$6.bytes = counter - offset;
+    decode$7.bytes = counter - offset;
     return result;
 };
 
@@ -345,8 +347,8 @@ var encodingLength = (value) => (value < N1 ? 1
                                     : 10);
 
 var index$7 = {
-    encode: encode$5,
-    decode: decode$6,
+    encode: encode$6,
+    decode: decode$7,
     encodingLength
 };
 
@@ -396,11 +398,11 @@ var index$5 = (typedArray, prefix) => {
 
 const ALPHABET$1 = '0123456789ABCDEF';
 const base16 = base$1(ALPHABET$1);
-const decode$5 = base16.decode;
-const encode$4 = base16.encode;
+const decode$6 = base16.decode;
+const encode$5 = base16.encode;
 const isBase16 = (string) => {
     try {
-        decode$5(string);
+        decode$6(string);
         return true;
     }
     catch (e) {
@@ -408,18 +410,18 @@ const isBase16 = (string) => {
     }
 };
 var index$4 = {
-    encode: encode$4,
-    decode: decode$5,
+    encode: encode$5,
+    decode: decode$6,
     isBase16
 };
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 const base64 = base$1(ALPHABET);
-const decode$4 = base64.decode;
-const encode$3 = base64.encode;
+const decode$5 = base64.decode;
+const encode$4 = base64.encode;
 const isBase64 = (string) => {
     try {
-        decode$4(string);
+        decode$5(string);
         return true;
     }
     catch (e) {
@@ -427,8 +429,8 @@ const isBase64 = (string) => {
     }
 };
 var index$3 = {
-    encode: encode$3,
-    decode: decode$4,
+    encode: encode$4,
+    decode: decode$5,
     isBase64
 };
 
@@ -4814,7 +4816,7 @@ const toType = (data) => {
         return new TextEncoder().encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
-const encode$2 = (proto, input, compress) => {
+const encode$3 = (proto, input, compress) => {
     const keys = Object.keys(proto);
     const values = Object.values(proto);
     const set = [];
@@ -4831,7 +4833,7 @@ const encode$2 = (proto, input, compress) => {
     }
     return index$6(set);
 };
-const decode$3 = (proto, uint8Array, compressed) => {
+const decode$4 = (proto, uint8Array, compressed) => {
     let deconcated = index$5(uint8Array);
     const output = {};
     const keys = Object.keys(proto);
@@ -4862,8 +4864,8 @@ const decode$3 = (proto, uint8Array, compressed) => {
     return output;
 };
 var index$1 = {
-    encode: encode$2,
-    decode: decode$3
+    encode: encode$3,
+    decode: decode$4
 };
 
 /*!
@@ -6342,6 +6344,172 @@ const nothingFoundError = (hash) => {
   return new Error(`nothing found for ${hash}`)
 };
 
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode$2 = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode$3 = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+const pathSepS = '/';
+class KeyPath {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode$2(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyPath) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
+    }
+  }
+  
+  isKeyPath() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'hex') {
+    return decode$3(this.uint8Array)
+  }
+
+  /**
+   * Returns the `list` representation of this path.
+   *
+   * @returns string[]
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+   * ```
+   */
+  list() {
+    return this.toString().split(pathSepS).slice(1)
+  }
+
+}
+
+let LeofcoinStorage$1 = class LeofcoinStorage {
+
+  constructor(name = 'storage', root = '.leofcoin') {
+    this.name = name;
+    this.root = root;
+  }
+
+  async init(name, root) {
+    const importee = await import(globalThis.navigator ? './browser-store.js' : './store.js');
+    const Store = importee.default;
+    this.db = new Store(this.name, this.root);
+  }
+
+  async get(key) {
+    if (typeof key === 'object') return this.many('get', key);
+    return this.db.get(new KeyPath(key))
+  }
+  
+  /**
+   * 
+   * @param {*} key 
+   * @param {*} value 
+   * @returns Promise
+   */
+  put(key, value) {
+    if (typeof key === 'object') return this.many('put', key);
+    return this.db.put(new KeyPath(key), new KeyValue(value));
+  }
+
+  async has(key) {
+    if (typeof key === 'object') return this.many('has', key);
+
+    try {
+      const has = await this.db.get(new KeyPath(key));
+
+      return Boolean(has);
+    } catch (e) {
+      return false
+    }
+  }
+
+  async delete(key) {
+    return this.db.delete(new KeyPath(key))
+  }
+
+  keys(limit = -1) {
+    return this.db.keys(limit)
+  }
+
+  async values(limit = -1) {
+    return this.db.values(limit)
+  }
+
+  async many(type, _value) {
+    const jobs = [];
+
+    for (const key of Object.keys(_value)) {
+      jobs.push(this[type](key, _value[key]));
+    }
+
+    return Promise.all(jobs)
+  }
+
+  async length() {
+    const keys = await this.keys();
+    return keys.length
+  }
+
+  async size() {
+    let size = 0;
+    const query = await this.db.iterate();
+    for await (const item of query) {
+      size += item.value ? item.value.length : item[1].length;
+    }
+    return size
+  }
+
+  async clear() {
+    return this.db.clear()
+  }
+
+  async iterate() {
+    return this.db.iterate()
+  }
+
+};
+
 const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
 
 const {subtle} = crypto;
@@ -20012,7 +20180,7 @@ class Identity {
             globalThis.peernet.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-96b718dc.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-5f6ba5a4.js');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -20050,10 +20218,10 @@ class Identity {
     }
 }
 
-globalThis.LeofcoinStorage = LeofcoinStorage;
+globalThis.LeofcoinStorage = LeofcoinStorage$1;
 globalThis.leofcoin = globalThis.leofcoin || {};
-pubsub = pubsub || new LittlePubSub();
-globalSub = globalSub || new LittlePubSub();
+globalThis.pubsub = globalThis.pubsub || new LittlePubSub();
+globalThis.globalSub = globalThis.globalSub || new LittlePubSub();
 /**
  * @access public
  * @example
@@ -20186,7 +20354,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-591e0b2c.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-5569e6ce.js');
         /**
          * proto Object containing protos
          * @type {Object}

package/exports/browser/peernet.d.ts

@@ -3,7 +3,7 @@ import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import DHT from './dht/dht.js';
 import MessageHandler from './handlers/message.js';
-import { LeofcoinStorage as LeofcoinStorageClass } from '@leofcoin/storage';
+import LeofcoinStorageClass from '@leofcoin/storage';
 import Identity from './identity.js';
 declare global {
     var globalSub: PubSub;

package/exports/browser/peernet.js

@@ -1 +1,2 @@
-export { P as default } from './peernet-20a06ecc.js';
+export { P as default } from './peernet-9c2a381a.js';
+import './value-157ab062.js';

package/exports/browser/value-157ab062.js

@@ -0,0 +1,64 @@
+// import base32 from '@vandeurenglenn/base32'
+// import base58 from '@vandeurenglenn/base58'
+
+// export const encodings = {
+//   base58,
+//   base32
+// }
+
+const encode = (string, encoding = 'utf-8') => {
+  if (typeof string === 'string') {
+    let encoded;
+    
+    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
+    encoded = new TextEncoder().encode(string);
+    return encoded
+  }
+  throw Error(`expected typeof String instead got ${string}`)
+};
+
+const decode = (uint8Array, encoding) => {
+  if (uint8Array instanceof Uint8Array) {
+    let decoded;
+    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
+    decoded = new TextDecoder().decode(uint8Array);
+    
+    return decoded
+  }
+  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+};
+
+class KeyValue {
+
+  /**
+   * @param {string | Uint8Array} input
+   */
+  constructor(input) {
+    if (typeof input === 'string') {
+      this.uint8Array = encode(input);
+    } else if (input instanceof Uint8Array) {
+      this.uint8Array = input;
+    } else if (input instanceof KeyValue) {
+      this.uint8Array = input.uint8Array;
+    } else {
+      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+    }
+  }
+
+  isKeyValue() {
+    return true
+  }
+
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
+   * @returns {string}
+   */
+  toString(encoding = 'utf8') {
+    return decode(this.uint8Array)
+  }
+
+}
+
+export { KeyValue as K };

package/exports/peernet.js

@@ -1,6 +1,7 @@
 import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import { Codec } from '@leofcoin/codec-format-interface';
+import LeofcoinStorageClass from '@leofcoin/storage';
 import { utils } from '@leofcoin/codecs';
 import MultiWallet from '@leofcoin/multi-wallet';
 import base58 from '@vandeurenglenn/base58';
@@ -380,10 +381,10 @@ class Identity {
     }
 }
 
-globalThis.LeofcoinStorage = LeofcoinStorage;
+globalThis.LeofcoinStorage = LeofcoinStorageClass;
 globalThis.leofcoin = globalThis.leofcoin || {};
-pubsub = pubsub || new PubSub();
-globalSub = globalSub || new PubSub();
+globalThis.pubsub = globalThis.pubsub || new PubSub();
+globalThis.globalSub = globalThis.globalSub || new PubSub();
 /**
  * @access public
  * @example

package/exports/types/peernet.d.ts

@@ -3,7 +3,7 @@ import '@vandeurenglenn/debug';
 import PubSub from '@vandeurenglenn/little-pubsub';
 import DHT from './dht/dht.js';
 import MessageHandler from './handlers/message.js';
-import { LeofcoinStorage as LeofcoinStorageClass } from '@leofcoin/storage';
+import LeofcoinStorageClass from '@leofcoin/storage';
 import Identity from './identity.js';
 declare global {
     var globalSub: PubSub;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.1.47",
+  "version": "1.1.49",
   "description": "",
   "main": "src/peernet.js",
   "exports": {

package/src/peernet.ts

@@ -8,7 +8,7 @@ import dataHandler from './handlers/data.js'
 import { encapsulatedError, dhtError,
   nothingFoundError } from './errors/errors.js'
 
-import {LeofcoinStorage as LeofcoinStorageClass} from '@leofcoin/storage'
+import LeofcoinStorageClass from '@leofcoin/storage'
 import { utils as codecUtils } from '@leofcoin/codecs'
 import Identity from './identity.js'
 
@@ -21,11 +21,11 @@ declare global {
   var LeofcoinStorageClient
 }
 
-globalThis.LeofcoinStorage = LeofcoinStorage
+globalThis.LeofcoinStorage = LeofcoinStorageClass
   
 globalThis.leofcoin = globalThis.leofcoin || {}
-pubsub = pubsub || new PubSub()
-globalSub = globalSub || new PubSub()
+globalThis.pubsub = globalThis.pubsub || new PubSub()
+globalThis.globalSub = globalThis.globalSub || new PubSub()
 
 
 /**