@esportsplus/web-storage 0.1.44 → 0.3.1

package/.github/dependabot.yml

@@ -4,11 +4,13 @@
 # https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
 
 version: 2
+
 registries:
   npm-npmjs:
     token: ${{secrets.NPM_TOKEN}}
     type: npm-registry
     url: https://registry.npmjs.org
+
 updates:
   - package-ecosystem: "npm"
     directory: "/"

package/.github/workflows/bump.yml

@@ -1,7 +1,9 @@
 name: bump
+
 on:
   push:
     branches: '**' # only trigger on branches, not on tags
+
 jobs:
   bump:
     uses: esportsplus/workflows/.github/workflows/bump.yml@main

package/.github/workflows/dependabot.yml

@@ -0,0 +1,12 @@
+name: dependabot automerge
+
+on:
+  pull_request:
+    types: [opened, synchronize, labeled]
+  workflow_dispatch:
+
+jobs:
+  automerge:
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/workflows/.github/workflows/dependabot.yml@main

package/.github/workflows/publish.yml

@@ -1,4 +1,5 @@
 name: publish to npm
+
 on:
   release:
     types: [published]
@@ -7,8 +8,9 @@ on:
     workflows: [bump]
     types:
       - completed
+
 jobs:
   publish:
     secrets:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN_PUBLISHING }}
-    uses: esportsplus/workflows/.github/workflows/publish.yml@main
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+    uses: esportsplus/workflows/.github/workflows/publish.yml@main

package/build/constants.d.ts

@@ -0,0 +1,5 @@
+declare enum DriverType {
+    IndexedDB = 0,
+    LocalStorage = 1
+}
+export { DriverType };

package/build/constants.js

@@ -0,0 +1,6 @@
+var DriverType;
+(function (DriverType) {
+    DriverType[DriverType["IndexedDB"] = 0] = "IndexedDB";
+    DriverType[DriverType["LocalStorage"] = 1] = "LocalStorage";
+})(DriverType || (DriverType = {}));
+export { DriverType };

package/build/drivers/indexeddb.d.ts

@@ -0,0 +1,17 @@
+import type { Driver } from '../types.js';
+declare class IndexedDBDriver<T> implements Driver<T> {
+    private connection;
+    private name;
+    constructor(name: string, version: number);
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(keys: (keyof T)[]): Promise<void>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>>;
+    replace(entries: [keyof T, T[keyof T]][]): Promise<void>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+}
+export { IndexedDBDriver };

package/build/drivers/indexeddb.js

