fixed mapping return

Author: cblanquera

src/data/Map.ts

@@ -24,9 +24,9 @@ export default class DataMap<K = any, V = any> extends Map<K, V> {
    * 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;
+    for (const [ key, value ] of this.entries()) {
+      if (callback(value, key, this)) {
+        return [ key, value ] as [ K, V ];
       }
     }
     return undefined;
@@ -60,11 +60,18 @@ export default class DataMap<K = any, V = any> extends Map<K, V> {
     return map;
   }
 
+  /**
+   * Returns the data set as a plain array
+   */
+  public toArray() {
+    return Array.from(this.values());
+  }
+
   /**
    * Returns the data map as a plain object
    */
   public toObject() {
-    return Object.fromEntries(Object.entries(this));
+    return Object.fromEntries(this) as Record<string, V>;
   }
 
   /**

src/data/Set.ts

@@ -27,7 +27,7 @@ export default class DataSet<V = any> extends Set<V> {
     const values = this.toArray();
     for (let i = 0; i < values.length; i++) {
       if (callback(values[i], i, this)) {
-        return [ i, values[i] ] as [number, V];
+        return [ i, values[i] ] as [ number, V ];
       }
     }
     return undefined;

tests/Map.test.ts

@@ -3,8 +3,142 @@ import { expect } from 'chai';
 //NOTE: no extensions in tests because it's excluded in tsconfig.json and
 //we are testing in a typescript environment via `ts-mocha -r tsx` (esm)
 import type { CallableMap, CallableSet } from '../src/types';
-import { map } from '../src/data/Map';
-import { set } from '../src/data/Set';
+import DataMap, { map } from '../src/data/Map';
+import DataSet, { set } from '../src/data/Set';
+
+describe('DataMap Tests', () => {
+  it('Should get by name', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    expect(store.has('one')).to.be.true;
+    expect(store.has('two')).to.be.true;
+    expect(store.has('three')).to.be.true;
+    expect(store.has('four')).to.be.false;
+    
+    expect(store.get('one')).to.equal(1);
+    expect(store.get('two')).to.equal(2);
+    expect(store.get('three')).to.equal(3);
+    expect(store.get('four')).to.be.undefined;
+  });
+
+  it('Should convert to plain object', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    const object = store.toObject();
+    expect(object).to.deep.equal({ one: 1, two: 2, three: 3 });
+  });
+
+  it('Should convert to JSON string', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    const json = store.toString();
+    expect(json).to.equal('{"one":1,"two":2,"three":3}');
+  });
+
+  it('Should filter entries', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    const filtered = store.filter((value) => value >= 2);
+    expect(filtered.toObject()).to.deep.equal({ two: 2, three: 3 });
+  });
+
+  it('Should find entries', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    const foundEntry = store.find((value) => value === 2);
+    expect(foundEntry).to.deep.equal([ 'two', 2 ]);
+
+    const foundKey = store.findKey((value) => value === 3);
+    expect(foundKey).to.equal('three');
+
+    const foundValue = store.findValue((value) => value === 1);
+    expect(foundValue).to.equal(1);
+  });
+
+  it('Should map entries', async () => {
+    const store = new DataMap<string, number>();
+    store.set('one', 1);
+    store.set('two', 2);
+    store.set('three', 3);
+
+    const mapped = store.map((value) => value * 10);
+    expect(mapped.toObject()).to.deep.equal({
+      one: 10,
+      two: 20,
+      three: 30
+    });
+  });
+});
+
+describe('DataSet Tests', () => {
+  it('Should convert to array', async () => {
+    const store = new DataSet<string>();
+    store.add('foo');
+    store.add('bar');
+    store.add('baz');
+
+    const arr = store.toArray();
+    expect(arr).to.deep.equal([ 'foo', 'bar', 'baz' ]);
+  });
+
+  it('Should convert to JSON string', async () => {
+    const store = new DataSet<string>();
+    store.add('foo');
+    store.add('bar');
+    store.add('baz');
+
+    const json = store.toString();
+    expect(json).to.equal('["foo","bar","baz"]');
+  });
+
+  it('Should filter entries', async () => {
+    const store = new DataSet<number>();
+    store.add(1);
+    store.add(2);
+    store.add(3);
+
+    const filtered = store.filter((value) => value >= 2);
+    expect(filtered.toArray()).to.deep.equal([ 2, 3 ]);
+  });
+
+  it('Should find entries', async () => {
+    const store = new DataSet<number>();
+    store.add(1);
+    store.add(2);
+    store.add(3);
+
+    const foundIndex = store.findIndex((value) => value === 2);
+    expect(foundIndex).to.equal(1);
+
+    const foundValue = store.findValue((value) => value === 3);
+    expect(foundValue).to.equal(3);
+  });
+
+  it('Should map entries', async () => {
+    const store = new DataSet<number>();
+    store.add(1);
+    store.add(2);
+    store.add(3);
+
+    const mapped = store.map((value) => value * 10);
+    expect(mapped.toArray()).to.deep.equal([ 10, 20, 30 ]);
+  });
+});
 
 describe('map() Tests', () => {
   it('Should be callable', async () => {