fix case insensitive primitives

Author: gregolsky

src/Primitives/CaseInsensitiveKeysMap.ts

@@ -1,33 +1,5 @@
 import { TypeUtil } from "../Utility/TypeUtil";
-import { stringify } from "qs";
-
-const originalKeysMap: WeakMap<Map<string, any>, Map<string, string>>
-    = new WeakMap();
-
-function getOriginalKey(targetMap: Map<string, any>, key: string) {
-    const keysMap = originalKeysMap.get(targetMap);
-    return keysMap.get(key);
-}
-
-function setOriginalKey(targetMap: Map<string, any>, origKey: string, lowerKey: string) {
-    let keysMap;
-    if (!originalKeysMap.has(targetMap)) {
-        keysMap = new Map<string, string>();
-        originalKeysMap.set(targetMap, keysMap);
-    } else {
-        keysMap = originalKeysMap.get(targetMap);
-    }
-
-    keysMap.set(lowerKey, origKey);
-}
-
-function deleteOriginalKey(targetMap: Map<string, any>, lowerKey: string) {
-    if (!originalKeysMap.has(targetMap)) {
-        return;
-    }
-
-    originalKeysMap.get(targetMap).delete(lowerKey);
-}
+import { CaseInsensitiveKeysStore } from "./CaseInsensitiveKeysStore";
 
 function validateKey(key) {
     if (TypeUtil.isNullOrUndefined(key)
@@ -38,9 +10,6 @@ function validateKey(key) {
     throw Error("Key must be a string.");
 }
 
-function normalizeKey(key: string) {
-    return key ? key.toLowerCase() : key;
-}
 export class CaseInsensitiveKeysMap {
 
     public static create<TValue>(): Map<string, TValue> {
@@ -50,45 +19,52 @@ export class CaseInsensitiveKeysMap {
         const origHas = result.has;
         const origDelete = result.delete;
 
+        const originalKeysStore = new CaseInsensitiveKeysStore();
+
         result["keysCaseSensitive"] = false;
         result.set = function (...args) {
             const [ key, ...rest ] = args;
             validateKey(key);
-            const lowerKey = normalizeKey(key);
-            setOriginalKey(result, key, lowerKey);
+            const lowerKey = originalKeysStore.setKey(key);
             return origSet.call(result, lowerKey, ...rest);
         };
 
         result.get = function (...args) {
             const [ key, ...rest ] = args;
-            validateKey(key);
-            const lowerKey = normalizeKey(key);
+            const lowerKey = originalKeysStore.normalizeKey(key);
             return origGet.call(result, lowerKey, ...rest);
         };
 
         result.has = function (...args) {
             const [ key, ...rest ] = args;
-            validateKey(key);
-            const lowerKey = normalizeKey(key);
+            const lowerKey = originalKeysStore.normalizeKey(key);
             return origHas.call(result, lowerKey, ...rest);
         };
 
         result.delete = function (...args) {
             const [ key, ...rest ] = args;
             validateKey(key);
-            const lowerKey = normalizeKey(key);
-            deleteOriginalKey(result, lowerKey);
+            const lowerKey = originalKeysStore.deleteKey(key);
             return origDelete.call(result, lowerKey, ...rest);
         };
 
         const origEntries = result.entries;
         result.entries = function () {
             return Array.from(origEntries.call(result) as Iterable<[string, TValue]>)
                 .reduce((reduced, next) => {
-                    const actualKey = getOriginalKey(result, next[0]);
+                    const actualKey = originalKeysStore.getKey(next[0]);
+                    return [...reduced, [actualKey, next[1]]];
+                }, [])[Symbol.iterator]();
+        };
+
+        result[Symbol.iterator] = function () {
+            return Array.from(origEntries.call(result) as Iterable<[string, TValue]>)
+                .reduce((reduced, next) => {
+                    const actualKey = originalKeysStore.getKey(next[0]);
                     return [...reduced, [actualKey, next[1]]];
                 }, [])[Symbol.iterator]();
         };
+            
 
         return result;
     }

src/Primitives/CaseInsensitiveKeysStore.ts

@@ -0,0 +1,75 @@
+
+// export class CaseInsensitiveKeysStore<T extends object> {
+
+//     private _originalKeys: WeakMap<T, Map<string, string>> = new WeakMap();
+
+//     public getKey(target: T, key: string) {
+//         const keysMap = this._originalKeys.get(target);
+//         return keysMap.get(key);
+//     }
+
+//     public getKeys(target: T): IterableIterator<string> {
+//         const keysMap = this._originalKeys.get(target);
+//         return keysMap.values();
+//     }
+
+//     public setKey(target: T, origKey: string): string {
+//         let keysMap;
+//         if (!this._originalKeys.has(target)) {
+//             keysMap = new Map<string, string>();
+//             this._originalKeys.set(target, keysMap);
+//         } else {
+//             keysMap = this._originalKeys.get(target);
+//         }
+
+//         const lowerKey = this.normalizeKey(origKey);
+//         keysMap.set(lowerKey, origKey);
+//         return lowerKey;
+//     }
+
+//     public deleteKey(target: T, origKey: string): string {
+//         if (!this._originalKeys.has(target)) {
+//             return;
+//         }
+
+//         const lowerKey = this.normalizeKey(origKey);
+
+//         this._originalKeys.get(target).delete(lowerKey);
+//         return lowerKey;
+//     }
+
+//     public normalizeKey(key: string) {
+//         return key ? key.toLowerCase() : key;
+//     }
+
+// }
+
+export class CaseInsensitiveKeysStore {
+
+    private _originalKeys: Map<string, string> = new Map();
+
+    public getKey(key: string) {
+        return this._originalKeys.get(
+            this.normalizeKey(key));
+    }
+
+    public getKeys(): IterableIterator<string> {
+        return this._originalKeys.values();
+    }
+
+    public setKey(origKey: string): string {
+        const lowerKey = this.normalizeKey(origKey);
+        this._originalKeys.set(lowerKey, origKey);
+        return lowerKey;
+    }
+
+    public deleteKey(origKey: string): string {
+        const lowerKey = this.normalizeKey(origKey);
+        this._originalKeys.delete(lowerKey);
+        return lowerKey;
+    }
+
+    public normalizeKey(key: string) {
+        return key ? key.toLowerCase() : key;
+    }
+}

src/Primitives/CaseInsensitiveStringSet.ts

@@ -1,35 +1,46 @@
+import { CaseInsensitiveKeysStore } from "./CaseInsensitiveKeysStore";
+
+
+function validateKey(key) {
+    if (!(key && key.toLowerCase)) {
+        throw Error("Key must be a string.");
+    }
+}
 
 export class CaseInsensitiveStringSet {
     public static create(): Set<string> {
-        const result = new Set();
+        const result = new Set<string>();
         const origAdd = result.add;
         const origHas = result.has;
         const origDelete = result.delete;
 
-        function validateKey(key) {
-            if (!(key && key.toLowerCase)) {
-                throw Error("Key must be a string.");
-            }
-        }
-
+        const originalKeysStore = new CaseInsensitiveKeysStore();
         result.add = function (...args) {
             const [ key, ...rest ] = args;
             validateKey(key);
-            return origAdd.call(result, key ? key.toLowerCase() : key, ...rest);
+            const lowerKey = originalKeysStore.setKey(key);
+            return origAdd.call(result, lowerKey, ...rest);
         };
 
         result.has = function (...args) {
             const [ key, ...rest ] = args;
-            validateKey(key);
-            return origHas.call(result, key ? key.toLowerCase() : key, ...rest);
+            const lowerKey = originalKeysStore.normalizeKey(key);
+            return origHas.call(result, lowerKey, ...rest);
         };
 
         result.delete = function (...args) {
             const [ key, ...rest ] = args;
-            validateKey(key);
-            return origDelete.call(result, key ? key.toLowerCase() : key, ...rest);
+            const lowerKey = originalKeysStore.deleteKey(key);
+            return origDelete.call(result, lowerKey, ...rest);
         };
 
+        result.entries = () => 
+            [...originalKeysStore.getKeys()]
+            .map(x => [x, x] as [string, string])[Symbol.iterator](); 
+
+        result[Symbol.iterator] = () => 
+            [...originalKeysStore.getKeys()][Symbol.iterator](); 
+
         return result;
     }
 }

test/Primitives/CaseInsensitivePrimitivesTests.ts

@@ -18,7 +18,11 @@ describe("CaseInsensitiveKeyMap", function () {
 
         // gives actual set entries
         const entries = Array.from(map.entries());
-        assert.strictEqual(entries[0][0], "TEst_KEY");
+        assert.strictEqual(entries[0][0], "TEsT_KEY");
+
+        const iterable = [...map];
+        assert.strictEqual(iterable[0][0], "TEsT_KEY");
+        assert.strictEqual(iterable[0][1], 1);
 
         assert.ok(map.delete("teST_KEY"));
         assert.ok(!map.has("TeSt_kEy"));
@@ -36,6 +40,10 @@ describe("CaseInsensitiveStringSet", function () {
     it("set, has and get with case insensitive strings", async () => {
         set.add("TEsT_KEY");
         assert.ok(set.has("TeSt_kEy"));
+        assert.strictEqual(Array.from(set)[0], "TEsT_KEY");
+        assert.strictEqual(Array.from(set.entries())[0][0], "TEsT_KEY");
+        
         assert.ok(set.delete("teST_KEY"));
+        assert.ok(!set.has("TeSt_kEy"));
     });
 });