@esportsplus/web-storage 0.3.5 → 0.5.0

package/build/index.js

@@ -2,6 +2,15 @@ import { decrypt, encrypt } from '@esportsplus/utilities';
 import { DriverType } from './constants.js';
 import { IndexedDBDriver } from './drivers/indexeddb.js';
 import { LocalStorageDriver } from './drivers/localstorage.js';
+import { MemoryDriver } from './drivers/memory.js';
+import { SessionStorageDriver } from './drivers/sessionstorage.js';
+const VERSION_KEY = '__version__';
+function isEnvelope(value) {
+    return value !== null
+        && typeof value === 'object'
+        && '__e' in value
+        && '__v' in value;
+}
 async function deserialize(value, secret) {
     if (value === undefined || value === null) {
         return undefined;
@@ -26,84 +35,267 @@ async function serialize(value, secret) {
     }
     return value;
 }
+function notify(globals, listeners, key, newValue, oldValue) {
+    let set = listeners.get(key);
+    if (set) {
+        for (let cb of set) {
+            cb(newValue, oldValue);
+        }
+    }
+    for (let cb of globals) {
+        cb(key, newValue, oldValue);
+    }
+}
+function unwrap(value) {
+    if (isEnvelope(value)) {
+        return {
+            expired: Date.now() > value.__e,
+            hasTTL: true,
+            value: value.__v
+        };
+    }
+    return { expired: false, hasTTL: false, value: value };
+}
+async function migrate(driver, migrations, version) {
+    let raw = await driver.get(VERSION_KEY), stored = typeof raw === 'number' ? raw : 0;
+    if (stored >= version) {
+        return;
+    }
+    let keys = Object.keys(migrations).map(Number).filter((v) => v > stored && v <= version).sort((a, b) => a - b);
+    for (let i = 0, n = keys.length; i < n; i++) {
+        let all = await driver.all(), data = {};
+        for (let key in all) {
+            if (key !== VERSION_KEY) {
+                data[key] = all[key];
+            }
+        }
+        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]]);
+        }
+        if (entries.length > 0) {
+            await driver.replace(entries);
+        }
+    }
+    await driver.set(VERSION_KEY, version);
+}
 class Local {
     driver;
+    globals;
+    listeners;
+    ready;
     secret;
+    version;
     constructor(options, secret) {
+        this.globals = new Set();
+        this.listeners = new Map();
         this.secret = secret || null;
-        let { name, version = 1 } = options;
+        let { migrations, name, version = 1 } = options;
+        this.version = version;
         if (options.driver === DriverType.LocalStorage) {
             this.driver = new LocalStorageDriver(name, version);
         }
+        else if (options.driver === DriverType.Memory) {
+            this.driver = new MemoryDriver(name, version);
+        }
+        else if (options.driver === DriverType.SessionStorage) {
+            this.driver = new SessionStorageDriver(name, version);
+        }
         else {
             this.driver = new IndexedDBDriver(name, version);
         }
+        if (migrations) {
+            this.ready = migrate(this.driver, migrations, version);
+        }
+        else {
+            this.ready = Promise.resolve();
+        }
     }
     async all() {
-        let raw = await this.driver.all(), result = {};
+        await this.ready;
+        let expired = [], 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;
+            if (key === VERSION_KEY) {
+                continue;
+            }
+            let deserialized = await deserialize(raw[key], this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                continue;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                continue;
             }
+            result[key] = unwrapped.value;
+        }
+        if (expired.length > 0) {
+            this.driver.delete(expired);
         }
         return result;
     }
     async clear() {
-        return this.driver.clear();
+        await this.ready;
+        let allData = await this.all(), keys = Object.keys(allData);
+        await this.driver.clear();
+        await this.driver.set(VERSION_KEY, this.version);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            notify(this.globals, this.listeners, keys[i], undefined, allData[keys[i]]);
+        }
+    }
+    async cleanup() {
+        await this.ready;
+        let expired = [], oldValues = new Map();
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized !== undefined && unwrapped.expired) {
+                expired.push(key);
+                oldValues.set(key, unwrapped.value);
+            }
+        });
+        if (expired.length > 0) {
+            await this.driver.delete(expired);
+            for (let i = 0, n = expired.length; i < n; i++) {
+                notify(this.globals, this.listeners, expired[i], undefined, oldValues.get(expired[i]));
+            }
+        }
     }
     async count() {
-        return this.driver.count();
+        await this.ready;
+        let total = await this.driver.count(), raw = await this.driver.get(VERSION_KEY);
+        return raw !== undefined ? total - 1 : total;
     }
     async delete(...keys) {
-        return this.driver.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);
+        }
+        await this.driver.delete(keys);
+        for (let i = 0, n = keys.length; i < n; i++) {
+            notify(this.globals, this.listeners, keys[i], undefined, oldValues.get(keys[i]));
+        }
     }
     async filter(fn) {
-        let i = 0, result = {}, stop = () => { stopped = true; }, stopped = false;
+        await this.ready;
+        let expired = [], i = 0, result = {}, stop = () => { stopped = true; }, stopped = false;
         await this.driver.map(async (raw, key) => {
-            if (stopped) {
+            if (stopped || key === VERSION_KEY) {
                 return;
             }
-            let value = await deserialize(raw, this.secret);
-            if (value === undefined) {
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
                 return;
             }
-            if (await fn({ i: i++, key, stop, value })) {
-                result[key] = value;
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
+            }
+            if (await fn({ i: i++, key, stop, value: unwrapped.value })) {
+                result[key] = unwrapped.value;
             }
         });
+        if (expired.length > 0) {
+            this.driver.delete(expired);
+        }
         return result;
     }
-    async get(key) {
-        return deserialize(await this.driver.get(key), this.secret);
+    async get(key, factory) {
+        await this.ready;
+        let deserialized = await deserialize(await this.driver.get(key), this.secret), missing = false, unwrapped = unwrap(deserialized);
+        if (deserialized === undefined) {
+            missing = true;
+        }
+        else if (unwrapped.expired) {
+            this.driver.delete([key]);
+            missing = true;
+        }
+        if (missing) {
+            if (factory) {
+                let value = await factory();
+                this.set(key, value);
+                return value;
+            }
+            return undefined;
+        }
+        return unwrapped.value;
     }
     async keys() {
-        return this.driver.keys();
+        await this.ready;
+        let all = await this.driver.keys();
+        return all.filter((k) => k !== VERSION_KEY);
     }
-    length() {
-        return this.driver.count();
+    async length() {
+        await this.ready;
+        return this.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 map(fn) {
+        await this.ready;
+        let expired = [], j = 0;
+        await this.driver.map(async (raw, key) => {
+            if (key === VERSION_KEY) {
+                return;
+            }
+            let deserialized = await deserialize(raw, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                return;
+            }
+            if (unwrapped.expired) {
+                expired.push(key);
+                return;
             }
+            await fn(unwrapped.value, key, j++);
         });
+        if (expired.length > 0) {
+            this.driver.delete(expired);
+        }
     }
     async only(...keys) {
-        let raw = await this.driver.only(keys), result = {};
+        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);
-            if (deserialized !== undefined) {
-                result[key] = deserialized;
+            let deserialized = await deserialize(value, this.secret), unwrapped = unwrap(deserialized);
+            if (deserialized === undefined) {
+                continue;
             }
+            if (unwrapped.expired) {
+                expired.push(key);
+                continue;
+            }
+            result[key] = unwrapped.value;
+        }
+        if (expired.length > 0) {
+            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);
+        if (deserialized === undefined) {
+            return false;
+        }
+        let unwrapped = unwrap(deserialized);
+        if (unwrapped.expired) {
+            this.driver.delete([key]);
+            return false;
+        }
+        if (!unwrapped.hasTTL) {
+            return true;
+        }
+        return this.driver.set(key, await serialize(unwrapped.value, this.secret));
+    }
     async replace(values) {
-        let entries = [], failed = [];
+        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);
+            oldValues.set(key, deserialized === undefined ? undefined : unwrapped.value);
             try {
                 entries.push([
                     key,
@@ -117,16 +309,64 @@ class Local {
         if (entries.length > 0) {
             await this.driver.replace(entries);
         }
+        for (let i = 0, n = entries.length; i < n; i++) {
+            let key = entries[i][0];
+            notify(this.globals, this.listeners, key, values[key], oldValues.get(key));
+        }
         return failed;
     }
-    async set(key, value) {
+    async set(key, value, options) {
+        await this.ready;
         try {
-            return this.driver.set(key, await serialize(value, this.secret));
+            let oldRaw = await this.driver.get(key), oldDeserialized = await deserialize(oldRaw, this.secret), 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);
+            }
+            else {
+                stored = await serialize(value, this.secret);
+            }
+            let result = await this.driver.set(key, stored);
+            notify(this.globals, this.listeners, key, value, oldValue);
+            return result;
         }
         catch {
             return false;
         }
     }
+    subscribe(keyOrCallback, callback) {
+        if (typeof keyOrCallback === 'function') {
+            let cb = keyOrCallback;
+            this.globals.add(cb);
+            return () => { this.globals.delete(cb); };
+        }
+        let cb = callback, key = keyOrCallback, set = this.listeners.get(key);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(key, set);
+        }
+        set.add(cb);
+        return () => { set.delete(cb); };
+    }
+    async ttl(key) {
+        await this.ready;
+        let raw = await this.driver.get(key), deserialized = await deserialize(raw, this.secret);
+        if (deserialized === undefined) {
+            return -1;
+        }
+        if (!isEnvelope(deserialized)) {
+            return -1;
+        }
+        let remaining = deserialized.__e - Date.now();
+        if (remaining <= 0) {
+            this.driver.delete([key]);
+            return -1;
+        }
+        return remaining;
+    }
 }
 export default (options, secret) => {
     return new Local(options, secret);

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,134 @@
+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) {
+            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);
+    let chars = [];
+    for (let i = 0, n = ctx.output.length; i < n; i++) {
+        chars.push(String.fromCharCode(ctx.output[i]));
+    }
+    return chars.join('');
+};
+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 result = [entry], 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];
+        result.push(entry);
+        w = entry;
+    }
+    return result.join('');
+};
+export { compress, decompress };

