@vnejs/plugins.core.storage 0.0.1

package/const/events.js

@@ -0,0 +1,11 @@
+export const SUBSCRIBE_EVENTS = {
+  SET: "vne:storage:set",
+  SET_ALL: "vne:storage:set_all",
+  GET: "vne:storage:get",
+  GET_ALL: "vne:storage:get_all",
+  RM: "vne:storage:rm",
+  CHANGED: "vne:storage:changed",
+  IMPORT: "vne:storage:import",
+  EXPORT: "vne:storage:export",
+  CLEAR: "vne:storage:clear",
+};

package/index.js

@@ -0,0 +1,7 @@
+import { regPlugin } from "@vnejs/shared";
+
+import { SUBSCRIBE_EVENTS } from "./const/events";
+
+import { Storage } from "./modules/storage";
+
+regPlugin("STORAGE", { events: SUBSCRIBE_EVENTS }, [Storage]);

package/modules/storage.js

@@ -0,0 +1,126 @@
+import localforage from "localforage";
+
+import { Module } from "@vnejs/module";
+
+export class Storage extends Module {
+  name = "storage";
+
+  subscribe = () => {
+    this.on(this.EVENTS.STORAGE.SET, this.onStorageSet);
+    this.on(this.EVENTS.STORAGE.SET_ALL, this.onStorageSetAll);
+    this.on(this.EVENTS.STORAGE.GET, this.onStorageGet);
+    this.on(this.EVENTS.STORAGE.RM, this.onStorageRm);
+    this.on(this.EVENTS.STORAGE.EXPORT, this.onStorageExport);
+    this.on(this.EVENTS.STORAGE.IMPORT, this.onStorageImport);
+    this.on(this.EVENTS.STORAGE.CLEAR, this.onStorageClear);
+  };
+  init = () =>
+    new Promise((resolve) => {
+      const { version = 0, gameName = "defaultGameName" } = this.options?.global || {};
+      const name = `vne_store_${gameName}`;
+      localforage.ready(resolve);
+      localforage.config({ driver: localforage.INDEXEDDB, name, storeName: name, description: name, version });
+    });
+
+  onStorageSet = async ({ prefix, key, value }) => {
+    if (!this.isReady) await this.waitIsReady();
+
+    await localforage.setItem(prefix ? `${prefix}.${key}` : key, value);
+
+    this.emit(this.EVENTS.STORAGE.CHANGED);
+  };
+
+  onStorageSetAll = async ({ storage }) => {
+    if (!this.isReady) await this.waitIsReady();
+
+    let wasChanged = false;
+
+    await Promise.all(
+      Object.keys(storage).map(async (key) => {
+        const value = await localforage.getItem(key);
+        if (value !== storage[key]) {
+          wasChanged = true;
+          await localforage.setItem(key, storage[key]);
+        }
+      })
+    );
+
+    const keys = await localforage.keys();
+
+    await Promise.all(
+      keys.map(async (key) => {
+        if (storage[key] === undefined) {
+          wasChanged = true;
+          await localforage.removeItem(key);
+        }
+      })
+    );
+
+    await this.emit(this.EVENTS.STORAGE.CHANGED);
+
+    return wasChanged;
+  };
+
+  onStorageGet = async ({ prefix = "", key = "" } = {}) => {
+    if (!this.isReady) await this.waitIsReady();
+
+    const result = {};
+
+    if (key) {
+      const keyWithPrefix = prefix ? `${prefix}.${key}` : key;
+
+      result[key] = await localforage.getItem(keyWithPrefix);
+    } else {
+      const keys = await localforage.keys();
+      const realKeys = prefix ? keys.filter((key) => key.startsWith(prefix)) : keys;
+
+      await Promise.all(
+        realKeys.map(async (key) => {
+          result[prefix ? key.slice(prefix.length + 1) : key] = await localforage.getItem(key);
+        })
+      );
+    }
+
+    return result;
+  };
+
+  onStorageRm = async ({ prefix, key }) => {
+    if (!this.isReady) await this.waitIsReady();
+
+    localforage.removeItem(`${prefix}.${key}`);
+
+    this.emit(this.EVENTS.STORAGE.CHANGED);
+  };
+
+  onStorageExport = async () => {
+    if (!this.isReady) await this.waitIsReady();
+
+    const state = await this.onStorageGet();
+
+    await this.emit(this.EVENTS.SYSTEM.FILE_LOAD, { obj: state, name: "state" });
+
+    return state;
+  };
+
+  onStorageImport = async () => {
+    if (!this.isReady) await this.waitIsReady();
+
+    const [newStorage] = await this.emit(this.EVENTS.SYSTEM.FILE_READ);
+    if (!newStorage) return;
+
+    const keys = await localforage.keys();
+    await Promise.all(keys.map((key) => localforage.removeItem(key)));
+    await Promise.all(Object.keys(newStorage).map((key) => localforage.setItem(key, newStorage[key])));
+
+    await this.emit(this.EVENTS.SYSTEM.RELOAD);
+  };
+
+  onStorageClear = async () => {
+    if (!this.isReady) await this.waitIsReady();
+
+    const keys = await localforage.keys();
+    await Promise.all(keys.map((key) => localforage.removeItem(key)));
+
+    await this.emit(this.EVENTS.SYSTEM.RELOAD);
+  };
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@vnejs/plugins.core.storage",
+  "version": "0.0.1",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "publish:major": "npm version major && npm publish --access public",
+    "publish:minor": "npm version minor && npm publish --access public",
+    "publish:patch": "npm version patch && npm publish --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "localforage": "1.10.0"
+  },
+  "peerDependencies": {
+    "@vnejs/shared": "*",
+    "@vnejs/module": "*"
+  }
+}