@ztimson/utils 0.24.3 → 0.24.4

package/dist/index.d.ts

@@ -19,3 +19,4 @@ export * from './search';
 export * from './string';
 export * from './time';
 export * from './types';
+export * from 'var-persist';

package/dist/index.mjs

@@ -1719,6 +1719,176 @@ function logicTest(target, condition) {
 function typeKeys() {
   return Object.keys({});
 }
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var dist = {};
+var persist$1 = {};
+Object.defineProperty(persist$1, "__esModule", { value: true });
+persist$1.persist = persist$1.Persist = void 0;
+class Persist {
+  /**
+   * @param {string} key Primary key value will be stored under
+   * @param {PersistOptions<T>} options Configure using {@link PersistOptions}
+   */
+  constructor(key, options = {}) {
+    __publicField(this, "key");
+    __publicField(this, "options");
+    /** Backend service to store data, must implement `Storage` interface */
+    __publicField(this, "storage");
+    /** Listeners which should be notified on changes */
+    __publicField(this, "watches", {});
+    /** Private value field */
+    __publicField(this, "_value");
+    this.key = key;
+    this.options = options;
+    this.storage = options.storage || localStorage;
+    this.load();
+  }
+  /** Current value or default if undefined */
+  get value() {
+    var _a;
+    return this._value !== void 0 ? this._value : (_a = this.options) == null ? void 0 : _a.default;
+  }
+  /** Set value with proxy object wrapper to sync future changes */
+  set value(v) {
+    if (v == null || typeof v != "object")
+      this._value = v;
+    else
+      this._value = new Proxy(v, {
+        get: (target, p) => {
+          const f = typeof target[p] == "function";
+          if (!f)
+            return target[p];
+          return (...args) => {
+            const value = target[p](...args);
+            this.save();
+            return value;
+          };
+        },
+        set: (target, p, newValue) => {
+          target[p] = newValue;
+          this.save();
+          return true;
+        }
+      });
+    this.save();
+  }
+  /** Notify listeners of change */
+  notify(value) {
+    Object.values(this.watches).forEach((watch) => watch(value));
+  }
+  /** Delete value from storage */
+  clear() {
+    this.storage.removeItem(this.key);
+  }
+  /** Save current value to storage */
+  save() {
+    if (this._value === void 0)
+      this.clear();
+    else
+      this.storage.setItem(this.key, JSON.stringify(this._value));
+    this.notify(this.value);
+  }
+  /** Load value from storage */
+  load() {
+    if (this.storage[this.key] != void 0) {
+      let value = JSON.parse(this.storage.getItem(this.key));
+      if (value != null && typeof value == "object" && this.options.type)
+        value.__proto__ = this.options.type.prototype;
+      this.value = value;
+    } else
+      this.value = this.options.default || void 0;
+  }
+  /**
+   * Callback function which is run when there are changes
+   *
+   * @param {(value: T) => any} fn Callback will run on each change; it's passed the next value & it's return is ignored
+   * @returns {() => void} Function which will unsubscribe the watch/callback when called
+   */
+  watch(fn2) {
+    const index = Object.keys(this.watches).length;
+    this.watches[index] = fn2;
+    return () => {
+      delete this.watches[index];
+    };
+  }
+  /**
+   * Return value as JSON string
+   *
+   * @returns {string} Stringified object as JSON
+   */
+  toString() {
+    return JSON.stringify(this.value);
+  }
+  /**
+   * Return current value
+   *
+   * @returns {T} Current value
+   */
+  valueOf() {
+    return this.value;
+  }
+}
+persist$1.Persist = Persist;
+function persist(options) {
+  return (target, prop) => {
+    const key = (options == null ? void 0 : options.key) || `${target.constructor.name}.${prop.toString()}`;
+    const wrapper = new Persist(key, options);
+    Object.defineProperty(target, prop, {
+      get: function() {
+        return wrapper.value;
+      },
+      set: function(v) {
+        wrapper.value = v;
+      }
+    });
+  };
+}
+persist$1.persist = persist;
+var memoryStorage = {};
+Object.defineProperty(memoryStorage, "__esModule", { value: true });
+memoryStorage.MemoryStorage = void 0;
+class MemoryStorage {
+  get length() {
+    return Object.keys(this).length;
+  }
+  clear() {
+    Object.keys(this).forEach((k) => this.removeItem(k));
+  }
+  getItem(key) {
+    return this[key];
+  }
+  key(index) {
+    return Object.keys(this)[index];
+  }
+  removeItem(key) {
+    delete this[key];
+  }
+  setItem(key, value) {
+    this[key] = value;
+  }
+}
+memoryStorage.MemoryStorage = MemoryStorage;
+(function(exports) {
+  var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  });
+  var __exportStar = commonjsGlobal && commonjsGlobal.__exportStar || function(m, exports2) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  __exportStar(persist$1, exports);
+  __exportStar(memoryStorage, exports);
+})(dist);
 export {
   ASet,
   ArgParser,