@esportsplus/web-storage 0.1.29 → 0.1.31

package/.editorconfig

@@ -1,9 +1,9 @@
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-end_of_line = lf
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+end_of_line = lf

package/.gitattributes

@@ -1,2 +1,2 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto

package/.github/dependabot.yml

@@ -0,0 +1,23 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# 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: "/"
+    groups:
+      production-dependencies:
+        dependency-type: "production"
+      development-dependencies:
+        dependency-type: "development"
+    registries:
+      - npm-npmjs
+    schedule:
+      interval: "daily"

package/.github/workflows/bump.yml

@@ -0,0 +1,7 @@
+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/publish.yml

@@ -0,0 +1,14 @@
+name: publish to npm
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+  workflow_run:
+    workflows: [bump]
+    types:
+      - completed
+jobs:
+  publish:
+    secrets:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN_PUBLISHING }}
+    uses: esportsplus/workflows/.github/workflows/publish.yml@main

package/build/local.d.ts

@@ -6,13 +6,11 @@ declare class Local<T> {
     length: LocalForage['length'];
     secret: null | string;
     constructor(options: Options, secret?: string);
-    private deserialize;
-    private serialize;
     all(): Promise<T>;
     clear(): Promise<void>;
     delete(...keys: (keyof T)[]): Promise<void>;
     filter(fn: Filter<T>): Promise<T>;
-    get(key: keyof T): Promise<T[keyof T] | undefined>;
+    get(key: keyof T): Promise<unknown>;
     only(...keys: (keyof T)[]): Promise<T>;
     replace(values: T): Promise<string[]>;
     set(key: keyof T, value: T[keyof T]): Promise<boolean>;

package/build/local.js

@@ -1,6 +1,25 @@
 import { Driver } from './types';
 import { decrypt, encrypt } from '@esportsplus/crypto';
 import localforage from 'localforage';
+async function deserialize(value, secret = null) {
+    if (secret && typeof value === 'string') {
+        value = await decrypt(value, secret);
+    }
+    if (typeof value === 'string') {
+        value = JSON.parse(value);
+    }
+    return value;
+}
+async function serialize(value, secret = null) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    value = JSON.stringify(value);
+    if (secret) {
+        value = await encrypt(value, secret);
+    }
+    return value;
+}
 class Local {
     instance;
     iterate;
@@ -24,29 +43,10 @@ class Local {
             this.secret = secret;
         }
     }
