@esportsplus/web-storage 0.0.8 → 0.1.1

package/build/index.d.ts

@@ -1,19 +1,30 @@
 import local from './local';
 declare const _default: {
     local: {
-        clear: () => void;
-        delete: (key: string) => Promise<void>;
-        get: (key: string, value?: any) => Promise<any>;
-        has: (key: string) => Promise<boolean>;
-        prepend: (key: string, value: any) => Promise<void>;
-        push: (key: string, value: any) => Promise<void>;
-        replace: (values: {
-            [key: string]: any;
-        }) => void;
-        set: (key: string, value: any) => Promise<void>;
-        useIndexedDB: (options?: import("./local/types").Options) => void;
-        useLocalStorage: (options?: import("./local/types").Options) => void;
-        useOptions: (options?: import("./local/types").Options) => void;
+        store: (options?: LocalForageOptions) => {
+            instance: LocalForage;
+            iterate: <T, U>(iteratee: (value: T, key: string, iterationNumber: number) => U, callback?: ((err: any, result: U) => void) | undefined) => Promise<U>;
+            keys: (callback?: ((err: any, keys: string[]) => void) | undefined) => Promise<string[]>;
+            length: (callback?: ((err: any, numberOfKeys: number) => void) | undefined) => Promise<number>;
+            promises: (Promise<any> | (() => void))[];
+            assign(key: string, value: import("./local/types").Object): void;
+            clear(): Promise<void>;
+            delete(...keys: string[]): void;
+            entries(): Promise<import("./local/types").Object>;
+            filter(fn: Function): Promise<import("./local/types").Object>;
+            get(key: string, value?: any): Promise<any>;
+            has(...keys: string[]): Promise<boolean>;
+            only(...keys: string[]): Promise<import("./local/types").Object>;
+            pop(key: string): Promise<any>;
+            push(key: string, ...values: any[]): void;
+            replace(values: {
+                [key: string]: any;
+            }): void;
+            shift(key: string): Promise<any>;
+            set(key: string, value: any): void;
+            sync(): Promise<void>;
+            unshift(key: string, ...values: any[]): void;
+        };
     };
 };
 export default _default;

package/build/index.js

@@ -1,3 +1,9 @@
-import local from './local';
-export default { local };
-export { local };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.local = void 0;
+const local_1 = __importDefault(require("./local"));
+exports.local = local_1.default;
+exports.default = { local: local_1.default };

package/build/local/index.d.ts

