@ztimson/utils 0.24.7 → 0.24.9

package/dist/index.mjs

@@ -422,7 +422,7 @@ class Cache {
     return new Proxy(this, {
       get: (target, prop) => {
         if (prop in target) return target[prop];
-        return deepCopy(target.store[prop]);
+        return this.get(prop, true);
       },
       set: (target, prop, value) => {
         if (prop in target) target[prop] = value;
@@ -435,12 +435,16 @@ class Cache {
     if (!this.key) throw new Error("No key defined");
     return value[this.key];
   }
+  save() {
+    if (this.options.storageKey && this.options.storage)
+      this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+  }
   /**
    * Get all cached items
    * @return {T[]} Array of items
    */
-  all() {
-    return deepCopy(Object.values(this.store));
+  all(expired) {
+    return deepCopy(Object.values(this.store).filter((v) => expired || !v._expired));
   }
   /**
    * Add a new item to the cache. Like set, but finds key automatically
@@ -469,6 +473,7 @@ class Cache {
    * Remove all keys from cache
    */
   clear() {
+    this.complete = false;
     this.store = {};
   }
   /**
@@ -477,37 +482,51 @@ class Cache {
    */
   delete(key) {
     delete this.store[key];
-    if (this.options.storageKey && this.options.storage)
-      this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+    this.save();
   }
   /**
    * Return cache as an array of key-value pairs
    * @return {[K, T][]} Key-value pairs array
    */
-  entries() {
-    return Object.entries(this.store);
+  entries(expired) {
+    return deepCopy(Object.entries(this.store).filter((v) => expired || !v._expired));
+  }
+  /**
+   * Manually expire a cached item
+   * @param {K} key Key to expire
+   */
+  expire(key) {
+    this.complete = false;
+    if (this.options.expiryPolicy == "keep") this.store[key]._expired = true;
+    else this.delete(key);
   }
   /**
    * Get item from the cache
    * @param {K} key Key to lookup
    * @return {T} Cached item
    */
-  get(key) {
-    return deepCopy(this.store[key]);
+  get(key, expired) {
+    const cached = deepCopy(this.store[key] ?? null);
+    if (expired || !cached._expired) return cached;
+    return null;
   }
   /**
    * Get a list of cached keys
    * @return {K[]} Array of keys
    */
-  keys() {
-    return Object.keys(this.store);
+  keys(expired) {
+    return Object.keys(this.store).filter((k) => expired || !this.store[k]._expired);
   }
   /**
    * Get map of cached items
    * @return {Record<K, T>}
    */
-  map() {
-    return deepCopy(this.store);
+  map(expired) {
+    const copy = deepCopy(this.store);
+    if (!expired) Object.keys(copy).forEach((k) => {
+      if (copy[k]._expired) delete copy[k];
+    });
+    return copy;
   }
   /**
    * Add an item to the cache manually specifying the key
@@ -517,12 +536,12 @@ class Cache {
    * @return {this}
    */
   set(key, value, ttl = this.options.ttl) {
+    if (this.options.expiryPolicy == "keep") delete this.store[key]._expired;
     this.store[key] = value;
-    if (this.options.storageKey && this.options.storage)
-      this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+    this.save();
     if (ttl) setTimeout(() => {
-      this.complete = false;
-      this.delete(key);
+      this.expire(key);
+      this.save();
     }, ttl * 1e3);
     return this;
   }
@@ -1634,7 +1653,7 @@ class PathEvent {
     return PathEvent.filter(target, this);
   }
   /**
-   * Create  event string from its components
+   * Create event string from its components
    *
    * @return {string} String representation of Event
    */
@@ -1643,18 +1662,22 @@ class PathEvent {
   }
 }
 class PathEventEmitter {
-  constructor() {
+  constructor(prefix = "") {
     __publicField(this, "listeners", []);
+    this.prefix = prefix;
   }
   emit(event, ...args) {
-    const parsed = new PathEvent(event);
+    const parsed = new PathEvent(`${this.prefix}/${typeof event == "string" ? event : event.toString()}`);
     this.listeners.filter((l) => PathEvent.has(l[0], event)).forEach(async (l) => l[1](parsed, ...args));
   }
   off(listener) {
     this.listeners = this.listeners.filter((l) => l[1] != listener);
   }
   on(event, listener) {
-    makeArray(event).forEach((e) => this.listeners.push([new PathEvent(e), listener]));
+    makeArray(event).forEach((e) => this.listeners.push([
+      new PathEvent(`${this.prefix}/${typeof e == "string" ? event : event.toString()}`),
+      listener
+    ]));
     return () => this.off(listener);
   }
   once(event, listener) {