@leofcoin/chain 1.4.78 → 1.4.80

package/exports/browser/browser-store.js

@@ -1,64 +1,73 @@
-// 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 encode = (string) => {
+    if (typeof string === 'string')
+        return new TextEncoder().encode(string);
+    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}`)
+const decode = (uint8Array) => {
+    if (uint8Array instanceof Uint8Array)
+        return new TextDecoder().decode(uint8Array);
+    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')
+const pathSepS = '/';
+class KeyPath {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(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');
+        }
     }
-  }
-
-  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)
-  }
+    isKeyPath() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
+    /**
+     * Returns the `list` representation of this path.
+     *
+     * @example
+     * ```js
+     * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+     * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+     * ```
+     */
+    list() {
+        return this.toString().split(pathSepS).slice(1);
+    }
+}
 
+class KeyValue {
+    uint8Array;
+    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;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
 }
 
 const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
@@ -376,149 +385,66 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-// 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}`)
-};
-
-const pathSepS = '/';
-class KeyPath {
-
-  /**
-   * @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 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(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)
-  }
-
-}
-
 class BrowerStore {
-  constructor(name = 'storage', root = '.leofcoin', version = 1) {
-    this.version = version;
-    this.name = name;
-    this.root = root;
-    this.db = openDB(`${root}/${name}`, version, {
-      upgrade(db) {
-        db.createObjectStore(name);
-      }
-    });
-  }
-
-  toKeyPath(key) {
-    if (!key.isKeyPath()) key = new KeyPath(key);
-    return key.toString('base32')
-  }
-  
-  toKeyValue(value) {
-    if (!value.isKeyValue()) value = new KeyValue(value);
-    return value.uint8Array
-  }
-
-  async get(key) {
-    return (await this.db).get(this.name, this.toKeyPath(key))
-  }
-
-  async put(key, value) {
-    return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key))
-  }
-
-  async delete(key) {
-    return (await this.db).delete(this.name, this.toKeyPath(key))
-  }
-
-  async clear() {
-    return (await this.db).clear(this.name)
-  }
-
-  async values(limit = -1) {
-    const values = [];
-    const tx = (await this.db).transaction(this.name);
-    
-    for await (const cursor of tx.store) {
-      values.push(cursor.value);
-      if (limit && values.length === limit) return values      
+    db;
+    name;
+    root;
+    version;
+    constructor(name = 'storage', root = '.leofcoin', version = '1') {
+        this.version = version;
+        this.name = name;
+        this.root = root;
+        this.db = openDB(`${root}/${name}`, Number(version), {
+            upgrade(db) {
+                db.createObjectStore(name);
+            }
+        });
     }
-    return values
-  }
-
-  async keys(limit = -1) {
-    const keys = [];
-    const tx = (await this.db).transaction(this.name);
-
-    for await (const cursor of tx.store) {
-      keys.push(cursor.key);
-      if (limit && keys.length === limit) return keys      
+    toKeyPath(key) {
+        if (!key.isKeyPath())
+            key = new KeyPath(key);
+        return key.toString('base32');
+    }
+    toKeyValue(value) {
+        if (!value.isKeyValue())
+            value = new KeyValue(value);
+        return value.uint8Array;
+    }
+    async get(key) {
+        return (await this.db).get(this.name, this.toKeyPath(key));
+    }
+    async put(key, value) {
+        return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key));
+    }
+    async delete(key) {
+        return (await this.db).delete(this.name, this.toKeyPath(key));
+    }
+    async clear() {
+        return (await this.db).clear(this.name);
+    }
+    async values(limit = -1) {
+        const values = [];
+        const tx = (await this.db).transaction(this.name);
+        for await (const cursor of tx.store) {
+            values.push(cursor.value);
+            if (limit && values.length === limit)
+                return values;
+        }
+        return values;
+    }
+    async keys(limit = -1) {
+        const keys = [];
+        const tx = (await this.db).transaction(this.name);
+        for await (const cursor of tx.store) {
+            keys.push(cursor.key);
+            if (limit && keys.length === limit)
+                return keys;
+        }
+        return keys;
+    }
+    async iterate() {
+        return (await this.db).transaction(this.name).store;
     }
-    return keys
-  }
-
-  async iterate() {
-    return (await this.db).transaction(this.name).store
-  }
-
 }
 
 export { BrowerStore as default };