@leofcoin/chain 1.7.54 → 1.7.65

package/exports/browser/browser-store.js

@@ -1,306 +0,0 @@
-const encode = (string) => {
-    if (typeof string === 'string')
-        return new TextEncoder().encode(string);
-    throw Error(`expected typeof String instead got ${string}`);
-};
-const decode = (uint8Array) => {
-    if (uint8Array instanceof Uint8Array)
-        return new TextDecoder().decode(uint8Array);
-    throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
-};
-
-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');
-        }
-    }
-    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);
-    }
-}
-
-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;
-    busy;
-    queue = [];
-    async init(name = 'storage', root = '.leofcoin', version = '1', inWorker = false) {
-        this.version = version;
-        this.name = name;
-        this.root = opfsRoot;
-        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);
-        }
-        this.db = directoryHandle;
-    }
-    toKeyPath(key) {
-        if (key instanceof KeyPath)
-            key = new KeyPath(key);
-        return key.toString();
-    }
-    toKeyValue(value) {
-        if (value instanceof KeyValue)
-            value = new KeyValue(value);
-        // @ts-ignore
-        return value.uint8Array;
-    }
-    async has(key) {
-        debug(`has ${this.toKeyPath(key)}`);
-        try {
-            await this.db.getFileHandle(this.toKeyPath(key));
-            return true;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    async get(key) {
-        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) {
-        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) {
-        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()) {
-            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 size() {
-        let size = 0;
-        for await (const cursor of this.db.values()) {
-            // huh? Outdated typings?
-            // @ts-ignore
-            console.log((await cursor.getFile()).size);
-
-            size += (await cursor.getFile()).size;
-        }
-        return size;
-    }
-    async keys() {
-        const keys = [];
-        for await (const cursor of this.db.keys()) {
-            keys.push(cursor);
-        }
-        return keys;
-    }
-    async iterate() {
-        return this.db.entries();
-    }
-}
-
-export { BrowerStore as default };