fixed docs submodule

.gitmodules

@@ -1,5 +1,5 @@
 [submodule "docs"]
 	path = docs
-	url = git@git.zakscode.com:ztimson/utils.wiki.git
+	url = ../utils.wiki.git
 	branch = master
 	ignore = all

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.25.20",
+	"version": "0.25.24",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",

src/cache.ts

@@ -24,6 +24,8 @@ export class Cache<K extends string | number | symbol, T> {
 	[key: string | number | symbol]: CachedValue<T> | any;
 	/** Whether cache is complete */
 	complete = false;
+	/** Await initial loading */
+	loading!: Promise<void>;
 
 	/**
 	 * Create new cache
@@ -31,15 +33,21 @@ export class Cache<K extends string | number | symbol, T> {
 	 * @param options
 	 */
 	constructor(public readonly key?: keyof T, public readonly options: CacheOptions = {}) {
+		let resolve: any;
+		this.loading = new Promise(r => resolve = r);
 		if(options.storageKey && !options.storage && typeof(Storage) !== 'undefined') options.storage = localStorage;
 		if(options.storage) {
 			if(options.storage instanceof Table) {
-				(async () => this.addAll(await options.storage?.getAll()))()
+				(async () => {
+					this.addAll(await options.storage?.getAll(), false);
+					resolve();
+				})()
 			} else if(options.storageKey) {
 				const stored = options.storage?.getItem(options.storageKey);
 				if(stored != null) try { Object.assign(this.store, JSON.parse(stored)); } catch { }
+				resolve();
 			}
-		}
+		} else resolve();
 		return new Proxy(this, {
 			get: (target: this, prop: string | symbol) => {
 				if(prop in target) return (target as any)[prop];
@@ -59,10 +67,18 @@ export class Cache<K extends string | number | symbol, T> {
 		return <K>value[this.key];
 	}
 
-	private save(key: K) {
+	private save(key?: K) {
 		if(this.options.storage) {
 			if(this.options.storage instanceof Table) {
-				this.options.storage.put(key, this.store[key]);
+				if(key == null) {
+					const rows = this.entries();
+					rows.forEach(([k, v]) => this.options.storage?.put(k, v));
+					this.options.storage.getAllKeys().then(keys => {
+						rows.map(([k]) => k).filter(k => !keys.includes(k))
+							.forEach(k => this.options.storage?.delete(k));
+					})
+				} else if(this.store[key] === undefined) this.options.storage.delete(key);
+				else this.options.storage.put(key, this.store[key]);
 			} else if(this.options.storageKey) {
 				this.options.storage.setItem(this.options.storageKey, JSONSanitize(this.store));
 			}
@@ -109,6 +125,7 @@ export class Cache<K extends string | number | symbol, T> {
 	clear(): this {
 		this.complete = false;
 		this.store = <any>{};
+		this.save();
 		return this;
 	}
 

src/database.ts

@@ -1,5 +1,6 @@
 import {findByProp} from './array.ts';
 import {ASet} from './aset.ts';
+import {sleepWhile} from './time.ts';
 
 export type TableOptions = {
 	name: string;
@@ -7,11 +8,24 @@ export type TableOptions = {
 	autoIncrement?: boolean;
 };
 
+class AsyncLock {
+	private p = Promise.resolve();
+	run<T>(fn: () => Promise<T>): Promise<T> {
+		const res = this.p.then(fn, fn);
+		this.p = res.then(() => {}, () => {});
+		return res;
+}
+	}
+
 export class Database {
+	private schemaLock = new AsyncLock();
+	private upgrading = false;
+
 	connection!: Promise<IDBDatabase>;
-	ready = false;
 	tables!: TableOptions[];
 
+	get ready() { return !this.upgrading; }
+
 	constructor(public readonly database: string, tables?: (string | TableOptions)[], public version?: number) {
 		this.connection = new Promise((resolve, reject) => {
 			const req = indexedDB.open(this.database, this.version);
@@ -26,7 +40,7 @@ export class Database {
 				const db = req.result;
 				const existing = Array.from(db.objectStoreNames);
 				if(!tables) this.tables = existing.map(t => {
-					const tx = db.transaction(t, 'readonly', )
+					const tx = db.transaction(t, 'readonly');
 					const store = tx.objectStore(t);
 					return {name: t, key: <string>store.keyPath};
 				});
@@ -39,10 +53,11 @@ export class Database {
 					this.version = db.version;
 					resolve(db);
 				}
-				this.ready = true;
+				this.upgrading = false;
 			};
 
 			req.onupgradeneeded = () => {
+				this.upgrading = true;
 				const db = req.result;
 				const existingTables = new ASet(Array.from(db.objectStoreNames));
 				if(tables) {
@@ -52,7 +67,7 @@ export class Database {
 						const t = this.tables.find(findByProp('name', name));
 						db.createObjectStore(name, {
 							keyPath: t?.key,
-							autoIncrement: t?.autoIncrement || !t?.key
+							autoIncrement: t?.autoIncrement || !t?.key,
 						});
 					});
 				}
@@ -60,22 +75,30 @@ export class Database {
 		});
 	}
 
+	waitForUpgrade = () => sleepWhile(() => this.upgrading);
+
 	async createTable<K extends IDBValidKey = any, T = any>(table: string | TableOptions): Promise<Table<K, T>> {
+		return this.schemaLock.run(async () => {
 			if(typeof table == 'string') table = { name: table };
 			const conn = await this.connection;
 			if(!this.includes(table.name)) {
 				conn.close();
 				Object.assign(this, new Database(this.database, [...this.tables, table], (this.version ?? 0) + 1));
+				await this.connection;
 			}
 			return this.table<K, T>(table.name);
+		});
 	}
 
 	async deleteTable(table: string | TableOptions): Promise<void> {
+		return this.schemaLock.run(async () => {
 			if(typeof table == 'string') table = { name: table };
 			if(!this.includes(table.name)) return;
 			const conn = await this.connection;
 			conn.close();
-		Object.assign(this, new Database(this.database, this.tables.filter(t => t.name != table.name), (this.version ?? 0) + 1));
+			Object.assign(this, new Database(this.database, this.tables.filter(t => t.name != (<TableOptions>table).name), (this.version ?? 0) + 1));
+			await this.connection;
+		});
 	}
 
 	includes(name: any): boolean {
@@ -96,12 +119,13 @@ export class Table<K extends IDBValidKey = any, T = any> {
 	}
 
 	async tx<R>(table: string, fn: (store: IDBObjectStore) => IDBRequest, readonly = false): Promise<R> {
+		await this.database.waitForUpgrade();
 		const db = await this.database.connection;
 		const tx = db.transaction(table, readonly ? 'readonly' : 'readwrite');
 		const store = tx.objectStore(table);
 		return new Promise<R>((resolve, reject) => {
 			const request = fn(store);
-			request.onsuccess = () => resolve(request.result as R); // ✅ explicit cast
+			request.onsuccess = () => resolve(request.result as R);
 			request.onerror = () => reject(request.error);
 		});
 	}