@superutils/store 0.1.14

package/dist/index.cjs

@@ -0,0 +1,331 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Store: () => Store,
+  Store_OnErrorType: () => Store_OnErrorType,
+  createObjectStore: () => createObjectStore,
+  createStore: () => createStore,
+  default: () => index_default,
+  forceUpdateCache$: () => forceUpdateCache$,
+  objToMap: () => import_core4.objToMap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createObjectStore.ts
+var import_core3 = require("@superutils/core");
+
+// src/createStore.ts
+var import_core2 = require("@superutils/core");
+
+// src/Store.ts
+var import_core = require("@superutils/core");
+var import_rxjs = require("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 import_rxjs.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 (!(0, import_core.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) => (0, import_core.filter)(this.getAll(), ...args);
+    this.find = (predicateOrOptions) => (0, import_core.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 : (0, import_core.isArr)(name) ? name.includes(this.name) : (0, import_core.isStr)(name) ? name === this.name : name === true;
+      if (!isTarget) return;
+      const newData = this.read();
+      this.subject$.next(newData);
+    };
+    this.handleSubjectChange = (data) => {
+      var _a;
+      if (!(0, import_core.isMap)(data)) return this.subject$.next(/* @__PURE__ */ new Map());
+      this.write(data);
+      (0, import_core.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 ((0, import_core.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((0, import_rxjs.skip)(isEmpty ? 0 : 1)).subscribe(
+        !this.cacheDisabled && this.delay > 0 ? (0, import_core.deferred)(this.handleSubjectChange, this.delay, {
+          thisArg: this,
+          ...this.delayOptions
+        }) : this.handleSubjectChange
+      );
+      return true;
+    };
+    this.keys = () => (0, import_core.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 = (0, import_core.fallbackIfFails)(
+        this.parse,
+        [dataStr],
+        this.triggerOnErrorCb("parse" /* parse */, void 0)
+      );
+      if ((0, import_core.isMap)(data) || !(0, import_core.isStr)(dataStr))
+        return (_a2 = (0, import_core.isFn)(this.parse) ? data : this.subject$.value) != null ? _a2 : /* @__PURE__ */ new Map();
+      return new Map(
+        (0, import_core.fallbackIfFails)(
+          () => {
+            const entries = JSON.parse(dataStr);
+            if (!(0, import_core.isArr2D)(entries))
+              throw new Error(_Store.messages.invalidJsonEntries);
+            return entries;
+          },
+          [],
+          this.triggerOnErrorCb("parse-json" /* parse_json */)
+        )
+      );
+    };
+    this.search = (...args) => (0, import_core.search)(this.getAll(), ...args);
+    this.set = (key, value) => {
+      const data = this.getAll();
+      data.set(key, (0, import_core.isFn)(value) ? value(data.get(key)) : value);
+      return this.setAll(data, true);
+    };
+    this.setAll = (data, replace = false) => {
+      if (!(0, import_core.isMap)(data)) return this;
+      data = replace ? data : (0, import_core.mapJoin)(this.getAll(), data);
+      this.subject$.next(new Map(data));
+      return this;
+    };
+    this.sort = (...args) => {
+      var _a;
+      const result = (0, import_core.sort)(
+        this.getAll(),
+        args[0],
+        args[1]
+      );
+      ((_a = args[1]) == null ? void 0 : _a.save) && this.setAll(result, true);
+      return result;
+    };
+    this.toArray = () => (0, import_core.getEntries)(this.getAll());
+    this.toJSON = (replacer, spacing = this.spaces, data = this.getAll()) => {
+      const str = (0, import_core.fallbackIfFails)(
+        this.stringify,
+        [data],
+        this.triggerOnErrorCb("stringify" /* stringify */, "")
+        // if fails return empty string
+      );
+      if ((0, import_core.isStr)(str)) return str;
+      return (0, import_core.fallbackIfFails)(
+        () => JSON.stringify(
+          Array.from(data),
+          replacer,
+          spacing
+        ),
+        [],
+        this.triggerOnErrorCb("stringify-json" /* stringify_json */, "")
+      );
+    };
+    this.toObject = (data = this.getAll()) => {
+      const obj = {};
+      if (!(0, import_core.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;
+      (0, import_core.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 = () => (0, import_core.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 (!(0, import_core.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 = (0, import_core.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 || (0, import_core.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 import_rxjs.Subject() : new import_rxjs.BehaviorSubject(/* @__PURE__ */ new Map());
+    (0, import_core.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: (0, import_core2.isFn)(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) => (0, import_core3.objToMap)(JSON.parse(str != null ? str : "{}")),
+    stringify: function(data) {
+      return JSON.stringify(this.toObject(data));
+    },
+    ...options,
+    initialValue: !(0, import_core3.isObj)(options == null ? void 0 : options.initialValue, true) ? options == null ? void 0 : options.initialValue : (0, import_core3.objToMap)(options.initialValue)
+  });
+  store.type = "object";
+  return store;
+}
+
+// src/index.ts
+var import_core4 = require("@superutils/core");
+var index_default = Store_default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Store,
+  Store_OnErrorType,
+  createObjectStore,
+  createStore,
+  forceUpdateCache$,
+  objToMap
+});