-    async deserialize(value) {
-        if (this.secret && typeof value === 'string') {
-            value = await decrypt(value, this.secret);
-        }
-        if (typeof value === 'string') {
-            value = JSON.parse(value);
-        }
-        return value;
-    }
-    async serialize(value) {
-        if (value === null || value === undefined) {
-            return undefined;
-        }
-        value = JSON.stringify(value);
-        if (this.secret) {
-            value = await encrypt(value, this.secret);
-        }
-        return value;
-    }
     async all() {
         let stack = [], values = {};
         await this.instance.iterate((v, k) => {
-            stack.push(this.deserialize(v)
+            stack.push(deserialize(v, this.secret)
                 .then((value) => {
                 if (value === undefined) {
                     return;
@@ -73,7 +73,7 @@ class Local {
             stopped = true;
         }, stopped = false, values = {};
         await this.instance.iterate(async (v, k, i) => {
-            let key = k, value = await this.deserialize(v).catch(() => undefined);
+            let key = k, value = await deserialize(v, this.secret).catch(() => undefined);
             if (value === undefined) {
                 return;
             }
@@ -87,7 +87,7 @@ class Local {
         return values;
     }
     async get(key) {
-        return await this.deserialize(await this.instance.getItem(key)).catch(() => undefined);
+        return await deserialize(await this.instance.getItem(key), this.secret).catch(() => undefined);
     }
     async only(...keys) {
         return await this.filter(({ key }) => keys.includes(key));
@@ -108,7 +108,8 @@ class Local {
     }
     async set(key, value) {
         let ok = true;
-        await this.instance.setItem(key, await this.serialize(value).catch(() => {
+        await this.instance.setItem(key, await serialize(value, this.secret)
+            .catch(() => {
             ok = false;
             return undefined;
         }));

package/package.json

@@ -1,22 +1,22 @@
-{
-    "author": "ICJR",
-    "dependencies": {
-        "@esportsplus/crypto": "^0.0.4",
-        "localforage": "^1.10.0"
-    },
-    "description": "Web storage utility",
-    "devDependencies": {
-        "@esportsplus/rspack": "^0.0.15"
-    },
-    "main": "build/index.js",
-    "name": "@esportsplus/web-storage",
-    "private": false,
-    "scripts": {
-        "build": "tsc && tsc-alias",
-        "-": "-",
-        "prepare": "npm run build",
-        "prepublishOnly": "npm run build"
-    },
-    "types": "build/index.d.ts",
-    "version": "0.1.29"
-}
+{
+    "author": "ICJR",
+    "dependencies": {
+        "@esportsplus/crypto": "^0.0.4",
+        "localforage": "^1.10.0"
+    },
+    "description": "Web storage utility",
+    "devDependencies": {
+        "@esportsplus/typescript": "^0.0.21"
+    },
+    "main": "build/index.js",
+    "name": "@esportsplus/web-storage",
+    "private": false,
+    "scripts": {
+        "build": "tsc && tsc-alias",
+        "-": "-",
+        "prepare": "npm run build",
+        "prepublishOnly": "npm run build"
+    },
+    "types": "build/index.d.ts",
+    "version": "0.1.31"
+}

package/src/index.ts

@@ -1 +1 @@
-export { default as local } from './local';
+export { default as local } from './local';

package/src/local.ts

@@ -1,176 +1,177 @@
-import { Driver, Filter, LocalForage, Options } from '~/types';
-import { decrypt, encrypt } from '@esportsplus/crypto';
-import localforage from 'localforage';
-
-
-class Local<T> {
-    instance: LocalForage;
-    iterate: LocalForage['iterate'];
-    keys: LocalForage['keys'];
-    length: LocalForage['length'];
-    secret: null | string = null;
-
-
-    constructor(options: Options, secret?: string) {
-        switch ((options.driver || Driver.IndexedDB) as Driver) {
-            case Driver.LocalStorage:
-                options.driver = localforage.LOCALSTORAGE;
-                break;
-            default:
-                options.driver = localforage.INDEXEDDB;
-                break;
-        }
-
-        this.instance = localforage.createInstance(
-            Object.assign(options, { storeName: options.name })
-        );
-        this.iterate = this.instance.iterate;
-        this.keys = this.instance.keys;
-        this.length = this.instance.length;
-
-        if (secret) {
-            this.secret = secret;
-        }
-    }
-
-
-    private async deserialize(value: unknown) {
-        if (this.secret && typeof value === 'string') {
-            value = await decrypt(value, this.secret);
-        }
-
-        if (typeof value === 'string') {
-            value = JSON.parse(value);
-        }
-
-        return value as T[keyof T];
-    }
-
-    private async serialize(value: unknown) {
-        if (value === null || value === undefined) {
-            return undefined;
-        }
-
-        value = JSON.stringify(value);
-
-        if (this.secret) {
-            value = await encrypt(value as string, this.secret);
-        }
-
-        return value as string;
-    }
-
-
-    async all(): Promise<T> {
-        let stack: Promise<void>[] = [],
-            values: T = {} as T;
-
-        await this.instance.iterate((v: unknown, k: string) => {
-            stack.push(
-                this.deserialize(v)
-                    .then((value) => {
-                        if (value === undefined) {
-                            return;
-                        }
-
-                        values[k as keyof T] = value;
-                    })
-                    .catch(() => {})
-            )
-        });
-
-        await Promise.allSettled(stack);
-
-        return values;
-    }
-
-    async clear() {
-        await this.instance.clear();
-    }
-
-    async delete(...keys: (keyof T)[]) {
-        let stack: Promise<void>[] = [];
-
-        for (let i = 0, n = keys.length; i < n; i++) {
-            stack.push( this.instance.removeItem(keys[i] as string) );
-        }
-
-        await Promise.allSettled(stack);
-    }
-
-    async filter(fn: Filter<T>): Promise<T> {
-        let stop: VoidFunction = () => {
-                stopped = true;
-            },
-            stopped: boolean = false,
-            values: T = {} as T;
-
-        await this.instance.iterate(async (v, k, i) => {
-            let key = k as keyof T,
-                value = await this.deserialize(v).catch(() => undefined);
-
-            if (value === undefined) {
-                return;
-            }
-
-            if (await fn({ i, key, stop, value })) {
-                values[key] = value;
-            }
-
-            // LocalForage iterate will stop once a non
-            // undefined value is returned
-            if (stopped) {
-                return true;
-            }
-        });
-
-        return values;
-    }
-
-    async get(key: keyof T) {
-        return await this.deserialize( await this.instance.getItem(key as string) ).catch(() => undefined);
-    }
-
-    async only(...keys: (keyof T)[]) {
-        return await this.filter( ({ key }) => keys.includes(key) );
-    }
-
-    async replace(values: T) {
-        let failed: string[] = [],
-            stack: Promise<void>[] = [];
-
-        for (let key in values) {
-            stack.push(
-                this.set(key, values[key])
-                    .then((ok) => {
-                        if (ok) {
-                            return;
-                        }
-
-                        failed.push(key);
-                    })
-            );
-        }
-
-        await Promise.allSettled(stack);
-
-        return failed;
-    }
-
-    async set(key: keyof T, value: T[keyof T]) {
-        let ok = true;
-
-        await this.instance.setItem(
-            key as string,
-            await this.serialize(value).catch(() => {
-                ok = false;
-                return undefined;
-            })
-        );
-
-        return ok;
-    }
-}
-
-
+import { Driver, Filter, LocalForage, Options } from '~/types';
+import { decrypt, encrypt } from '@esportsplus/crypto';
+import localforage from 'localforage';
+
+
+async function deserialize(value: unknown, secret: null | string = null) {
+    if (secret && typeof value === 'string') {
+        value = await decrypt(value, secret);
+    }
+
+    if (typeof value === 'string') {
+        value = JSON.parse(value);
+    }
+
+    return value;
+}
+
+async function serialize(value: unknown, secret: null | string = null) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+
+    value = JSON.stringify(value);
+
+    if (secret) {
+        value = await encrypt(value as string, secret);
+    }
+
+    return value as string;
+}
+
+
+class Local<T> {
+    instance: LocalForage;
+    iterate: LocalForage['iterate'];
+    keys: LocalForage['keys'];
+    length: LocalForage['length'];
+    secret: null | string = null;
+
+
+    constructor(options: Options, secret?: string) {
+        switch ((options.driver || Driver.IndexedDB) as Driver) {
+            case Driver.LocalStorage:
+                options.driver = localforage.LOCALSTORAGE;
+                break;
+            default:
+                options.driver = localforage.INDEXEDDB;
+                break;
+        }
+
+        this.instance = localforage.createInstance(
+            Object.assign(options, { storeName: options.name })
+        );
+        this.iterate = this.instance.iterate;
+        this.keys = this.instance.keys;
+        this.length = this.instance.length;
+
+        if (secret) {
+            this.secret = secret;
+        }
+    }
+
+
+    async all(): Promise<T> {
+        let stack: Promise<void>[] = [],
+            values: T = {} as T;
+
+        await this.instance.iterate((v: unknown, k: string) => {
+            stack.push(
+                deserialize(v, this.secret)
+                    .then((value) => {
+                        if (value === undefined) {
+                            return;
+                        }
+
+                        values[k as keyof T] = value as T[keyof T];
+                    })
+                    .catch(() => {})
+            )
+        });
+
+        await Promise.allSettled(stack);
+
+        return values;
+    }
+
+    async clear() {
+        await this.instance.clear();
+    }
+
+    async delete(...keys: (keyof T)[]) {
+        let stack: Promise<void>[] = [];
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            stack.push( this.instance.removeItem(keys[i] as string) );
+        }
+
+        await Promise.allSettled(stack);
+    }
+
+    async filter(fn: Filter<T>): Promise<T> {
+        let stop: VoidFunction = () => {
+                stopped = true;
+            },
+            stopped: boolean = false,
+            values: T = {} as T;
+
+        await this.instance.iterate(async (v, k, i) => {
+            let key = k as keyof T,
+                value = await deserialize(v, this.secret).catch(() => undefined) as T[keyof T];
+
+            if (value === undefined) {
+                return;
+            }
+
+            if (await fn({ i, key, stop, value })) {
+                values[key] = value;
+            }
+
+            // LocalForage iterate will stop once a non
+            // undefined value is returned
+            if (stopped) {
+                return true;
+            }
+        });
+
+        return values;
+    }
+
+    async get(key: keyof T) {
+        return await deserialize( await this.instance.getItem(key as string), this.secret ).catch(() => undefined);
+    }
+
+    async only(...keys: (keyof T)[]) {
+        return await this.filter( ({ key }) => keys.includes(key) );
+    }
+
+    async replace(values: T) {
+        let failed: string[] = [],
+            stack: Promise<void>[] = [];
+
+        for (let key in values) {
+            stack.push(
+                this.set(key, values[key])
+                    .then((ok) => {
+                        if (ok) {
+                            return;
+                        }
+
+                        failed.push(key);
+                    })
+            );
+        }
+
+        await Promise.allSettled(stack);
+
+        return failed;
+    }
+
+    async set(key: keyof T, value: T[keyof T]) {
+        let ok = true;
+
+        await this.instance.setItem(
+            key as string,
+            await serialize(value, this.secret)
+                .catch(() => {
+                    ok = false;
+                    return undefined;
+                })
+        );
+
+        return ok;
+    }
+}
+
+
 export default <T>(options: Options, secret?: string) => new Local<T>(options, secret);

package/src/types.ts

@@ -1,22 +1,22 @@
-import localforage from 'localforage';
-
-
-enum Driver {
-    IndexedDB,
-    LocalStorage
-};
-
-type Filter<T> = (data: { i: number, key: keyof T, stop: VoidFunction, value: T[keyof T] }) => boolean | Promise<boolean>;
-
-type LocalForage = typeof localforage;
-
-type Options = {
-    description?: string;
-    driver?: string | string[];
-    name: string;
-    size?: number;
-    version?: number;
-};
-
-
-export { Driver, Filter, LocalForage, Options };
+import localforage from 'localforage';
+
+
+enum Driver {
+    IndexedDB,
+    LocalStorage
+};
+
+type Filter<T> = (data: { i: number, key: keyof T, stop: VoidFunction, value: T[keyof T] }) => boolean | Promise<boolean>;
+
+type LocalForage = typeof localforage;
+
+type Options = {
+    description?: string;
+    driver?: string | string[];
+    name: string;
+    size?: number;
+    version?: number;
+};
+
+
+export { Driver, Filter, LocalForage, Options };

package/tsconfig.json

@@ -1,10 +1,11 @@
-{
-    "compilerOptions": {
-        "baseUrl": ".",
-        "declarationDir": "build",
-        "outDir": "build"
-    },
-    "exclude": ["node_modules"],
-    "extends": "@esportsplus/rspack/tsconfig.base.json",
-    "include": ["src"]
+{
+    "compilerOptions": {
+        "baseUrl": ".",
+        "declaration": true,
+        "declarationDir": "build",
+        "outDir": "build"
+    },
+    "exclude": ["node_modules"],
+    "extends": "./node_modules/@esportsplus/typescript/tsconfig.base.json",
+    "include": ["src"]
 }