proxy, reflect

Author: uhyo

build/index.ts

@@ -68,7 +68,8 @@ function checkStatement(
   } else if (
     ts.isFunctionDeclaration(statement) ||
     ts.isInterfaceDeclaration(statement) ||
-    ts.isTypeAliasDeclaration(statement)
+    ts.isTypeAliasDeclaration(statement) ||
+    ts.isModuleDeclaration(statement)
   ) {
     const repl = statement.name && replacement.has(statement.name.text);
     if (repl) {

build/replacement.ts

@@ -38,4 +38,6 @@ export const replacement = new Map([
     ]),
   ],
   ["lib.es2015.promise.d.ts", new Set(["PromiseConstructor"])],
+  ["lib.es2015.proxy.d.ts", new Set(["ProxyHandler"])],
+  ["lib.es2015.reflect.d.ts", new Set(["Reflect"])],
 ]);

lib/lib.es2015.proxy.d.ts

@@ -0,0 +1,25 @@
+/// <reference no-default-lib="true"/>
+
+interface ProxyHandler<T extends object> {
+  getPrototypeOf?(target: T): object | null;
+  setPrototypeOf?(target: T, v: unknown): boolean;
+  isExtensible?(target: T): boolean;
+  preventExtensions?(target: T): boolean;
+  getOwnPropertyDescriptor?(
+    target: T,
+    p: PropertyKey
+  ): PropertyDescriptor | undefined;
+  has?(target: T, p: PropertyKey): boolean;
+  get?(target: T, p: PropertyKey, receiver: unknown): any;
+  set?(target: T, p: PropertyKey, value: unknown, receiver: unknown): boolean;
+  deleteProperty?(target: T, p: PropertyKey): boolean;
+  defineProperty?(
+    target: T,
+    p: PropertyKey,
+    attributes: PropertyDescriptor
+  ): boolean;
+  enumerate?(target: T): PropertyKey[];
+  ownKeys?(target: T): PropertyKey[];
+  apply?(target: T, thisArg: unknown, argArray: unknown[]): any;
+  construct?(target: T, argArray: unknown[], newTarget: unknown): object;
+}

lib/lib.es2015.reflect.d.ts

@@ -0,0 +1,41 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Reflect {
+  function apply(
+    target: Function,
+    thisArgument: any,
+    argumentsList: ArrayLike<any>
+  ): unknown;
+  function construct(
+    target: Function,
+    argumentsList: ArrayLike<any>,
+    newTarget?: any
+  ): object;
+  function defineProperty(
+    target: object,
+    propertyKey: PropertyKey,
+    attributes: PropertyDescriptor
+  ): boolean;
+  function deleteProperty(target: object, propertyKey: PropertyKey): boolean;
+  function get<T, K extends PropertyKey>(
+    target: T,
+    propertyKey: K,
+    receiver?: any
+  ): K extends keyof T ? T[K] : unknown;
+  function getOwnPropertyDescriptor(
+    target: object,
+    propertyKey: PropertyKey
+  ): PropertyDescriptor | undefined;
+  function getPrototypeOf(target: object): object;
+  function has(target: object, propertyKey: PropertyKey): boolean;
+  function isExtensible(target: object): boolean;
+  function ownKeys(target: object): PropertyKey[];
+  function preventExtensions(target: object): boolean;
+  function set(
+    target: object,
+    propertyKey: PropertyKey,
+    value: any,
+    receiver?: any
+  ): boolean;
+  function setPrototypeOf(target: object, proto: any): boolean;
+}

tests/es2015.proxy.ts

@@ -0,0 +1,31 @@
+/// <reference path="../dist/lib/lib.es2015.d.ts" />
+
+import { expectType } from "tsd";
+
+// ProxyHandler
+new Proxy(
+  {},
+  {
+    setPrototypeOf(t, v) {
+      expectType<unknown>(v);
+      return true;
+    },
+    get(t, p, receiver) {
+      expectType<unknown>(receiver);
+    },
+    set(t, p, value, receiver) {
+      expectType<unknown>(value);
+      expectType<unknown>(receiver);
+      return true;
+    },
+    apply(t, thisArg, argArray) {
+      expectType<unknown>(thisArg);
+      expectType<unknown[]>(argArray);
+    },
+    construct(t, argArray, newTarget) {
+      expectType<unknown[]>(argArray);
+      expectType<unknown>(newTarget);
+      return {};
+    },
+  }
+);

tests/es2015.reflect.ts

@@ -0,0 +1,15 @@
+/// <reference path="../dist/lib/lib.es2015.d.ts" />
+
+import { expectType } from "tsd";
+
+expectType<unknown>(Reflect.apply(() => {}, {}, []));
+expectType<object>(Reflect.construct(function () {}, []));
+{
+  const obj1 = {
+    foo: 123,
+    bar: "wow",
+  };
+  expectType<number>(Reflect.get(obj1, "foo"));
+  expectType<string>(Reflect.get(obj1, "bar"));
+  expectType<unknown>(Reflect.get(obj1, 123));
+}