Implement trie as a Map

Store the character trie as a Map instead of an Object.  Enable ES6
types in TypeScript.

Author: wimpyprogrammer

package.json

@@ -41,6 +41,7 @@
     "@babel/core": "^7.0.0-beta.54",
     "@babel/preset-env": "^7.0.0-beta.54",
     "@babel/preset-typescript": "^7.0.0-beta.54",
+    "@types/es6-shim": "^0.31.37",
     "@types/jest": "^23.3.1",
     "@types/lodash": "^4.14.114",
     "husky": "^0.14.3",

src/types/iCharTree.d.ts

@@ -1,3 +1,4 @@
 type Char = string;
-interface ICharTrie extends Record<Char, CharNode> {}
-type CharNode = ICharTrie;
+interface ICharTrie extends Map<Char, ICharTrie> {
+	[headChar: string]: ICharTrie;
+}

src/utils/trie.spec.ts

@@ -1,97 +1,125 @@
 import { build } from './trie';
 
+interface ICharTrieData {
+	[prefix: string]: ICharTrieData;
+}
+
+function convertObjectToTrie(trieData: ICharTrieData): ICharTrie {
+	const trieDataPairs = Object.entries(trieData);
+
+	const trie = trieDataPairs.reduce(
+		(map, [prefix, suffix]) => map.set(prefix, convertObjectToTrie(suffix)),
+		new Map()
+	);
+
+	return trie as ICharTrie;
+}
+
 describe('build', () => {
 	it('returns empty trie when no words', () => {
-		expect(build([])).toEqual({});
+		const expectedResult = convertObjectToTrie({});
+		expect(build([])).toEqual(expectedResult);
 	});
 
 	it('returns the entirety of words when no common head', () => {
 		const words = ['bar', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			bar: {},
 			foo: {},
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns the entirety of repeated equal words', () => {
 		const words = ['foo', 'foo', 'foo', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			foo: {},
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns the entirety of multiple, repeated equal words', () => {
 		const words = ['bar', 'bar', 'bar', 'bar', 'foo', 'foo', 'foo', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			bar: {},
 			foo: {},
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns an empty string for partial words', () => {
 		const words = ['foo', 'foobar'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			foo: { '': {}, bar: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns the common head of two words', () => {
 		const words = ['bar', 'baz'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			ba: { r: {}, z: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns multiple depths of partial words', () => {
 		const words = ['foo', 'foobar', 'foobaz'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			foo: { '': {}, ba: { r: {}, z: {} } },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('returns the common head of multiple words', () => {
 		const words = ['bar', 'baz', 'quux', 'quuz'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			ba: { r: {}, z: {} },
 			quu: { x: {}, z: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('preserves leading whitespace', () => {
 		const words = [' foo', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			' foo': {},
 			foo: {},
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('preserves trailing whitespace', () => {
 		const words = ['foo ', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			foo: { '': {}, ' ': {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('preserves mid-word whitespace', () => {
 		const words = ['foo bar', 'foobar'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			foo: { ' bar': {}, bar: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('is case-sensitive with string heads', () => {
 		const words = ['Foo', 'foo'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			Foo: {},
 			foo: {},
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('is case-sensitive with string tails', () => {
 		const words = ['foo', 'foO'];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			fo: { o: {}, O: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 
 	it('handles complex words', () => {
@@ -116,7 +144,7 @@ describe('build', () => {
 			'Oklahoma',
 			'Oregon',
 		];
-		expect(build(words)).toEqual({
+		const expectedResult = convertObjectToTrie({
 			M: {
 				a: { ine: {}, ryland: {}, ssachusetts: {} },
 				i: { chigan: {}, nnesota: {}, ss: { issippi: {}, ouri: {} } },
@@ -132,5 +160,6 @@ describe('build', () => {
 			},
 			O: { hio: {}, klahoma: {}, regon: {} },
 		});
+		expect(build(words)).toEqual(expectedResult);
 	});
 });

src/utils/trie.ts

@@ -1,6 +1,6 @@
-import { keys, map, partition, uniq } from 'lodash';
+import { partition, uniq } from 'lodash';
 
-const leafNode: CharNode = {};
+const leafNode = new Map() as ICharTrie;
 
 /**
  * Arrange a head character and its suffixes into a trie.
@@ -13,13 +13,12 @@ const leafNode: CharNode = {};
  * @returns A character trie with tailGroup branching from headChar
  */
 function mergeGroups(headChar: Char, tailGroup: ICharTrie): ICharTrie {
-	const tails = keys(tailGroup);
-	if (tails.length > 1) {
-		return { [headChar]: tailGroup };
+	if (tailGroup.size !== 1) {
+		return new Map([[headChar, tailGroup]]) as ICharTrie;
 	}
 
-	const onlyTail = tails[0];
-	return { [headChar + onlyTail]: tailGroup[onlyTail] };
+	const [onlyTail, onBranch] = tailGroup.entries().next().value;
+	return new Map([[headChar + onlyTail, onBranch]]) as ICharTrie;
 }
 
 /**
@@ -39,19 +38,19 @@ function buildUnique(words: string[]): ICharTrie {
 		// End of the target word reached. Include an empty string to signify that
 		// a word ends at this spot, and group any remaining words in the trie.
 		const [, nonEmptyWords] = partition(words, word => word === '');
-		return { '': leafNode, ...build(nonEmptyWords) };
+		return new Map([['', leafNode], ...build(nonEmptyWords)]) as ICharTrie;
 	}
 
 	// Begin a new trie containing all words starting with the same letter as wordToMatch
 	const charToMatch = wordToMatch[0];
 	const [wordsMatched, wordsMissed] = partition(words, ['[0]', charToMatch]);
 
-	const tailsMatched = map(wordsMatched, word => word.substring(1));
+	const tailsMatched = wordsMatched.map(word => word.substring(1));
 	const tailsMatchedGrouped = build(tailsMatched);
 
 	const groupWithChildren = mergeGroups(charToMatch, tailsMatchedGrouped);
 
-	return { ...groupWithChildren, ...build(wordsMissed) };
+	return new Map([...groupWithChildren, ...build(wordsMissed)]) as ICharTrie;
 }
 
 /** @borrows buildUnique as build */

tsconfig.json

@@ -3,7 +3,9 @@
 		"allowJs": true,
 		"allowSyntheticDefaultImports": true,
 		"baseUrl": "./",
+		"downlevelIteration": true,
 		"rootDir": "./",
+		"lib": ["es2017"],
 		"module": "es2015",
 		"noEmit": true,
 		"noImplicitAny": true,

yarn.lock

@@ -543,6 +543,10 @@
     lodash "^4.17.5"
     to-fast-properties "^2.0.0"
 
+"@types/es6-shim@^0.31.37":
+  version "0.31.37"
+  resolved "https://registry.yarnpkg.com/@types/es6-shim/-/es6-shim-0.31.37.tgz#d01fa9b61a6692e57387dde5483b0255659ba70f"
+
 "@types/jest@^23.3.1":
   version "23.3.1"
   resolved "https://registry.yarnpkg.com/@types/jest/-/jest-23.3.1.tgz#a4319aedb071d478e6f407d1c4578ec8156829cf"