@esportsplus/web-storage 0.4.0 → 0.5.1

package/build/index.js

@@ -1,4 +1,4 @@
-import { decrypt, encrypt } from '@esportsplus/utilities';
+import { encryption } from '@esportsplus/utilities';
 import { DriverType } from './constants.js';
 import { IndexedDBDriver } from './drivers/indexeddb.js';
 import { LocalStorageDriver } from './drivers/localstorage.js';
@@ -11,14 +11,13 @@ function isEnvelope(value) {
         && '__e' in value
         && '__v' in value;
 }
-async function deserialize(value, secret) {
+async function deserialize(value, cipher) {
     if (value === undefined || value === null) {
         return undefined;
     }
-    if (secret && typeof value === 'string') {
+    if (cipher && typeof value === 'string') {
         try {
-            value = await decrypt(value, secret);
-            value = JSON.parse(value);
+            value = await cipher.decrypt(value);
         }
         catch {
             return undefined;
@@ -26,12 +25,12 @@ async function deserialize(value, secret) {
     }
     return value;
 }
-async function serialize(value, secret) {
+async function serialize(value, cipher) {
     if (value === undefined || value === null) {
         return value;
     }
-    if (secret) {
-        return encrypt(JSON.stringify(value), secret);
+    if (cipher) {
+        return cipher.encrypt(value);
     }
     return value;
 }
@@ -70,11 +69,11 @@ async function migrate(driver, migrations, version) {
             }
         }
         let transformed = await migrations[keys[i]]({ all: () => Promise.resolve(data) });
-        await driver.clear();
         let entries = [];
         for (let key in transformed) {
             entries.push([key, transformed[key]]);
         }
+        await driver.clear();
         if (entries.length > 0) {
             await driver.replace(entries);
         }
@@ -82,16 +81,16 @@ async function migrate(driver, migrations, version) {
     await driver.set(VERSION_KEY, version);
 }
 class Local {
+    cipher;
     driver;
     globals;
     listeners;
     ready;
-    secret;
     version;
     constructor(options, secret) {
+        this.cipher = null;
         this.globals = new Set();
         this.listeners = new Map();
-        this.secret = secret || null;
         let { migrations, name, version = 1 } = options;
         this.version = version;
         if (options.driver === DriverType.LocalStorage) {
@@ -106,11 +105,14 @@ class Local {
         else {
             this.driver = new IndexedDBDriver(name, version);
         }
+        let init = secret
+            ? encryption(secret).then((c) => { this.cipher = c; })
+            : Promise.resolve();
         if (migrations) {
-            this.ready = migrate(this.driver, migrations, version);
+            this.ready = init.then(() => migrate(this.driver, migrations, version));
         }
         else {
-            this.ready = Promise.resolve();
+            this.ready = init;
         }
     }
     async all() {
@@ -120,7 +122,7 @@ class Local {
             if (key === VERSION_KEY) {
                 continue;
             }
-            let deserialized = await deserialize(raw[key], this.secret), unwrapped = unwrap(deserialized);
+            let deserialized = await deserialize(raw[key], this.cipher), unwrapped = unwrap(deserialized);
             if (deserialized === undefined) {
                 continue;
             }
@@ -131,7 +133,7 @@ class Local {
             result[key] = unwrapped.value;
         }
         if (expired.length > 0) {
-            this.driver.delete(expired);
+            await this.driver.delete(expired);
         }
         return result;
     }
@@ -151,7 +153,7 @@ class Local {
             if (key === VERSION_KEY) {
                 return;
             }
-            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            let deserialized = await deserialize(raw, this.cipher), unwrapped = unwrap(deserialized);
             if (deserialized !== undefined && unwrapped.expired) {
                 expired.push(key);
                 oldValues.set(key, unwrapped.value);
@@ -166,15 +168,32 @@ class Local {
     }
     async count() {
         await this.ready;
-        let total = await this.driver.count(), raw = await this.driver.get(VERSION_KEY);
-        return raw !== undefined ? total - 1 : total;
+        let expired = [], total = 0;
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.cipher), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                return;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
+            }
+            total++;
+        });
+        if (expired.length > 0) {
+            await this.driver.delete(expired);
+        }
+        return total;
     }
     async delete(...keys) {
         await this.ready;
-        let oldValues = new Map();
-        for (let i = 0, n = keys.length; i < n; i++) {
-            let raw = await this.driver.get(keys[i]), deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
-            oldValues.set(keys[i], deserialized === undefined ? undefined : unwrapped.value);
+        let oldValues = new Map(), raw = await this.driver.only(keys);
+        for (let [key, value] of raw) {
+            let deserialized = await deserialize(value, this.cipher), unwrapped = unwrap(deserialized);
+            oldValues.set(key, deserialized === undefined ? undefined : unwrapped.value);
         }
         await this.driver.delete(keys);
         for (let i = 0, n = keys.length; i < n; i++) {
@@ -188,7 +207,7 @@ class Local {
             if (stopped || key === VERSION_KEY) {
                 return;
             }
-            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            let deserialized = await deserialize(raw, this.cipher), unwrapped = unwrap(deserialized);
             if (deserialized === undefined) {
                 return;
             }
@@ -201,18 +220,18 @@ class Local {
             }
         });
         if (expired.length > 0) {
-            this.driver.delete(expired);
+            await this.driver.delete(expired);
         }
         return result;
     }
     async get(key, factory) {
         await this.ready;
-        let deserialized = await deserialize(await this.driver.get(key), this.secret), missing = false, unwrapped = unwrap(deserialized);
+        let deserialized = await deserialize(await this.driver.get(key), this.cipher), missing = false, unwrapped = unwrap(deserialized);
         if (deserialized === undefined) {
             missing = true;
         }
         else if (unwrapped.expired) {
-            this.driver.delete([key]);
+            await this.driver.delete([key]);
             missing = true;
         }
         if (missing) {
@@ -227,8 +246,25 @@ class Local {
     }
     async keys() {
         await this.ready;
-        let all = await this.driver.keys();
-        return all.filter((k) => k !== VERSION_KEY);
+        let expired = [], result = [];
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.cipher), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                return;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
+            }
+            result.push(key);
+        });
+        if (expired.length > 0) {
+            await this.driver.delete(expired);
+        }
+        return result;
     }
     async length() {
         await this.ready;
@@ -241,7 +277,7 @@ class Local {
             if (key === VERSION_KEY) {
                 return;
             }
-            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            let deserialized = await deserialize(raw, this.cipher), unwrapped = unwrap(deserialized);
             if (deserialized === undefined) {
                 return;
             }
@@ -252,14 +288,14 @@ class Local {
             await fn(unwrapped.value, key, j++);
         });
         if (expired.length > 0) {
-            this.driver.delete(expired);
+            await this.driver.delete(expired);
         }
     }
     async only(...keys) {
         await this.ready;
         let expired = [], raw = await this.driver.only(keys), result = {};
         for (let [key, value] of raw) {
-            let deserialized = await deserialize(value, this.secret), unwrapped = unwrap(deserialized);
+            let deserialized = await deserialize(value, this.cipher), unwrapped = unwrap(deserialized);
             if (deserialized === undefined) {
                 continue;
             }
@@ -270,36 +306,38 @@ class Local {
             result[key] = unwrapped.value;
         }
         if (expired.length > 0) {
-            this.driver.delete(expired);
+            await this.driver.delete(expired);
         }
         return result;
     }
     async persist(key) {
         await this.ready;
-        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret);
+        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.cipher);
         if (deserialized === undefined) {
             return false;
         }
         let unwrapped = unwrap(deserialized);
         if (unwrapped.expired) {
-            this.driver.delete([key]);
+            await this.driver.delete([key]);
             return false;
         }
         if (!unwrapped.hasTTL) {
             return true;
         }
-        return this.driver.set(key, await serialize(unwrapped.value, this.secret));
+        return this.driver.set(key, await serialize(unwrapped.value, this.cipher));
     }
     async replace(values) {
         await this.ready;
-        let entries = [], failed = [], oldValues = new Map();
-        for (let key in values) {
-            let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+        let entries = [], failed = [], fetchKeys = Object.keys(values), oldValues = new Map(), raw = await this.driver.only(fetchKeys);
+        for (let key of fetchKeys) {
+            let value = raw.get(key), deserialized = value !== undefined
+                ? await deserialize(value, this.cipher)
+                : undefined, unwrapped = unwrap(deserialized);
             oldValues.set(key, deserialized === undefined ? undefined : unwrapped.value);
             try {
                 entries.push([
                     key,
-                    await serialize(values[key], this.secret)
+                    await serialize(values[key], this.cipher)
                 ]);
             }
             catch {
@@ -318,16 +356,16 @@ class Local {
     async set(key, value, options) {
         await this.ready;
         try {
-            let oldRaw = await this.driver.get(key), oldDeserialized = await deserialize(oldRaw, this.secret), oldUnwrapped = unwrap(oldDeserialized), oldValue = oldDeserialized === undefined ? undefined : oldUnwrapped.value, stored;
+            let oldRaw = await this.driver.get(key), oldDeserialized = await deserialize(oldRaw, this.cipher), oldUnwrapped = unwrap(oldDeserialized), oldValue = oldDeserialized === undefined ? undefined : oldUnwrapped.value, stored;
             if (options?.ttl != null && options.ttl > 0) {
                 let envelope = {
                     __e: Date.now() + options.ttl,
                     __v: value
                 };
-                stored = await serialize(envelope, this.secret);
+                stored = await serialize(envelope, this.cipher);
             }
             else {
-                stored = await serialize(value, this.secret);
+                stored = await serialize(value, this.cipher);
             }
             let result = await this.driver.set(key, stored);
             notify(this.globals, this.listeners, key, value, oldValue);
@@ -353,7 +391,7 @@ class Local {
     }
     async ttl(key) {
         await this.ready;
-        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret);
+        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.cipher);
         if (deserialized === undefined) {
             return -1;
         }
@@ -362,7 +400,7 @@ class Local {
         }
         let remaining = deserialized.__e - Date.now();
         if (remaining <= 0) {
-            this.driver.delete([key]);
+            await this.driver.delete([key]);
             return -1;
         }
         return remaining;

package/build/lz.d.ts

@@ -0,0 +1,3 @@
+declare const compress: (input: string) => string;
+declare const decompress: (compressed: string) => string;
+export { compress, decompress };

package/build/lz.js

@@ -0,0 +1,138 @@
+let MAX_DECOMPRESSED_SIZE = 10_485_760;
+function emitLiteral(ctx, ch) {
+    let code = ch.charCodeAt(0);
+    if (code < 256) {
+        writeBits(ctx, ctx.numBits, 0);
+        writeBits(ctx, 8, code);
+    }
+    else {
+        writeBits(ctx, ctx.numBits, 1);
+        writeBits(ctx, 16, code);
+    }
+}
+function readBits(ctx, n) {
+    let result = 0;
+    for (let i = 0; i < n; i++) {
+        if (ctx.bitPos > 15) {
+            if (ctx.pos >= ctx.compressed.length) {
+                throw new Error('LZ: unexpected end of compressed data');
+            }
+            ctx.currentValue = ctx.compressed.charCodeAt(ctx.pos++) - 1;
+            ctx.bitPos = 0;
+        }
+        result = (result << 1) | ((ctx.currentValue >> (15 - ctx.bitPos)) & 1);
+        ctx.bitPos++;
+    }
+    return result;
+}
+function writeBits(ctx, n, value) {
+    for (let i = n - 1; i >= 0; i--) {
+        ctx.buffer = (ctx.buffer << 1) | ((value >> i) & 1);
+        ctx.bitsInBuffer++;
+        if (ctx.bitsInBuffer === 16) {
+            ctx.output.push(ctx.buffer + 1);
+            ctx.buffer = 0;
+            ctx.bitsInBuffer = 0;
+        }
+    }
+}
+const compress = (input) => {
+    if (!input) {
+        return '';
+    }
+    let ctx = { bitsInBuffer: 0, buffer: 0, numBits: 2, output: [] }, dictSize = 3, dictionary = new Map(), w = '';
+    for (let i = 0, n = input.length; i < n; i++) {
+        let c = input[i], wc = w + c;
+        if (dictionary.has(wc)) {
+            w = wc;
+            continue;
+        }
+        if (w.length > 0) {
+            if (dictionary.has(w)) {
+                writeBits(ctx, ctx.numBits, dictionary.get(w));
+            }
+            else {
+                emitLiteral(ctx, w);
+            }
+            dictionary.set(wc, dictSize++);
+            if (dictSize > (1 << ctx.numBits)) {
+                ctx.numBits++;
+            }
+        }
+        w = c;
+    }
+    if (w.length > 0) {
+        if (dictionary.has(w)) {
+            writeBits(ctx, ctx.numBits, dictionary.get(w));
+        }
+        else {
+            emitLiteral(ctx, w);
+        }
+    }
+    dictSize++;
+    if (dictSize > (1 << ctx.numBits)) {
+        ctx.numBits++;
+    }
+    writeBits(ctx, ctx.numBits, 2);
+    if (ctx.bitsInBuffer > 0) {
+        ctx.output.push(((ctx.buffer << (16 - ctx.bitsInBuffer)) & 0xFFFF) + 1);
+    }
+    ctx.output.push((ctx.bitsInBuffer === 0 ? 16 : ctx.bitsInBuffer) + 1);
+    return String.fromCharCode(...ctx.output);
+};
+const decompress = (compressed) => {
+    if (!compressed) {
+        return '';
+    }
+    let ctx = { bitPos: 16, compressed: '', currentValue: 0, pos: 0 }, dictSize = 3, dictionary = [], numBits = 2;
+    ctx.compressed = compressed.substring(0, compressed.length - 1);
+    let code = readBits(ctx, numBits), entry;
+    if (code === 0) {
+        entry = String.fromCharCode(readBits(ctx, 8));
+    }
+    else if (code === 1) {
+        entry = String.fromCharCode(readBits(ctx, 16));
+    }
+    else {
+        return '';
+    }
+    let parts = [entry], totalLength = entry.length, w = entry;
+    while (true) {
+        let slotIdx = dictionary.length;
+        dictionary.push('');
+        dictSize++;
+        if (dictSize > (1 << numBits)) {
+            numBits++;
+        }
+        code = readBits(ctx, numBits);
+        if (code === 2) {
+            dictionary.pop();
+            break;
+        }
+        let slotCode = slotIdx + 3;
+        if (code === 0) {
+            entry = String.fromCharCode(readBits(ctx, 8));
+        }
+        else if (code === 1) {
+            entry = String.fromCharCode(readBits(ctx, 16));
+        }
+        else if (code === slotCode) {
+            entry = w + w[0];
+        }
+        else if (code >= 3 && code < slotCode) {
+            entry = dictionary[code - 3];
+        }
+        else {
+            throw new Error('LZ: invalid decompression code');
+        }
+        dictionary[slotIdx] = w + entry[0];
+        parts.push(entry);
+        totalLength += entry.length;
+        if (totalLength > MAX_DECOMPRESSED_SIZE) {
+            throw new Error('LZ: decompressed output exceeds size limit');
+        }
+        w = entry;
+    }
+    return parts.join('');
+};
+export { compress, decompress };

package/build/types.d.ts

@@ -36,4 +36,4 @@ type TTLEnvelope<V> = {
 };
 type GlobalCallback<T> = (key: keyof T, newValue: T[keyof T] | undefined, oldValue: T[keyof T] | undefined) => void;
 type KeyCallback<T, K extends keyof T = keyof T> = (newValue: T[K] | undefined, oldValue: T[K] | undefined) => void;
-export type { Driver, Filter, GlobalCallback, KeyCallback, MigrationContext, MigrationFn, Options, SetOptions, TTLEnvelope };
+export type { Driver, Filter, GlobalCallback, KeyCallback, MigrationFn, Options, SetOptions, TTLEnvelope };

package/package.json

@@ -1,14 +1,14 @@
 {
   "author": "ICJR",
   "dependencies": {
-    "@esportsplus/utilities": "^0.26.0"
+    "@esportsplus/utilities": "^0.28.0"
   },
   "description": "Web storage utility",
   "devDependencies": {
-    "@esportsplus/typescript": "^0.9.2",
+    "@esportsplus/typescript": "^0.29.1",
     "fake-indexeddb": "^6.2.5",
-    "happy-dom": "^20.8.8",
-    "vitest": "^4.1.1"
+    "happy-dom": "^20.8.9",
+    "vitest": "^4.1.4"
   },
   "main": "build/index.js",
   "name": "@esportsplus/web-storage",
@@ -19,7 +19,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "scripts": {
     "build": "tsc && tsc-alias",
     "test": "vitest run",

package/src/drivers/localstorage.ts

@@ -1,3 +1,4 @@
+import { compress, decompress } from '~/lz';
 import type { Driver } from '~/types';
 
 
@@ -35,6 +36,10 @@ class LocalStorageDriver<T> implements Driver<T> {
         }
 
         try {
+            if (value.charCodeAt(0) === 1) {
+                return JSON.parse(decompress(value.slice(1)));
+            }
+
             return JSON.parse(value);
         }
         catch {
@@ -42,6 +47,12 @@ class LocalStorageDriver<T> implements Driver<T> {
         }
     }
 
+    private serialize(value: T[keyof T]): string {
+        let json = JSON.stringify(value);
+
+        return json.length >= 100 ? '\x01' + compress(json) : json;
+    }
+
 
     async all(): Promise<T> {
         let keys = this.getKeys(),
@@ -67,7 +78,15 @@ class LocalStorageDriver<T> implements Driver<T> {
     }
 
     async count(): Promise<number> {
-        return this.getKeys().length;
+        let count = 0;
+
+        for (let i = 0, n = localStorage.length; i < n; i++) {
+            if (localStorage.key(i)?.startsWith(this.prefix)) {
+                count++;
+            }
+        }
+
+        return count;
     }
 
     async delete(keys: (keyof T)[]): Promise<void> {
@@ -112,13 +131,13 @@ class LocalStorageDriver<T> implements Driver<T> {
 
     async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
         for (let i = 0, n = entries.length; i < n; i++) {
-            localStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+            localStorage.setItem(this.key(entries[i][0]), this.serialize(entries[i][1]));
         }
     }
 
     async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
         try {
-            localStorage.setItem(this.key(key), JSON.stringify(value));
+            localStorage.setItem(this.key(key), this.serialize(value));
             return true;
         }
         catch {

package/src/drivers/sessionstorage.ts

@@ -1,3 +1,4 @@
+import { compress, decompress } from '~/lz';
 import type { Driver } from '~/types';
 
 
@@ -35,6 +36,10 @@ class SessionStorageDriver<T> implements Driver<T> {
         }
 
         try {
+            if (value.charCodeAt(0) === 1) {
+                return JSON.parse(decompress(value.slice(1)));
+            }
+
             return JSON.parse(value);
         }
         catch {
@@ -42,6 +47,12 @@ class SessionStorageDriver<T> implements Driver<T> {
         }
     }
 
+    private serialize(value: T[keyof T]): string {
+        let json = JSON.stringify(value);
+
+        return json.length >= 100 ? '\x01' + compress(json) : json;
+    }
+
 
     async all(): Promise<T> {
         let keys = this.getKeys(),
@@ -67,7 +78,15 @@ class SessionStorageDriver<T> implements Driver<T> {
     }
 
     async count(): Promise<number> {
-        return this.getKeys().length;
+        let count = 0;
+
+        for (let i = 0, n = sessionStorage.length; i < n; i++) {
+            if (sessionStorage.key(i)?.startsWith(this.prefix)) {
+                count++;
+            }
+        }
+
+        return count;
     }
 
     async delete(keys: (keyof T)[]): Promise<void> {
@@ -112,13 +131,13 @@ class SessionStorageDriver<T> implements Driver<T> {
 
     async replace(entries: [keyof T, T[keyof T]][]): Promise<void> {
         for (let i = 0, n = entries.length; i < n; i++) {
-            sessionStorage.setItem(this.key(entries[i][0]), JSON.stringify(entries[i][1]));
+            sessionStorage.setItem(this.key(entries[i][0]), this.serialize(entries[i][1]));
         }
     }
 
     async set(key: keyof T, value: T[keyof T]): Promise<boolean> {
         try {
-            sessionStorage.setItem(this.key(key), JSON.stringify(value));
+            sessionStorage.setItem(this.key(key), this.serialize(value));
             return true;
         }
         catch {