created a datamap and a dataset class that adds more basic methods

Author: cblanquera

package.json

@@ -48,13 +48,13 @@
       "require": "./cjs/data/cookie.js",
       "import": "./esm/data/cookie.js"
     },
-    "./map": {
-      "require": "./cjs/data/map.js",
-      "import": "./esm/data/map.js"
+    "./Map": {
+      "require": "./cjs/data/Map.js",
+      "import": "./esm/data/Map.js"
     },
-    "./set": {
-      "require": "./cjs/data/set.js",
-      "import": "./esm/data/set.js"
+    "./Set": {
+      "require": "./cjs/data/Set.js",
+      "import": "./esm/data/Set.js"
     },
     "./Nest": {
       "require": "./cjs/data/Nest.js",
@@ -131,8 +131,8 @@
       "Reflection": [ "./cjs/Reflection.d.ts" ],
       "Status": [ "./cjs/Status.d.ts" ],
       "cookie": [ "./cjs/data/cookie.d.ts" ],
-      "map": [ "./cjs/data/map.d.ts" ],
-      "set": [ "./cjs/data/set.d.ts" ],
+      "Map": [ "./cjs/data/Map.d.ts" ],
+      "Set": [ "./cjs/data/Set.d.ts" ],
       "Nest": [ "./cjs/data/Nest.d.ts" ],
       "ReadonlyMap": [ "./cjs/data/ReadonlyMap.d.ts" ],
       "ReadonlyNest": [ "./cjs/data/ReadonlyNest.d.ts" ],

src/data/Map.ts

@@ -0,0 +1,114 @@
+import type { 
+  CallableMap, 
+  DataMapFilter,
+  DataMapIterator
+} from '../types.js';
+
+/**
+ * Adding extra utility methods to the native Map class
+ * (that should have been there in the first place...)
+ */
+export default class DataMap<K = any, V = any> extends Map<K, V> {
+  /**
+   * Filters the data map (returns a new DataMap instance)
+   */
+  public filter(callback: DataMapFilter<K, V, this>) {
+    const entries = Array.from(this.entries()).filter(
+      entry => callback(entry[1], entry[0], this)
+    );
+    const constructor = this.constructor as new(map: [K, V][]) => this;
+    return new constructor(entries);
+  }
+
+  /**
+   * Finds the first entry that matches the callback
+   */
+  public find(callback: DataMapFilter<K, V, this>) {
+    for (const entry of this.entries()) {
+      if (callback(entry[1], entry[0], this)) {
+        return entry;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Finds the first key that matches the callback
+   */
+  public findKey(callback: DataMapFilter<K, V, this>) {
+    return this.find(callback)?.[0];
+  }
+
+  /**
+   * Finds the first value that matches the callback
+   */
+  public findValue(callback: DataMapFilter<K, V, this>) {
+    return this.find(callback)?.[1];
+  }
+
+  /**
+   * Maps the data map values to a new data map
+   */
+  public map<T>(callback: DataMapIterator<K, V, this, T>) {
+    const constructor = this.constructor as new() => DataMap<K, T>;
+    const map = new constructor();
+    for (const entry of this.entries()) {
+      map.set(entry[0], callback(entry[1], entry[0], this));
+    }
+    return map;
+  }
+};
+
+export function map<K = any, V = any> (data?: [K, V][]): CallableMap<K, V> {
+  const store = new DataMap<K, V>(data);
+  const callable = Object.assign(
+    (name: K) => store.get(name),
+    {
+      clear() {
+        return store.clear();
+      },
+      delete(name: K) {
+        return store.delete(name);
+      },
+      entries() {
+        return store.entries();
+      },
+      filter(callback: DataMapFilter<K, V, typeof store>) {
+        return store.filter(callback);
+      },
+      find(callback: DataMapFilter<K, V, typeof store>) {
+        return store.find(callback);
+      },
+      findKey(callback: DataMapFilter<K, V, typeof store>) {
+        return store.findKey(callback);
+      },
+      findValue(callback: DataMapFilter<K, V, typeof store>) {
+        return store.findValue(callback);
+      },
+      forEach(callback: DataMapIterator<K, V, Map<K, V>, void>) {
+        return store.forEach(callback);
+      },
+      get(name: K) {
+        return store.get(name);
+      },
+      has(name: K) {
+        return store.has(name);
+      },
+      keys() {
+        return store.keys();
+      },
+      map<T>(callback: DataMapIterator<K, V, typeof store, T>) {
+        return store.map<T>(callback);
+      },
+      set(name: K, value: V) {
+        return store.set(name, value);
+      },
+      values() {
+        return store.values();
+      }
+    } as DataMap<K, V>
+  );
+  //magic size property
+  Object.defineProperty(callable, 'size', { get: () => store.size });
+  return callable;
+};

src/data/Nest.ts

@@ -286,21 +286,43 @@ export function nest<M extends UnknownNest = UnknownNest>(data?: M): CallableNes
   const callable = Object.assign(
     <T = any>(...path: Key[]) => store.get<T>(...path),
     {
-      clear: () => store.clear(),
-      delete: (...path: Key[]) => store.delete(...path),
-      entries: () => store.entries(),
-      forEach: (...path: Key[]) => store.forEach(...path),
-      get: <T = any>(...path: Key[]) => store.get<T>(...path),
-      has: (...path: Key[]) => store.has(...path),
-      keys: () => store.keys(),
-      path: <T = any>(path: string, defaults?: TypeOf<T>) => store.path<T>(path, defaults),
-      set: (...path: any[]) => store.set(...path),
-      toString: () => store.toString(),
-      values: () => store.values(),
       withArgs: store.withArgs,
       withFormData: store.withFormData,
       withPath: store.withPath,
-      withQuery: store.withQuery
+      withQuery: store.withQuery,
+      clear() {
+        return store.clear();
+      },
+      delete(...path: Key[]) {
+        return store.delete(...path);
+      },
+      entries() {
+        return store.entries();
+      },
+      forEach(...path: Key[]) {
+        return store.forEach(...path);
+      },
+      get<T = any>(...path: Key[]) {
+        return store.get<T>(...path);
+      },
+      has(...path: Key[]) {
+        return store.has(...path);
+      },
+      keys() {
+        return store.keys();
+      },
+      path<T = any>(path: string, defaults?: TypeOf<T>) {
+        return store.path<T>(path, defaults);
+      },
+      set(...path: any[]) {
+        return store.set(...path);
+      },
+      toString() {
+        return store.toString();
+      },
+      values() {
+        return store.values();
+      }
     } as Nest<M>
   );
   //magic size/data property

src/data/ReadonlyMap.ts

@@ -1,12 +1,21 @@
-export default class ReadonlyMap<S = any, T = any> {
+import DataMap from './Map.js';
+
+export default class ReadonlyMap<K = any, V = any> {
   //map of map
-  protected _map: Map<S, T>;
+  protected _map: DataMap<K, V>;
+
+  /**
+   * Returns the size of the map
+   */
+  public get size() {
+    return this._map.size;
+  }
 
   /**
    * Sets the initial values of the map
    */
-  constructor(init?: [S, T][]) {
-    this._map = new Map(init);
+  constructor(init?: [K, V][]) {
+    this._map = new DataMap<K, V>(init);
   }
 
   /**
@@ -16,11 +25,55 @@ export default class ReadonlyMap<S = any, T = any> {
     return this._map.entries();
   }
 
+  /**
+   * Filters the data map (returns a new DataMap instance)
+   */
+  public filter(callback: (
+    value: V, 
+    key?: K, 
+    map?: DataMap<K, V>
+  ) => boolean) {
+    return this._map.filter(callback);
+  }
+
+  /**
+   * Finds the first entry that matches the callback
+   */
+  public find(callback: (
+    value: V, 
+    key?: K, 
+    map?: DataMap<K, V>
+  ) => boolean) {
+    return this._map.find(callback);
+  }
+
+  /**
+   * Finds the first key that matches the callback
+   */
+  public findKey(callback: (
+    value: V, 
+    key?: K, 
+    map?: DataMap<K, V>
+  ) => boolean) {
+    return this._map.findKey(callback);
+  }
+
+  /**
+   * Finds the first value that matches the callback
+   */
+  public findValue(callback: (
+    value: V, 
+    key?: K, 
+    map?: DataMap<K, V>
+  ) => boolean) {
+    return this._map.findValue(callback);
+  }
+
   /**
    * Iterates over the map
    */
   public forEach(
-    iterator: (value: T, key: S, set: Map<S, T>) => void, 
+    iterator: (value: V, key: K, set: Map<K, V>) => void, 
     arg?: unknown
   ) {
     return this._map.forEach(iterator, arg);
@@ -29,14 +82,14 @@ export default class ReadonlyMap<S = any, T = any> {
   /**
    * Returns the value of the map
    */
-  public get(key: S) {
+  public get(key: K) {
     return this._map.get(key);
   }
 
   /**
    * Returns whether the map has the value
    */
-  public has(key: S) {
+  public has(key: K) {
     return this._map.has(key);
   }
 
@@ -48,10 +101,14 @@ export default class ReadonlyMap<S = any, T = any> {
   }
 
   /**
-   * Returns the size of the map
+   * Maps the data map values to a new data map
    */
-  public get size() {
-    return this._map.size;
+  public map<T>(callback: (
+    value: V, 
+    key?: K, 
+    map?: DataMap<K, V>) => T
+  ) {
+    return this._map.map(callback);
   }
 
   /**