@@ -1,17 +1,30 @@
-import type { Options } from './types';
-declare const _default: {
-    clear: () => void;
-    delete: (key: string) => Promise<void>;
-    get: (key: string, value?: any) => Promise<any>;
-    has: (key: string) => Promise<boolean>;
-    prepend: (key: string, value: any) => Promise<void>;
-    push: (key: string, value: any) => Promise<void>;
-    replace: (values: {
+import { Object } from './types';
+declare class Store {
+    instance: LocalForage;
+    iterate: LocalForage['iterate'];
+    keys: LocalForage['keys'];
+    length: LocalForage['length'];
+    promises: (Promise<any> | (() => void))[];
+    constructor(options?: LocalForageOptions);
+    assign(key: string, value: Object): void;
+    clear(): Promise<void>;
+    delete(...keys: string[]): void;
+    entries(): Promise<Object>;
+    filter(fn: Function): Promise<Object>;
+    get(key: string, value?: any): Promise<any>;
+    has(...keys: string[]): Promise<boolean>;
+    only(...keys: string[]): Promise<Object>;
+    pop(key: string): Promise<any>;
+    push(key: string, ...values: any[]): void;
+    replace(values: {
         [key: string]: any;
-    }) => void;
-    set: (key: string, value: any) => Promise<void>;
-    useIndexedDB: (options?: Options) => void;
-    useLocalStorage: (options?: Options) => void;
-    useOptions: (options?: Options) => void;
+    }): void;
+    shift(key: string): Promise<any>;
+    set(key: string, value: any): void;
+    sync(): Promise<void>;
+    unshift(key: string, ...values: any[]): void;
+}
+declare const _default: {
+    store: (options?: LocalForageOptions) => Store;
 };
 export default _default;

package/build/local/index.js

@@ -1,91 +1,140 @@
-import dot from '@esportsplus/dot';
-import localforage from 'localforage';
-let cache = {}, driver = localforage.LOCALSTORAGE;
-function init(options = {}) {
-    localforage.config(Object.assign({ name: 'store' }, options, { driver }));
-}
-async function sync(key) {
-    let root = (key.split('.')[0] || '');
-    await localforage.setItem(root, dot.get(cache, root));
-}
-const clear = () => {
-    cache = {};
-    localforage.clear();
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const del = async (key) => {
-    dot.set(cache, key, undefined);
-    if (key.includes('.')) {
-        await sync(key);
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const localforage_1 = __importDefault(require("localforage"));
+class Store {
+    instance;
+    iterate;
+    keys;
+    length;
+    promises;
+    constructor(options = {}) {
+        let driver, name = options.name || 'store';
+        switch ((options.driver || types_1.Driver.IndexedDB)) {
+            case types_1.Driver.LocalStorage:
+                driver = localforage_1.default.LOCALSTORAGE;
+                break;
+            default:
+                driver = localforage_1.default.INDEXEDDB;
+                break;
+        }
+        this.instance = localforage_1.default.createInstance(Object.assign(options, { driver, name }));
+        this.iterate = this.instance.iterate;
+        this.keys = this.instance.keys;
+        this.length = this.instance.length;
+        this.promises = [];
     }
-    else {
-        localforage.removeItem(key);
+    assign(key, value) {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || {};
+            await this.instance.setItem(key, Object.assign(data, value));
+        });
     }
-};
-const get = async (key, value = null) => {
-    if (await has(key)) {
-        return dot.get(cache, key);
+    clear() {
+        this.promises = [];
+        return this.instance.clear();
     }
-    if (typeof value === 'function') {
-        value = await value();
+    delete(...keys) {
+        this.promises.push(async () => {
+            for (let i = 0, n = keys.length; i < n; i++) {
+                await this.instance.removeItem(keys[i]);
+            }
+        });
     }
-    set(key, value);
-    value = dot.get(cache, key);
-    if (value === null) {
-        throw new Error(`'${key}' has not been set in storage`);
+    async entries() {
+        let values = {};
+        await this.instance.iterate((value, key) => {
+            values[key] = value;
+        });
+        return values;
     }
-    return value;
-};
-const has = async (key) => {
-    if (dot.has(cache, key)) {
-        return true;
+    async filter(fn) {
+        let values = {};
+        await this.instance.iterate((value, key) => {
+            let result = fn(value, key), stop = typeof result !== 'boolean';
+            if (stop || (!stop && result)) {
+                values[key] = value;
+            }
+            if (stop) {
+                return true;
+            }
+        });
+        return values;
     }
-    let k = key.split('.'), f = k.shift() || '', value = await localforage.getItem(f);
-    if (value !== null) {
-        set(f, value);
-        if (Array.isArray(value) && k.length == 0) {
-            return true;
+    async get(key, value = null) {
+        let data = await this.instance.getItem(key);
+        if (data === null) {
+            if (typeof value === 'function') {
+                data = await value();
+            }
+            else {
+                data = value;
+            }
+            if (data !== null) {
+                this.set(key, data);
+            }
         }
-        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
-            return dot.has(value, k.join('.'));
+        if (data === null) {
+            throw new Error(`'${key}' has not been set in Storage`);
         }
+        return data;
     }
-    return false;
-};
-const prepend = async (key, value) => {
-    let values = await get(key, []);
-    if (!Array.isArray(values)) {
-        values = [values];
+    async has(...keys) {
+        let haystack = await this.instance.keys();
+        for (let i = 0, n = keys.length; i < n; i++) {
+            if (haystack.includes(keys[i])) {
+                continue;
+            }
+            return false;
+        }
+        return true;
     }
-    values.unshift(value);
-    set(key, values);
-};
-const push = async (key, value) => {
-    let values = await get(key, []);
-    if (!Array.isArray(values)) {
-        values = [values];
+    async only(...keys) {
+        return await this.filter((key) => keys.includes(key));
     }
-    values.push(value);
-    set(key, values);
-};
-const replace = (values) => {
-    for (let key in values) {
-        set(key, values[key]);
+    async pop(key) {
+        let value, values = (await this.get(key)) || [];
+        value = values.pop();
+        this.promises.push(this.instance.setItem(key, values));
+        return value;
     }
+    push(key, ...values) {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || [];
+            data.push(...values);
+            await this.instance.setItem(key, data);
+        });
+    }
+    replace(values) {
+        this.promises.push(async () => {
+            for (let key in values) {
+                await this.instance.setItem(key, values[key]);
+            }
+        });
+    }
+    async shift(key) {
+        let value, values = (await this.get(key)) || [];
+        value = values.shift();
+        this.promises.push(this.instance.setItem(key, values));
+        return value;
+    }
+    set(key, value) {
+        this.promises.push(this.instance.setItem(key, value));
+    }
+    async sync() {
+        await Promise.allSettled(this.promises.splice(0));
+    }
+    unshift(key, ...values) {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || [];
+            data.unshift(...values);
+            await this.instance.setItem(key, data);
+        });
+    }
+}
+exports.default = {
+    store: (options = {}) => new Store(options)
 };
-const set = async (key, value) => {
-    dot.set(cache, key, value);
-    await sync(key);
-};
-const useIndexedDB = (options = {}) => {
-    driver = localforage.INDEXEDDB;
-    init(options);
-};
-const useLocalStorage = (options = {}) => {
-    driver = localforage.LOCALSTORAGE;
-    init(options);
-};
-const useOptions = (options = {}) => {
-    init(options);
-};
-init();
-export default { clear, delete: del, get, has, prepend, push, replace, set, useIndexedDB, useLocalStorage, useOptions };

package/build/local/types.d.ts

@@ -1,7 +1,8 @@
-declare type Options = {
-    description?: string;
-    name?: string;
-    storeName?: string;
-    version?: number;
+declare enum Driver {
+    IndexedDB = 0,
+    LocalStorage = 1
+}
+declare type Object = {
+    [key: string]: any;
 };
-export type { Options };
+export { Driver, Object };

package/build/local/types.js

@@ -1 +1,10 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driver = void 0;
+var Driver;
+(function (Driver) {
+    Driver[Driver["IndexedDB"] = 0] = "IndexedDB";
+    Driver[Driver["LocalStorage"] = 1] = "LocalStorage";
+})(Driver || (Driver = {}));
+exports.Driver = Driver;
+;

package/package.json

@@ -1,20 +1,17 @@
 {
     "author": "ICJR",
     "dependencies": {
-        "@esportsplus/dot": "^0.0.3",
         "localforage": "^1.10.0"
     },
     "description": "Web storage utility",
     "devDependencies": {
-        "glob": "^7.1.7",
-        "node-polyfill-webpack-plugin": "^1.1.4",
-        "npm-run-all": "^4.1.5",
-        "ts-loader": "^9.2.6",
-        "tsc-alias": "^1.5.0",
-        "tsconfig-paths-webpack-plugin": "^3.5.2",
-        "typescript": "^4.5.2",
-        "webpack": "^5.64.4",
-        "webpack-cli": "^4.9.1"
+        "glob": "^8.0.3",
+        "ts-loader": "^9.4.1",
+        "tsc-alias": "^1.7.0",
+        "tsconfig-paths-webpack-plugin": "^4.0.0",
+        "typescript": "^4.8.4",
+        "webpack": "^5.74.0",
+        "webpack-cli": "^4.10.0"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/web-storage",
@@ -26,5 +23,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.8"
+    "version": "0.1.1"
 }

package/src/local/index.ts

@@ -1,135 +1,191 @@
-import type { Options } from './types';
-import dot from '@esportsplus/dot';
-import localforage from 'localforage';
-
-
-let cache: any = {},
-    driver: any = localforage.LOCALSTORAGE;
-
-
-function init(options: Options = {}): void {
-    localforage.config(Object.assign({ name: 'store' }, options, { driver }));
-}
-
-async function sync(key: string) {
-    let root = (key.split('.')[0] || '');
-
-    await localforage.setItem(root, dot.get(cache, root));
-}
-
-
-const clear = () => {
-    cache = {};
-    localforage.clear();
-};
-
-const del = async (key: string): Promise<void> => {
-    dot.set(cache, key, undefined);
-
-    if (key.includes('.')) {
-        await sync(key);
-    }
-    else {
-        localforage.removeItem(key);
-    }
-}
-
-const get = async (key: string, value: any = null): Promise<any> => {
-    if (await has(key)) {
-        return dot.get(cache, key);
-    }
-
-    if (typeof value === 'function') {
-        value = await value();
-    }
-
-    set(key, value);
-
-    value = dot.get(cache, key);
-
-    if (value === null) {
-        throw new Error(`'${key}' has not been set in storage`);
-    }
-
-    return value;
-};
-
-const has = async (key: string): Promise<boolean> => {
-    if (dot.has(cache, key)) {
-        return true;
-    }
-
-    let k = key.split('.'),
-        f = k.shift() || '',
-        value = await localforage.getItem(f);
-
-    if (value !== null) {
-        set(f, value);
-
-        if (Array.isArray(value) && k.length == 0) {
-            return true;
-        }
-
-        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
-            return dot.has(value, k.join('.'));
-        }
-    }
-
-    return false;
-};
-
-const prepend = async (key: string, value: any): Promise<void> => {
-    let values = await get(key, []);
-
-    if (!Array.isArray(values)) {
-        values = [values];
-    }
-
-    values.unshift(value);
-
-    set(key, values);
-};
-
-const push = async (key: string, value: any): Promise<void> => {
-    let values = await get(key, []);
-
-    if (!Array.isArray(values)) {
-        values = [values];
-    }
-
-    values.push(value);
-
-    set(key, values);
-};
-
-const replace = (values: { [key: string]: any }): void => {
-    for (let key in values) {
-        set(key, values[key]);
-    }
-};
-
-const set = async (key: string, value: any): Promise<void> => {
-    dot.set(cache, key, value);
-    await sync(key);
-};
-
-const useIndexedDB = (options: Options = {}): void => {
-    driver = localforage.INDEXEDDB;
-    init(options);
-};
-
-const useLocalStorage = (options: Options = {}): void => {
-    driver = localforage.LOCALSTORAGE;
-    init(options);
-};
-
-const useOptions = (options: Options = {}): void => {
-    init(options);
-};
-
-
-// Initialize using localstorage as default storage
-init();
-
-
-export default { clear, delete: del, get, has, prepend, push, replace, set, useIndexedDB, useLocalStorage, useOptions };
+import { Driver, Object } from './types';
+import localforage from 'localforage';
+
+
+class Store {
+    instance: LocalForage;
+    iterate: LocalForage['iterate'];
+    keys: LocalForage['keys'];
+    length: LocalForage['length'];
+    promises: (Promise<any> | (() => void))[];
+
+
+    constructor(options: LocalForageOptions = {}) {
+        let driver,
+            name = options.name || 'store';
+
+        switch ((options.driver || Driver.IndexedDB) as Driver) {
+            case Driver.LocalStorage: 
+                driver = localforage.LOCALSTORAGE;
+                break;
+            default:
+                driver = localforage.INDEXEDDB;
+                break;
+        }
+
+        this.instance = localforage.createInstance( Object.assign(options, { driver, name }) );
+        this.iterate = this.instance.iterate;
+        this.keys = this.instance.keys;
+        this.length = this.instance.length;
+        this.promises = [];
+    }
+
+
+    assign(key: string, value: Object): void {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || {};
+
+            await this.instance.setItem(
+                key, 
+                Object.assign(data, value)
+            );
+        });
+    }
+
+    clear(): Promise<void> {
+        this.promises = [];
+
+        return this.instance.clear();
+    }
+
+    delete(...keys: string[]): void {
+        this.promises.push(async () => {
+            for (let i = 0, n = keys.length; i < n; i++) {
+                await this.instance.removeItem(keys[i]);
+            }
+        });
+    }
+
+    async entries(): Promise<Object> {
+        let values: Object = {};
+
+        await this.instance.iterate((value: any, key: string) => {
+            values[key] = value;
+        });
+
+        return values;
+    }
+
+    async filter(fn: Function): Promise<Object> {
+        let values: Object = {};
+
+        await this.instance.iterate((value: any, key: string) => {
+            let result = fn(value, key),
+                stop = typeof result !== 'boolean';
+
+            if (stop || (!stop && result)) {
+                values[key] = value;
+            }
+
+            if (stop) {
+                return true;
+            }
+        });
+
+        return values;
+    }
+
+    async get(key: string, value: any = null): Promise<any> {
+        let data: any = await this.instance.getItem(key);
+    
+        if (data === null) {
+            if (typeof value === 'function') {
+                data = await value();
+            }
+            else {
+                data = value;
+            }
+    
+            if (data !== null) {
+                this.set(key, data);
+            }
+        }
+    
+        if (data === null) {
+            throw new Error(`'${key}' has not been set in Storage`);
+        }
+    
+        return data;
+    }
+
+    async has(...keys: string[]): Promise<boolean> {
+        let haystack = await this.instance.keys();
+
+        for (let i = 0, n = keys.length; i < n; i++) {
+            if (haystack.includes(keys[i])) {
+                continue;
+            }
+
+            return false;
+        }
+        
+        return true;
+    }
+
+    async only(...keys: string[]): Promise<Object> {
+        return await this.filter((key: string) => keys.includes(key));
+    }
+
+    async pop(key: string): Promise<any> {
+        let value,
+            values = (await this.get(key)) || [];
+
+        value = values.pop();
+
+        this.promises.push( this.instance.setItem(key, values) );
+
+        return value;
+    }
+
+    push(key: string, ...values: any[]): void {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || [];
+
+            data.push(...values);
+
+            await this.instance.setItem(key, data);
+        });
+    }
+
+    replace(values: { [key: string]: any }): void {
+        this.promises.push(async () => {
+            for (let key in values) {
+                await this.instance.setItem(key, values[key])
+            }
+        });
+    }
+
+    async shift(key: string): Promise<any> {
+        let value,
+            values = (await this.get(key)) || [];
+
+        value = values.shift();
+
+        this.promises.push( this.instance.setItem(key, values) );
+
+        return value;
+    }
+
+    set(key: string, value: any): void {
+        this.promises.push( this.instance.setItem(key, value) );
+    }
+
+    async sync(): Promise<void> { 
+        await Promise.allSettled(this.promises.splice(0));
+    }
+
+    unshift(key: string, ...values: any[]): void {
+        this.promises.push(async () => {
+            let data = (await this.get(key)) || [];
+
+            data.unshift(...values);
+
+            await this.instance.setItem(key, data);
+        });
+    }
+}
+
+
+export default {
+    store: (options: LocalForageOptions = {}): Store => new Store(options)
+};

package/src/local/types.ts

@@ -1,9 +1,9 @@
-type Options = {
-    description?: string,
-    name?: string,
-    storeName?: string,
-    version?: number
+enum Driver {
+    IndexedDB,
+    LocalStorage
 };
 
+type Object = { [key: string]: any };
 
-export type { Options };
+
+export { Driver, Object };

package/tsconfig.json

@@ -1,35 +1,23 @@
 {
     "compilerOptions": {
         "allowJs": true,
-        "allowUmdGlobalAccess": true,
         "alwaysStrict": true,
         "baseUrl": "src",
         "declaration": true,
         "declarationDir": "./build",
-        "esModuleInterop": true,
-        "forceConsistentCasingInFileNames": true,
-        "lib": ["dom", "es7"],
-        "module": "esnext",
+        "lib": ["dom", "ESNext"],
+        "module": "NodeNext",
         "moduleResolution": "node",
-        "noFallthroughCasesInSwitch": true,
-        "noImplicitAny": true,
-        "noImplicitReturns": true,
-        "noImplicitThis": true,
-        "noUncheckedIndexedAccess": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
         "outDir": "./build",
-        "paths": { },
+        "paths": {
+            "~/*": ["*"]
+        },
         "removeComments": true,
         "resolveJsonModule": true,
-        "skipLibCheck": true,
-        "sourceMap": false,
         "strict": true,
-        "strictBindCallApply": true,
-        "strictFunctionTypes": true,
-        "strictNullChecks": true,
-        "strictPropertyInitialization": true,
-        "target": "esnext"
+        "target": "ESNext"
     },
     "exclude": ["node_modules"],
     "include": ["src"],

package/webpack.typescript.config.js

@@ -1,64 +1,54 @@
-const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
 const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
 const glob = require('glob');
-const webpack = require('webpack');
 
 
-const config = ({ filename, input, library, output, production }) => {
-    let optimization = {
-            usedExports: false
-        };
-
+module.exports = ({ directory, entry, filename, library, output, production }) => {
     filename = filename || 'app';
-    production = production ? false : true;
+    production = production == 'true' ? true : false;
+
+    if (directory) {
+        entry = glob.sync(`${directory}/{,!(node_modules)/**/}!(webpack)*!(.d).{ts,js}`);
+    }
 
     if (production) {
-        optimization = {
-            mangleWasmImports: false,
-            minimize: false,
-            usedExports: false
-        };
+        filename += '.min';
     }
 
     return {
         entry: {
-            [(filename || 'app') + (production ? '.min' : '')]: glob.sync(`${input}/{,!(node_modules)/**/}!(webpack)*!(.d).ts`)
+            [filename]: entry
         },
-        mode: (production ? 'development' : 'production'),
+        mode: (production ? 'production' : 'development'),
         module: {
             rules: [
                 {
                     test: /\.tsx?$/,
                     use: 'ts-loader',
-                    exclude: /node_modules/
+                    exclude: /node_modules/,
+                    resolve: {
+                        fullySpecified: false,
+                    }
                 }
             ]
         },
-        optimization,
+        optimization: {
+            mangleWasmImports: production,
+            minimize: production,
+            usedExports: production
+        },
         output: {
-            // fixes ReferenceError: window is not defined
-            globalObject: "(typeof self !== 'undefined' ? self : this)",
             library: library || filename,
             path: output,
         },
-        plugins: [
-            new NodePolyfillPlugin(),
-            new webpack.ProvidePlugin({
-                Buffer: ['buffer', 'Buffer'],
-                process: 'process/browser'
-            })
-        ],
         resolve: {
             extensions: ['.js', '.ts', '.tsx'],
-            fallback: {
-                fs: false
-            },
+            fullySpecified: false,
             plugins: [
-                new TsconfigPathsPlugin()
+                new TsconfigPathsPlugin({
+                    extensions: ['.js', '.ts', '.tsx']
+                })
             ]
-        }
+        },
+        watch: true
     };
 };
-
-
-module.exports = config;