es2015.collection

Author: uhyo

build/replacement.ts

@@ -6,6 +6,18 @@ export const replacement = new Set<string>([
   "IArguments",
   "JSON",
   "ArrayConstructor",
+  // lib.es2015.collection.d.ts
+  "Map",
+  "MapConstructor",
+  "WeakMap",
+  "WeakMapConstructor",
+  "ReadonlyMap",
+  "Set",
+  "SetConstructor",
+  "ReadonlySet",
 ]);
 
-export const betterLibs = new Set<string>(["lib.es5.d.ts"]);
+export const betterLibs = new Set<string>([
+  "lib.es5.d.ts",
+  "lib.es2015.collection.d.ts",
+]);

lib/lib.es2015.collection.d.ts

@@ -0,0 +1,71 @@
+interface Map<K, V> {
+  clear(): void;
+  delete(key: K): boolean;
+  forEach<This>(
+    callbackfn: (this: This, value: V, key: K, map: Map<K, V>) => void,
+    thisArg?: This
+  ): void;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): this;
+  readonly size: number;
+}
+
+interface MapConstructor {
+  new <K, V>(entries?: readonly (readonly [K, V])[] | null): Map<K, V>;
+  readonly prototype: Map<unknown, unknown>;
+}
+
+declare var Map: MapConstructor;
+
+interface WeakMap<K extends object, V> {
+  delete(key: K): boolean;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): this;
+}
+
+interface WeakMapConstructor {
+  new <K extends object = object, V = unknown>(
+    entries?: readonly [K, V][] | null
+  ): WeakMap<K, V>;
+  readonly prototype: WeakMap<object, unknown>;
+}
+declare var WeakMap: WeakMapConstructor;
+
+interface ReadonlyMap<K, V> {
+  forEach<This>(
+    callbackfn: (this: This, value: V, key: K, map: ReadonlyMap<K, V>) => void,
+    thisArg?: This
+  ): void;
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  readonly size: number;
+}
+
+interface Set<T> {
+  add(value: T): this;
+  clear(): void;
+  delete(value: T): boolean;
+  forEach<This>(
+    callbackfn: (this: This, value: T, value2: T, set: Set<T>) => void,
+    thisArg?: This
+  ): void;
+  has(value: T): boolean;
+  readonly size: number;
+}
+
+interface SetConstructor {
+  new <T>(values?: readonly T[] | null): Set<T>;
+  readonly prototype: Set<unknown>;
+}
+declare var Set: SetConstructor;
+
+interface ReadonlySet<T> {
+  forEach<This>(
+    callbackfn: (this: This, value: T, value2: T, set: ReadonlySet<T>) => void,
+    thisArg?: This
+  ): void;
+  has(value: T): boolean;
+  readonly size: number;
+}

tests/es2015.ts

@@ -0,0 +1,66 @@
+/// <reference path="../dist/lib/lib.es2015.d.ts" />
+
+import { expectType } from "tsd";
+
+// Map
+{
+  const map: Map<string, number> = new Map();
+
+  map.forEach((v, k) => {
+    expectType<undefined>(this);
+    expectType<number>(v);
+    expectType<string>(k);
+  });
+  map.forEach((v, k) => {
+    expectType<undefined>(this);
+    expectType<number>(v);
+    expectType<string>(k);
+  }, {});
+  map.forEach(
+    function () {
+      expectType<string>(this.foo);
+    },
+    { foo: "foo" }
+  );
+
+  const map2 = new Map();
+  expectType<Map<unknown, unknown>>(map2);
+  expectType<unknown>(map2.get("a"));
+
+  const map3 = new Map<string, number>();
+  expectType<Map<string, number>>(map3);
+
+  expectType<Map<unknown, unknown>>(Map.prototype);
+}
+// WeakMap
+{
+  const map: WeakMap<object, number> = new WeakMap();
+  expectType<WeakMap<object, number>>(map);
+
+  const map2 = new WeakMap();
+  expectType<WeakMap<object, unknown>>(map2);
+  expectType<unknown>(map2.get({}));
+
+  expectType<WeakMap<object, unknown>>(WeakMap.prototype);
+}
+// Set
+{
+  const set = new Set();
+  expectType<Set<unknown>>(set);
+
+  const set2 = new Set([1, 2, 3]);
+  set2.forEach((v) => {
+    expectType<undefined>(this);
+    expectType<number>(v);
+  });
+  set2.forEach((v) => {
+    expectType<undefined>(this);
+    expectType<number>(v);
+  }, {});
+  set2.forEach(
+    function () {
+      expectType<string>(this.foo);
+    },
+    { foo: "foo" }
+  );
+}