@superutils/store 0.1.14

package/dist/index.js

@@ -0,0 +1,317 @@
+// src/createObjectStore.ts
+import { objToMap, isObj } from "@superutils/core";
+
+// src/createStore.ts
+import { isFn as isFn2 } from "@superutils/core";
+
+// src/Store.ts
+import {
+  deferred,
+  fallbackIfFails,
+  filter,
+  find,
+  getEntries,
+  getKeys,
+  getValues,
+  isArr,
+  isArr2D,
+  isDefined,
+  isFn,
+  isMap,
+  isPositiveNumber,
+  isStr,
+  mapJoin,
+  search,
+  sort
+} from "@superutils/core";
+import { BehaviorSubject, skip, Subject } from "rxjs";
+
+// src/types/types.ts
+var Store_OnErrorType = /* @__PURE__ */ ((Store_OnErrorType2) => {
+  Store_OnErrorType2["onChange"] = "onChange";
+  Store_OnErrorType2["parse"] = "parse";
+  Store_OnErrorType2["parse_json"] = "parse-json";
+  Store_OnErrorType2["stringify"] = "stringify";
+  Store_OnErrorType2["stringify_json"] = "stringify-json";
+  Store_OnErrorType2["write"] = "write";
+  return Store_OnErrorType2;
+})(Store_OnErrorType || {});
+
+// src/Store.ts
+var forceUpdateCache$ = new Subject();
+var _Store = class _Store {
+  constructor(name, options) {
+    this.initialized = false;
+    this.subscriptions = {
+      subject: void 0,
+      forceUpdateCache: void 0
+    };
+    this.type = "map";
+    this.clear = () => this.setAll(/* @__PURE__ */ new Map(), true);
+    this.delete = (keys) => {
+      if (!isArr(keys)) keys = [keys];
+      const data = this.getAll();
+      for (const k of keys) data.delete(k);
+      this.setAll(data, true);
+      return this;
+    };
+    this.filter = (...args) => filter(this.getAll(), ...args);
+    this.find = (predicateOrOptions) => find(this.getAll(), predicateOrOptions);
+    this.get = (key) => this.getAll().get(key);
+    this.getAll = (forceRead = false) => {
+      const wasInitialized = this.initialized;
+      if (!wasInitialized) this.init();
+      const readFromStorage = this.cacheDisabled || this.storage && forceRead;
+      if (readFromStorage) {
+        const data = this.read();
+        const shouldTrigger = forceRead || !wasInitialized && !!data.size;
+        shouldTrigger && this.subject$.next(data);
+        return data;
+      }
+      return this.subject$.value;
+    };
+    this.handleForceUpdateCache = (name) => {
+      const isTarget = !this.name ? false : isArr(name) ? name.includes(this.name) : isStr(name) ? name === this.name : name === true;
+      if (!isTarget) return;
+      const newData = this.read();
+      this.subject$.next(newData);
+    };
+    this.handleSubjectChange = (data) => {
+      var _a;
+      if (!isMap(data)) return this.subject$.next(/* @__PURE__ */ new Map());
+      this.write(data);
+      fallbackIfFails(
+        (_a = this.onChange) == null ? void 0 : _a.bind(this),
+        [data],
+        this.triggerOnErrorCb("onChange" /* onChange */)
+      );
+    };
+    this.has = (key) => this.getAll().has(key);
+    this.init = (initialValue, checkStorage = true) => {
+      var _a;
+      if (this.initialized) return false;
+      this.initialized = true;
+      if (checkStorage && this.name && !this.storage)
+        throw new Error(_Store.messages.invalidOptionsStorage);
+      let isEmpty = !!this.cacheDisabled;
+      let firstValue = initialValue;
+      if (!!(initialValue == null ? void 0 : initialValue.size) || !this.cacheDisabled) {
+        const dataStr = this.name ? (_a = this.storage) == null ? void 0 : _a.getItem(this.name) : null;
+        const existingValue = this.read(dataStr != null ? dataStr : null);
+        if (isDefined(dataStr)) firstValue = existingValue;
+        isEmpty = this.cacheDisabled || existingValue.size === 0;
+      }
+      (firstValue == null ? void 0 : firstValue.size) && this.subject$.next(firstValue);
+      this.unsubscribe();
+      if (!this.cacheDisabled) {
+        this.subscriptions.forceUpdateCache = forceUpdateCache$.subscribe(
+          this.handleForceUpdateCache
+        );
+      }
+      this.subscriptions.subject = this.subject$.pipe(skip(isEmpty ? 0 : 1)).subscribe(
+        !this.cacheDisabled && this.delay > 0 ? deferred(this.handleSubjectChange, this.delay, {
+          thisArg: this,
+          ...this.delayOptions
+        }) : this.handleSubjectChange
+      );
+      return true;
+    };
+    this.keys = () => getKeys(this.getAll());
+    this.map = (callback) => this.toArray().map(
+      ([key, value], index, entries) => callback(value, key, entries, index)
+    );
+    this.read = (dataStr = ((_b) => (_b = this.name && ((_a) => (_a = this.storage) == null ? void 0 : _a.getItem(this.name))()) != null ? _b : null)()) => {
+      var _a2;
+      const data = fallbackIfFails(
+        this.parse,
+        [dataStr],
+        this.triggerOnErrorCb("parse" /* parse */, void 0)
+      );
+      if (isMap(data) || !isStr(dataStr))
+        return (_a2 = isFn(this.parse) ? data : this.subject$.value) != null ? _a2 : /* @__PURE__ */ new Map();
+      return new Map(
+        fallbackIfFails(
+          () => {
+            const entries = JSON.parse(dataStr);
+            if (!isArr2D(entries))
+              throw new Error(_Store.messages.invalidJsonEntries);
+            return entries;
+          },
+          [],
+          this.triggerOnErrorCb("parse-json" /* parse_json */)
+        )
+      );
+    };
+    this.search = (...args) => search(this.getAll(), ...args);
+    this.set = (key, value) => {
+      const data = this.getAll();
+      data.set(key, isFn(value) ? value(data.get(key)) : value);
+      return this.setAll(data, true);
+    };
+    this.setAll = (data, replace = false) => {
+      if (!isMap(data)) return this;
+      data = replace ? data : mapJoin(this.getAll(), data);
+      this.subject$.next(new Map(data));
+      return this;
+    };
+    this.sort = (...args) => {
+      var _a;
+      const result = sort(
+        this.getAll(),
+        args[0],
+        args[1]
+      );
+      ((_a = args[1]) == null ? void 0 : _a.save) && this.setAll(result, true);
+      return result;
+    };
+    this.toArray = () => getEntries(this.getAll());
+    this.toJSON = (replacer, spacing = this.spaces, data = this.getAll()) => {
+      const str = fallbackIfFails(
+        this.stringify,
+        [data],
+        this.triggerOnErrorCb("stringify" /* stringify */, "")
+        // if fails return empty string
+      );
+      if (isStr(str)) return str;
+      return fallbackIfFails(
+        () => JSON.stringify(
+          Array.from(data),
+          replacer,
+          spacing
+        ),
+        [],
+        this.triggerOnErrorCb("stringify-json" /* stringify_json */, "")
+      );
+    };
+    this.toObject = (data = this.getAll()) => {
+      const obj = {};
+      if (!isMap(data)) return obj;
+      for (const [key, value] of data)
+        obj[key] = value;
+      return obj;
+    };
+    this.toString = (data = this.getAll()) => this.toJSON(void 0, void 0, data);
+    this.triggerOnErrorCb = (type, returnValue = void 0) => (err) => {
+      var _a;
+      fallbackIfFails(
+        (_a = this.onError) == null ? void 0 : _a.bind(this),
+        [err, type],
+        ""
+      );
+      return returnValue;
+    };
+    this.unsubscribe = () => {
+      var _a, _b;
+      (_a = this.subscriptions.forceUpdateCache) == null ? void 0 : _a.unsubscribe();
+      (_b = this.subscriptions.subject) == null ? void 0 : _b.unsubscribe();
+      this.subscriptions = {};
+    };
+    this.values = () => getValues(this.getAll());
+    this.write = (data) => {
+      var _a;
+      try {
+        !this.initialized && this.init();
+        data != null ? data : data = (_a = this.subject$) == null ? void 0 : _a.value;
+        if (!isMap(data)) return false;
+        const jsonStr = this.toString(data);
+        if (!this.name || !this.storage) return false;
+        this.storage.setItem(this.name, jsonStr);
+        return true;
+      } catch (err) {
+        this.triggerOnErrorCb("write" /* write */)(err);
+        return false;
+      }
+    };
+    const {
+      cacheDisabled = false,
+      delay,
+      delayOptions,
+      initialValue,
+      onError,
+      onChange,
+      parse,
+      spaces,
+      storage = fallbackIfFails(
+        () => globalThis.localStorage,
+        [],
+        void 0
+      ),
+      stringify
+    } = options != null ? options : {};
+    this.name = `${name != null ? name : ""}`.trim() || null;
+    if (this.name && !storage && !(options == null ? void 0 : options.checkStorageOnInit))
+      throw new Error(_Store.messages.invalidOptionsStorage);
+    this.cacheDisabled = !!storage && cacheDisabled;
+    this.delay = delay === 0 || isPositiveNumber(delay) ? delay : 300;
+    this.delayOptions = delayOptions;
+    this.onError = onError;
+    this.onChange = onChange;
+    this.parse = parse == null ? void 0 : parse.bind(this);
+    this.storage = storage;
+    this.stringify = stringify == null ? void 0 : stringify.bind(this);
+    this.spaces = spaces;
+    this.subject$ = this.cacheDisabled ? new Subject() : new BehaviorSubject(/* @__PURE__ */ new Map());
+    isMap(initialValue) && initialValue.size && this.init(initialValue, false);
+  }
+  get size() {
+    return this.getAll().size;
+  }
+};
+_Store.messages = Object.seal({
+  invalidJsonEntries: "Invalid JSON format. Parsed value must be a 2D array representing key-value pairs.",
+  invalidOptionsStorage: "options.storage: LocalStorage instance or equivalent required"
+});
+/**
+ * Trigger forced update of cached data from storage.
+ *
+ * @param name determines which cache-enabled storage instances to be updated.
+ * - name (`string` | `string[]`): update all instances with a specific name(s)
+ * - global (`true`): update all instances globally
+ *
+ * See {@link forceUpdateCache$} for more details.
+ */
+_Store.forceUpdateCache = (name) => {
+  forceUpdateCache$.next(name);
+};
+var Store = _Store;
+var Store_default = Store;
+
+// src/createStore.ts
+function createStore(name, options) {
+  const store = new Store_default(name, options);
+  Object.defineProperty(store, "context", {
+    configurable: false,
+    enumerable: false,
+    value: isFn2(options == null ? void 0 : options.context) ? options.context(store) : options == null ? void 0 : options.context,
+    writable: false
+  });
+  return store;
+}
+var createStore_default = createStore;
+
+// src/createObjectStore.ts
+function createObjectStore(name, options) {
+  const store = createStore_default(name, {
+    parse: (str) => objToMap(JSON.parse(str != null ? str : "{}")),
+    stringify: function(data) {
+      return JSON.stringify(this.toObject(data));
+    },
+    ...options,
+    initialValue: !isObj(options == null ? void 0 : options.initialValue, true) ? options == null ? void 0 : options.initialValue : objToMap(options.initialValue)
+  });
+  store.type = "object";
+  return store;
+}
+
+// src/index.ts
+import { objToMap as objToMap2 } from "@superutils/core";
+var index_default = Store_default;
+export {
+  Store,
+  Store_OnErrorType,
+  createObjectStore,
+  createStore,
+  index_default as default,
+  forceUpdateCache$,
+  objToMap2 as objToMap
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+	"author": "Toufiqur Rahaman Chowdhury",
+	"description": "Generic, reactive, persistent and fully-typed Map-like data store with advanced search, filtering, and sorting capabilities.",
+	"dependencies": {
+		"@superutils/core": "^1.2.18",
+		"rxjs": "^7.8.2"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"keywords": [
+		"rxjs",
+		"utils",
+		"typescript",
+		"react",
+		"hooks"
+	],
+	"license": "MIT",
+	"main": "./dist/index.cjs",
+	"module": "./dist/index.js",
+	"name": "@superutils/store",
+	"peerDependencies": {
+		"@superutils/core": "*"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"_build": "tsc -p tsconfig.json",
+		"_watch": "tsc -p tsconfig.json --watch",
+		"build": "tsup --config ../../tsup.config.js",
+		"dev": "npm run build -- --watch",
+		"start": "npm run dev",
+		"test": "cd ../../ && npm run test store"
+	},
+	"sideEffects": false,
+	"type": "module",
+	"types": "./dist/index.d.ts",
+	"version": "0.1.14",
+	"gitHead": "9e526ce83ac97f6ba66a06a6d2e95798a4660823"
+}