fix(std/node): correct typings for global, globalThis, window (#8363)

std/node/buffer_test.ts

@@ -1,19 +1,7 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-import { assert, assertEquals, assertThrows } from "../testing/asserts.ts";
+import { assertEquals, assertThrows } from "../testing/asserts.ts";
 import { Buffer } from "./buffer.ts";
 
-Deno.test({
-  name: "Buffer global scope",
-  fn() {
-    // deno-lint-ignore ban-ts-comment
-    // @ts-expect-error
-    assert(window.Buffer === Buffer);
-    // deno-lint-ignore ban-ts-comment
-    // @ts-expect-error
-    assert(globalThis.Buffer === Buffer);
-  },
-});
-
 Deno.test({
   name: "alloc fails on negative numbers",
   fn() {

std/node/global.d.ts

@@ -0,0 +1,28 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { process as processModule } from "./process.ts";
+import { Buffer as bufferModule } from "./buffer.ts";
+
+// d.ts files allow us to declare Buffer as a value and as a type
+// type something = Buffer | something_else; is quite common
+
+type GlobalType = {
+  process: typeof processModule;
+  Buffer: typeof bufferModule;
+};
+
+declare global {
+  interface Window {
+    global: GlobalType;
+  }
+
+  interface globalThis {
+    global: GlobalType;
+  }
+
+  var global: GlobalType;
+  var process: typeof processModule;
+  var Buffer: typeof bufferModule;
+  type Buffer = bufferModule;
+}
+
+export {};

std/node/global.ts

@@ -1,35 +1,24 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-import process from "./process.ts";
+/// <reference path="./global.d.ts" />
-import { Buffer as buffer } from "./buffer.ts";
+import { process as processModule } from "./process.ts";
+import { Buffer as bufferModule } from "./_buffer.ts";
 
-Object.defineProperty(globalThis, Symbol.toStringTag, {
+Object.defineProperty(globalThis, "global", {
-  value: "global",
+  value: globalThis,
   writable: false,
   enumerable: false,
   configurable: true,
 });
 
-// deno-lint-ignore no-explicit-any
-(globalThis as any)["global"] = globalThis;
-
-// Define the type for the global declration
-type Process = typeof process;
-type Buffer = typeof buffer;
-
 Object.defineProperty(globalThis, "process", {
-  value: process,
+  value: processModule,
   enumerable: false,
   writable: true,
   configurable: true,
 });
 
-declare global {
-  const process: Process;
-  const Buffer: Buffer;
-}
-
 Object.defineProperty(globalThis, "Buffer", {
-  value: buffer,
+  value: bufferModule,
   enumerable: false,
   writable: true,
   configurable: true,

std/node/global_test.ts

@@ -0,0 +1,52 @@
+import "./global.ts";
+import { assert, assertStrictEquals } from "../testing/asserts.ts";
+import { Buffer as BufferModule } from "./buffer.ts";
+import processModule from "./process.ts";
+
+// Definitions for this are quite delicate
+// This ensures modifications to the global namespace don't break on TypeScript
+
+// TODO
+// Deno lint marks globals defined by this module as undefined
+// probably gonna change in the future
+
+Deno.test("global is correctly defined", () => {
+  // deno-lint-ignore no-undef
+  assertStrictEquals(global, globalThis);
+  // deno-lint-ignore no-undef
+  assertStrictEquals(global.Buffer, BufferModule);
+  // deno-lint-ignore no-undef
+  assertStrictEquals(global.process, process);
+});
+
+Deno.test("Buffer is correctly defined", () => {
+  //Check that Buffer is defined as a type as well
+  type x = Buffer;
+  // deno-lint-ignore no-undef
+  assertStrictEquals(Buffer, BufferModule);
+  // deno-lint-ignore no-undef
+  assert(Buffer.from);
+  // deno-lint-ignore no-undef
+  assertStrictEquals(global.Buffer, BufferModule);
+  // deno-lint-ignore no-undef
+  assert(global.Buffer.from);
+  assertStrictEquals(globalThis.Buffer, BufferModule);
+  assert(globalThis.Buffer.from);
+  assertStrictEquals(window.Buffer, BufferModule);
+  assert(window.Buffer.from);
+});
+
+Deno.test("process is correctly defined", () => {
+  // deno-lint-ignore no-undef
+  assertStrictEquals(process, processModule);
+  // deno-lint-ignore no-undef
+  assert(process.arch);
+  // deno-lint-ignore no-undef
+  assertStrictEquals(global.process, processModule);
+  // deno-lint-ignore no-undef
+  assert(global.process.arch);
+  assertStrictEquals(globalThis.process, processModule);
+  assert(globalThis.process.arch);
+  assertStrictEquals(window.process, processModule);
+  assert(window.process.arch);
+});

std/node/process_test.ts

@@ -6,6 +6,7 @@ import * as path from "../path/mod.ts";
 import * as all from "./process.ts";
 import { argv, env } from "./process.ts";
 import { delay } from "../async/delay.ts";
+import "./global.ts";
 
 // NOTE: Deno.execPath() (and thus process.argv) currently requires --allow-env
 // (Also Deno.env.toObject() (and process.env) requires --allow-env but it's more obvious)