@@ -0,0 +1,115 @@
+let connections = new Map();
+function connect(name, version) {
+    let key = `${name}:${version}`;
+    if (!connections.has(key)) {
+        connections.set(key, new Promise((resolve, reject) => {
+            let request = indexedDB.open(name, version);
+            request.onupgradeneeded = () => {
+                let db = request.result;
+                if (!db.objectStoreNames.contains(name)) {
+                    db.createObjectStore(name);
+                }
+            };
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+        }));
+    }
+    return connections.get(key);
+}
+function promisify(request) {
+    return new Promise((resolve, reject) => {
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+    });
+}
+class IndexedDBDriver {
+    connection;
+    name;
+    constructor(name, version) {
+        this.connection = connect(name, version);
+        this.name = name;
+    }
+    async all() {
+        let db = await this.connection, store = db.transaction(this.name, 'readonly').objectStore(this.name), [keys, values] = await Promise.all([
+            promisify(store.getAllKeys()),
+            promisify(store.getAll())
+        ]), result = {};
+        for (let i = 0, n = keys.length; i < n; i++) {
+            result[keys[i]] = values[i];
+        }
+        return result;
+    }
+    async clear() {
+        let db = await this.connection, store = db.transaction(this.name, 'readwrite').objectStore(this.name);
+        await promisify(store.clear());
+    }
+    async count() {
+        let db = await this.connection, store = db.transaction(this.name, 'readonly').objectStore(this.name);
+        return promisify(store.count());
+    }
+    async delete(keys) {
+        let db = await this.connection, tx = db.transaction(this.name, 'readwrite'), store = tx.objectStore(this.name);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            store.delete(keys[i]);
+        }
+        return new Promise((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async get(key) {
+        let db = await this.connection, store = db.transaction(this.name, 'readonly').objectStore(this.name);
+        return promisify(store.get(key));
+    }
+    async keys() {
+        let db = await this.connection, store = db.transaction(this.name, 'readonly').objectStore(this.name);
+        return promisify(store.getAllKeys());
+    }
+    async map(fn) {
+        let db = await this.connection, store = db.transaction(this.name, 'readonly').objectStore(this.name);
+        return new Promise((resolve, reject) => {
+            let cursor = store.openCursor(), i = 0;
+            cursor.onerror = () => reject(cursor.error);
+            cursor.onsuccess = async () => {
+                let c = cursor.result;
+                if (c) {
+                    await fn(c.value, c.key, i++);
+                    c.continue();
+                }
+                else {
+                    resolve();
+                }
+            };
+        });
+    }
+    async only(keys) {
+        let db = await this.connection, results = new Map(), tx = db.transaction(this.name, 'readonly'), store = tx.objectStore(this.name);
+        await Promise.all(keys.map((key) => promisify(store.get(key)).then((value) => {
+            if (value !== undefined) {
+                results.set(key, value);
+            }
+        })));
+        return results;
+    }
+    async replace(entries) {
+        let db = await this.connection, tx = db.transaction(this.name, 'readwrite'), store = tx.objectStore(this.name);
+        for (let i = 0; i < entries.length; i++) {
+            store.put(entries[i][1], entries[i][0]);
+        }
+        return new Promise((resolve, reject) => {
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    async set(key, value) {
+        try {
+            let db = await this.connection, store = db.transaction(this.name, 'readwrite').objectStore(this.name);
+            await promisify(store.put(value, key));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export { IndexedDBDriver };

package/build/drivers/localstorage.d.ts

@@ -0,0 +1,19 @@
+import type { Driver } from '../types.js';
+declare class LocalStorageDriver<T> implements Driver<T> {
+    private prefix;
+    constructor(name: string, version: number);
+    private getKeys;
+    private key;
+    private parse;
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(keys: (keyof T)[]): Promise<void>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>>;
+    replace(entries: [keyof T, T[keyof T]][]): Promise<void>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+}
+export { LocalStorageDriver };

package/build/drivers/localstorage.js

@@ -0,0 +1,94 @@
+class LocalStorageDriver {
+    prefix;
+    constructor(name, version) {
+        this.prefix = `${name}:${version}:`;
+    }
+    getKeys() {
+        let keys = [];
+        for (let i = 0, n = localStorage.length; i < n; i++) {
+            let key = localStorage.key(i);
+            if (key && key.startsWith(this.prefix)) {
+                keys.push(key.slice(this.prefix.length));
+            }
+        }
+        return keys;
+    }
+    key(key) {
+        return this.prefix + String(key);
+    }
+    parse(value) {
+        if (value === null) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async all() {
+        let keys = this.getKeys(), result = {};
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.prefix + keys[i]));
+            if (value !== undefined) {
+                result[keys[i]] = value;
+            }
+        }
+        return result;
+    }
+    async clear() {
+        let keys = this.getKeys();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            localStorage.removeItem(this.prefix + keys[i]);
+        }
+    }
+    async count() {
+        return this.getKeys().length;
+    }
+    async delete(keys) {
+        for (let i = 0, n = keys.length; i < n; i++) {
+            localStorage.removeItem(this.key(keys[i]));
+        }
+    }
+    async get(key) {
+        return this.parse(localStorage.getItem(this.key(key)));
+    }
+    async keys() {
+        return this.getKeys();
+    }
+    async map(fn) {
+        let keys = this.getKeys();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.prefix + keys[i]));
+            if (value !== undefined) {
+                await fn(value, keys[i], i);
+            }
+        }
+    }
+    async only(keys) {
+        let results = new Map();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            let value = this.parse(localStorage.getItem(this.key(keys[i])));
+            if (value !== undefined) {
+                results.set(keys[i], value);
+            }
+        }
+        return results;
+    }
+    async replace(entries) {
+        for (let i = 0, n = entries.length; i < n; i++) {
+            localStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+        }
+    }
+    async set(key, value) {
+        try {
+            localStorage.setItem(this.key(key), JSON.stringify(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export { LocalStorageDriver };

package/build/index.d.ts

@@ -1 +1,21 @@
-export { default as local } from './local.js';
+import type { Filter, Options } from './types.js';
+declare class Local<T> {
+    private driver;
+    private secret;
+    constructor(options: Options, secret?: string);
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(...keys: (keyof T)[]): Promise<void>;
+    filter(fn: Filter<T>): Promise<T>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    length(): Promise<number>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(...keys: (keyof T)[]): Promise<T>;
+    replace(values: Partial<T>): Promise<string[]>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
+}
+declare const _default: <T>(options: Options, secret?: string) => Local<T>;
+export default _default;
+export { DriverType } from './constants.js';

package/build/index.js

@@ -1 +1,134 @@
-export { default as local } from './local.js';
+import { decrypt, encrypt } from '@esportsplus/crypto';
+import { DriverType } from './constants.js';
+import { IndexedDBDriver } from './drivers/indexeddb.js';
+import { LocalStorageDriver } from './drivers/localstorage.js';
+async function deserialize(value, secret) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (secret && typeof value === 'string') {
+        try {
+            value = await decrypt(value, secret);
+            value = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return value;
+}
+async function serialize(value, secret) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (secret) {
+        return encrypt(JSON.stringify(value), secret);
+    }
+    return value;
+}
+class Local {
+    driver;
+    secret;
+    constructor(options, secret) {
+        this.secret = secret || null;
+        let { name, version = 1 } = options;
+        if (options.driver === DriverType.LocalStorage) {
+            this.driver = new LocalStorageDriver(name, version);
+        }
+        else {
+            this.driver = new IndexedDBDriver(name, version);
+        }
+    }
+    async all() {
+        let raw = await this.driver.all(), result = {};
+        for (let key in raw) {
+            let value = await deserialize(raw[key], this.secret);
+            if (value !== undefined) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    async clear() {
+        return this.driver.clear();
+    }
+    async count() {
+        return this.driver.count();
+    }
+    async delete(...keys) {
+        return this.driver.delete(keys);
+    }
+    async filter(fn) {
+        let i = 0, result = {}, stop = () => { stopped = true; }, stopped = false;
+        await this.driver.map(async (raw, key) => {
+            if (stopped) {
+                return;
+            }
+            let value = await deserialize(raw, this.secret);
+            if (value === undefined) {
+                return;
+            }
+            if (await fn({ i: i++, key, stop, value })) {
+                result[key] = value;
+            }
+        });
+        return result;
+    }
+    async get(key) {
+        return deserialize(await this.driver.get(key), this.secret);
+    }
+    async keys() {
+        return this.driver.keys();
+    }
+    length() {
+        return this.driver.count();
+    }
+    map(fn) {
+        return this.driver.map(async (raw, key, i) => {
+            let value = await deserialize(raw, this.secret);
+            if (value !== undefined) {
+                await fn(value, key, i);
+            }
+        });
+    }
+    async only(...keys) {
+        let raw = await this.driver.only(keys), result = {};
+        for (let [key, value] of raw) {
+            let deserialized = await deserialize(value, this.secret);
+            if (deserialized !== undefined) {
+                result[key] = deserialized;
+            }
+        }
+        return result;
+    }
+    async replace(values) {
+        let entries = [], failed = [];
+        for (let key in values) {
+            try {
+                entries.push([
+                    key,
+                    await serialize(values[key], this.secret)
+                ]);
+            }
+            catch {
+                failed.push(key);
+            }
+        }
+        if (entries.length > 0) {
+            await this.driver.replace(entries);
+        }
+        return failed;
+    }
+    async set(key, value) {
+        try {
+            return this.driver.set(key, await serialize(value, this.secret));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export default (options, secret) => {
+    return new Local(options, secret);
+};
+export { DriverType } from './constants.js';

package/build/types.d.ts

@@ -1,7 +1,15 @@
-import localforage from 'localforage';
-declare enum Driver {
-    IndexedDB = 0,
-    LocalStorage = 1
+import { DriverType } from './constants.js';
+interface Driver<T> {
+    all(): Promise<T>;
+    clear(): Promise<void>;
+    count(): Promise<number>;
+    delete(keys: (keyof T)[]): Promise<void>;
+    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    keys(): Promise<(keyof T)[]>;
+    map(fn: (value: T[keyof T], key: keyof T, i: number) => void | Promise<void>): Promise<void>;
+    only(keys: (keyof T)[]): Promise<Map<keyof T, T[keyof T]>>;
+    replace(entries: [keyof T, T[keyof T]][]): Promise<void>;
+    set(key: keyof T, value: T[keyof T]): Promise<boolean>;
 }
 type Filter<T> = (data: {
     i: number;
@@ -9,13 +17,9 @@ type Filter<T> = (data: {
     stop: VoidFunction;
     value: T[keyof T];
 }) => boolean | Promise<boolean>;
-type LocalForage = typeof localforage;
 type Options = {
-    description?: string;
-    driver?: string | string[];
+    driver?: DriverType.IndexedDB | DriverType.LocalStorage;
     name: string;
-    size?: number;
-    version?: number;
+    version: number;
 };
-export { Driver };
-export type { Filter, LocalForage, Options };
+export type { Driver, Filter, Options };

package/build/types.js

@@ -1,7 +1 @@
-var Driver;
-(function (Driver) {
-    Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
-    Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
-})(Driver || (Driver = {}));
-;
-export { Driver };
+export {};

package/package.json

@@ -1,8 +1,7 @@
 {
   "author": "ICJR",
   "dependencies": {
-    "@esportsplus/crypto": "^0.1.0",
-    "localforage": "^1.10.0"
+    "@esportsplus/crypto": "^0.2.3"
   },
   "description": "Web storage utility",
   "devDependencies": {
@@ -11,9 +10,13 @@
   "main": "build/index.js",
   "name": "@esportsplus/web-storage",
   "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/esportsplus/web-storage"
+  },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.1.44",
+  "version": "0.3.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"

package/src/constants.ts

@@ -0,0 +1,6 @@
+enum DriverType {
+    IndexedDB,
+    LocalStorage
+}
+
+export { DriverType };