Implement

Author: noahwillcrow

src/classes/StrictMap.ts

@@ -0,0 +1,98 @@
+import { HttpService } from "@rbxts/services";
+import { IReadonlyStrictMap } from "interfaces/IReadonlyStrictMap";
+
+export class StrictMap<K extends defined, V extends defined> implements IReadonlyStrictMap<K, V> {
+	private map: Map<K, V>;
+	private numberOfKeys = 0;
+
+	public constructor(
+		entries?: ReadonlyArray<[K, V]>,
+		private readonly getMissingKeyErrorMessage?: (key: K) => string,
+	) {
+		this.map = new Map<K, V>(entries ?? []);
+		this.numberOfKeys = this.map.size();
+	}
+
+	public clear() {
+		this.map = new Map<K, V>();
+		this.numberOfKeys = 0;
+	}
+
+	public delete(key: K) {
+		if (!this.map.has(key)) {
+			return false;
+		}
+
+		this.numberOfKeys--;
+		return this.map.delete(key);
+	}
+
+	public entries() {
+		const result = new Array<[K, V]>();
+		for (const [key, value] of this.map) {
+			result.push([key, value]);
+		}
+		return result;
+	}
+
+	public forEach(callbackfn: (value: V, key: K, self: this) => void) {
+		this.map.forEach((value, key) => callbackfn(value, key, this));
+	}
+
+	public has(key: K) {
+		return this.map.has(key);
+	}
+
+	public isEmpty() {
+		return this.numberOfKeys === 0;
+	}
+
+	public keys() {
+		const result = new Array<K>();
+		for (const [key] of this.map) {
+			result.push(key);
+		}
+		return result;
+	}
+
+	public mustGet(key: K) {
+		const value = this.map.get(key);
+		if (value === undefined) {
+			if (this.getMissingKeyErrorMessage !== undefined) {
+				throw this.getMissingKeyErrorMessage(key);
+			} else {
+				throw `Attempt to index missing value for key: ${key}`;
+			}
+		}
+
+		return value;
+	}
+
+	public set(key: K, value: V) {
+		if (!this.map.has(key)) {
+			this.numberOfKeys++;
+		}
+
+		this.map.set(key, value);
+	}
+
+	public size() {
+		return this.numberOfKeys;
+	}
+
+	public toReadonlyMap(): ReadonlyMap<K, V> {
+		return new ReadonlyMap(this.entries());
+	}
+
+	public toString() {
+		return HttpService.JSONEncode(this.map);
+	}
+
+	public values() {
+		const result = new Array<V>();
+		for (const [, value] of this.map) {
+			result.push(value);
+		}
+		return result;
+	}
+}

src/index.ts

@@ -1,2 +1,4 @@
+export * from "classes/StrictMap";
+
 export { IReadonlyStrictMap } from "interfaces/IReadonlyStrictMap";
-export { IStrictMap } from "interfaces/IStrictMap";
+export { IStrictMap } from "interfaces/IStrictMap";

src/interfaces/IReadonlyStrictMap.d.ts

@@ -1,7 +1,7 @@
 /**
  * Defines an interface for reading from a strict map
  */
- export interface IReadonlyStrictMap<K extends defined, V extends defined> {
+export interface IReadonlyStrictMap<K extends defined, V extends defined> {
 	/**
 	 * Returns an array of tuples for all members of this instance
 	 */
@@ -10,7 +10,7 @@
 	/**
 	 * Performs the specified action for each (element / pair of elements) in the Map
 	 * @param callbackfn  A function that accepts up to three arguments.
-     * forEach calls the callbackfn function one time for each (element / pair of elements) in the array.
+	 * forEach calls the callbackfn function one time for each (element / pair of elements) in the array.
 	 */
 	forEach(callbackfn: (value: V, key: K, self: this) => void): void;
 

src/interfaces/IStrictMap.d.ts

@@ -7,16 +7,16 @@ export interface IStrictMap<K extends defined, V extends defined> extends IReado
 	/**
 	 * Deletes all members of this instance
 	 */
-	clear(): void
+	clear(): void;
 
 	/**
 	 * Deletes the given key from this instance
 	 * @returns A boolean indicating whether or not a value was removed.
 	 */
-	delete(key: K): boolean
+	delete(key: K): boolean;
 
 	/**
 	 * Associates a key with a value which can be accessed later by the given key
 	 */
-	set(key: K, value: V): boolean
-}
+	set(key: K, value: V): boolean;
+}