package/build/types.d.ts

@@ -17,9 +17,23 @@ type Filter<T> = (data: {
     stop: VoidFunction;
     value: T[keyof T];
 }) => boolean | Promise<boolean>;
+type MigrationContext = {
+    all(): Promise<Record<string, unknown>>;
+};
+type MigrationFn = (old: MigrationContext) => Promise<Record<string, unknown>>;
 type Options = {
-    driver?: DriverType.IndexedDB | DriverType.LocalStorage;
+    driver?: DriverType.IndexedDB | DriverType.LocalStorage | DriverType.Memory | DriverType.SessionStorage;
+    migrations?: Record<number, MigrationFn>;
     name: string;
     version: number;
 };
-export type { Driver, Filter, Options };
+type SetOptions = {
+    ttl?: number;
+};
+type TTLEnvelope<V> = {
+    __e: number;
+    __v: 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 };

package/package.json

@@ -5,7 +5,10 @@
   },
   "description": "Web storage utility",
   "devDependencies": {
-    "@esportsplus/typescript": "^0.9.2"
+    "@esportsplus/typescript": "^0.9.2",
+    "fake-indexeddb": "^6.2.5",
+    "happy-dom": "^20.8.8",
+    "vitest": "^4.1.1"
   },
   "main": "build/index.js",
   "name": "@esportsplus/web-storage",
@@ -16,9 +19,10 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.3.5",
+  "version": "0.5.0",
   "scripts": {
     "build": "tsc && tsc-alias",
+    "test": "vitest run",
     "-": "-"
   }
 }

package/src/constants.ts

@@ -1,6 +1,8 @@
 enum DriverType {
     IndexedDB,
-    LocalStorage
+    LocalStorage,
+    Memory,
+    SessionStorage
 }
 
 export { DriverType };

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(),
@@ -112,13 +123,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 {