@ztimson/utils 0.24.2 → 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

@@ -1439,7 +1439,7 @@ function PE(str, ...args) {
     if (str[i]) combined.push(str[i]);
     if (args[i]) combined.push(args[i]);
   }
-  return new PathEvent(combined.join(""));
+  return new PathEvent(combined.join("/"));
 }
 function PES(str, ...args) {
   let combined = [];
@@ -1498,28 +1498,28 @@ class PathEvent {
     return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("c"));
   }
   set create(v) {
-    v ? this.methods.delete("n").add("c") : this.methods.delete("c");
+    v ? this.methods.delete("n").delete("*").add("c") : this.methods.delete("c");
   }
   /** Read method specified */
   get read() {
     return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("r"));
   }
   set read(v) {
-    v ? this.methods.delete("n").add("r") : this.methods.delete("r");
+    v ? this.methods.delete("n").delete("*").add("r") : this.methods.delete("r");
   }
   /** Update method specified */
   get update() {
     return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("u"));
   }
   set update(v) {
-    v ? this.methods.delete("n").add("u") : this.methods.delete("u");
+    v ? this.methods.delete("n").delete("*").add("u") : this.methods.delete("u");
   }
   /** Delete method specified */
   get delete() {
     return !this.methods.has("n") && (this.methods.has("*") || this.methods.has("d"));
   }
   set delete(v) {
-    v ? this.methods.delete("n").add("d") : this.methods.delete("d");
+    v ? this.methods.delete("n").delete("*").add("d") : this.methods.delete("d");
   }
   /**
    * Combine multiple  events into one parsed object. Longest path takes precedent, but all subsequent methods are
@@ -1677,11 +1677,11 @@ function search(rows, search2, regex, transform = (r) => r) {
         }
       }).length;
     } else {
-      return testCondition(search2, r);
+      return logicTest(r, search2);
     }
   });
 }
-function testCondition(condition, row) {
+function logicTest(target, condition) {
   const evalBoolean = (a, op, b) => {
     switch (op) {
       case "=":
@@ -1707,10 +1707,10 @@ function testCondition(condition, row) {
     return and.filter((p2) => {
       const prop = /(\S+)\s*(==?|!=|>=|>|<=|<)\s*(\S+)/g.exec(p2);
       if (prop) {
-        const key = Object.keys(row).find((k) => k.toLowerCase() == prop[1].toLowerCase());
-        return evalBoolean(dotNotation(row, key || prop[1]), prop[2], JSONAttemptParse(prop[3]));
+        const key = Object.keys(target).find((k) => k.toLowerCase() == prop[1].toLowerCase());
+        return evalBoolean(dotNotation(target, key || prop[1]), prop[2], JSONAttemptParse(prop[3]));
       }
-      const v = Object.values(row).map((v2) => typeof v2 == "object" && v2 != null ? JSON.stringify(v2) : v2).join("");
+      const v = Object.values(target).map(JSONSerialize).join("");
       if (/[A-Z]/g.test(condition)) return v.includes(p2);
       return v.toLowerCase().includes(p2);
     }).length == and.length;
@@ -1719,6 +1719,176 @@ function testCondition(condition, row) {
 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,
@@ -1791,6 +1961,7 @@ export {
   instantInterval,
   isEqual,
   kebabCase,
+  logicTest,
   makeArray,
   makeUnique,
   matchAll,
@@ -1808,7 +1979,6 @@ export {
   snakeCase,
   sortByProp,
   strSplice,
-  testCondition,
   timeUntil,
   timestampFilename,
   toCsv,