Optimize + refactor code

src/utils/local-db/local-db.ts

@@ -0,0 +1,79 @@
+export abstract class LocalDb {
+    static readonly DB_NAME = 'BetterXcloud';
+    static readonly DB_VERSION = 1;
+
+    private db: any;
+
+    protected open() {
+        return new Promise<void>((resolve, reject) => {
+            if (this.db) {
+                resolve();
+                return;
+            }
+
+            const request = window.indexedDB.open(LocalDb.DB_NAME, LocalDb.DB_VERSION);
+            request.onupgradeneeded = this.onUpgradeNeeded;
+
+            request.onerror = e => {
+                console.log(e);
+                alert((e.target as any).error.message);
+                reject && reject();
+            };
+
+            request.onsuccess = e => {
+                this.db = (e.target as any).result;
+                resolve();
+            };
+        });
+    }
+
+    protected abstract onUpgradeNeeded(e: IDBVersionChangeEvent): void;
+
+    protected table(name: string, type: string): Promise<IDBObjectStore> {
+        const transaction = this.db.transaction(name, type || 'readonly');
+        const table = transaction.objectStore(name);
+
+        return new Promise(resolve => resolve(table));
+    }
+
+    // Convert IndexDB method to Promise
+    protected call(method: any) {
+        const table = arguments[1];
+        return new Promise(resolve => {
+            const request = method.call(table, ...Array.from(arguments).slice(2));
+            request.onsuccess = (e: Event) => {
+                resolve([table, (e.target as any).result]);
+            };
+        });
+    }
+
+    protected count(table: IDBObjectStore): Promise<[IDBObjectStore, number]> {
+        // @ts-ignore
+        return this.call(table.count, ...arguments);
+    }
+
+    protected add(table: IDBObjectStore, data: any): Promise<[IDBObjectStore, number]> {
+        // @ts-ignore
+        return this.call(table.add, ...arguments);
+    }
+
+    protected put(table: IDBObjectStore, data: any): Promise<[IDBObjectStore, number]> {
+        // @ts-ignore
+        return this.call(table.put, ...arguments);
+    }
+
+    protected delete(table: IDBObjectStore, data: any): Promise<[IDBObjectStore, number]> {
+        // @ts-ignore
+        return this.call(table.delete, ...arguments);
+    }
+
+    protected get(table: IDBObjectStore, id: number): Promise<any> {
+        // @ts-ignore
+        return this.call(table.get, ...arguments);
+    }
+
+    protected getAll(table: IDBObjectStore): Promise<[IDBObjectStore, any]> {
+        // @ts-ignore
+        return this.call(table.getAll, ...arguments);
+    }
+}

src/utils/local-db/mkb-presets-db.ts

@@ -0,0 +1,96 @@
+import { PrefKey } from "@/enums/pref-keys";
+import { MkbPreset } from "@/modules/mkb/mkb-preset";
+import type { MkbStoredPreset, MkbStoredPresets } from "@/types/mkb";
+import { setPref } from "../settings-storages/global-settings-storage";
+import { t } from "../translation";
+import { LocalDb } from "./local-db";
+import { BxLogger } from "../bx-logger";
+
+export class MkbPresetsDb extends LocalDb {
+    private static instance: MkbPresetsDb;
+    public static getInstance = () => MkbPresetsDb.instance ?? (MkbPresetsDb.instance = new MkbPresetsDb());
+    private readonly LOG_TAG = 'MkbPresetsDb';
+
+    private readonly TABLE_PRESETS = 'mkb_presets';
+
+    private constructor() {
+        super();
+        BxLogger.info(this.LOG_TAG, 'constructor()');
+    }
+
+    protected onUpgradeNeeded(e: IDBVersionChangeEvent): void {
+        const db = (e.target! as any).result;
+        switch (e.oldVersion) {
+            case 0: {
+                const presets = db.createObjectStore(this.TABLE_PRESETS, {
+                    keyPath: 'id',
+                    autoIncrement: true,
+                });
+                presets.createIndex('name_idx', 'name');
+                break;
+            }
+        }
+    }
+
+    private presetsTable() {
+        return this.open()
+            .then(() => this.table(this.TABLE_PRESETS, 'readwrite'))
+    }
+
+    newPreset(name: string, data: any) {
+        return this.presetsTable()
+            .then(table => this.add(table, {name, data}))
+            .then(([table, id]) => new Promise<number>(resolve => resolve(id)));
+    }
+
+    updatePreset(preset: MkbStoredPreset) {
+        return this.presetsTable()
+            .then(table => this.put(table, preset))
+            .then(([table, id]) => new Promise(resolve => resolve(id)));
+    }
+
+    deletePreset(id: number) {
+        return this.presetsTable()
+            .then(table => this.delete(table, id))
+            .then(([table, id]) => new Promise(resolve => resolve(id)));
+    }
+
+    getPreset(id: number): Promise<MkbStoredPreset> {
+        return this.presetsTable()
+            .then(table => this.get(table, id))
+            .then(([table, preset]) => new Promise(resolve => resolve(preset)));
+    }
+
+    getPresets(): Promise<MkbStoredPresets> {
+        return this.presetsTable()
+            .then(table => this.count(table))
+            .then(([table, count]) => {
+                if (count > 0) {
+                    return new Promise(resolve => {
+                        this.getAll(table)
+                            .then(([table, items]) => {
+                                const presets: MkbStoredPresets = {};
+                                items.forEach((item: MkbStoredPreset) => (presets[item.id!] = item));
+                                resolve(presets);
+                            });
+                    });
+                }
+
+                // Create "Default" preset when the table is empty
+                const preset: MkbStoredPreset = {
+                    name: t('default'),
+                    data: MkbPreset.DEFAULT_PRESET,
+                }
+
+                return new Promise<MkbStoredPresets>(resolve => {
+                    this.add(table, preset)
+                        .then(([table, id]) => {
+                            preset.id = id;
+                            setPref(PrefKey.MKB_DEFAULT_PRESET_ID, id);
+
+                            resolve({[id]: preset});
+                        });
+                });
+            });
+    }
+}