How to prevent "Property '...' does not exist on type 'Global'" with jsdom and typescript?

Question

I try to convert an existing project to use Typescript and I have problems doing so with my testing setup.

I had a setup file for my tests that sets up jsdom so that all my DOM interacting code works during my tests. Using Typescript (ts-node with mocha) I always get errors like this:

Property 'window' does not exist on type 'Global'.

To prevent this I tried patching the NodeJS.Global interface like this:

declare namespace NodeJS{
  interface Global {
    document: Document;
    window: Window;
    navigator: Navigator;
  }
}

But this didn't change anything.

How do I enable those browser properties on the NodeJS global variable?

Extras:

This is my mocha setup.ts:

import { jsdom, changeURL } from 'jsdom';

const exposedProperties = ['window', 'navigator', 'document'];

global.document = jsdom('');
global.window = global.document.defaultView;
Object.keys(global.document.defaultView).forEach((property) => {
  if (typeof global[property] === 'undefined') {
    exposedProperties.push(property);
    global[property] = global.document.defaultView[property];
  }
});

global.navigator = {
  userAgent: 'node.js',
};

changeURL(global.window, 'http://example.com/');

Answer 1

Original Answer To Avoid Error

Put this at the top of your typescript file

const globalAny:any = global;

Then use globalAny instead.

globalAny.document = jsdom('');
globalAny.window = global.document.defaultView;

Updated Answer To Maintain Type Safety

If you want to keep your type safety, you can augment the existing NodeJS.Global type definition.

You need to put your definition inside the global scope declare global {...}

Keep in mind that the typescript global scope is not the same as the NodeJS interface Global, or the node global property called global of type Global...

declare global {
  namespace NodeJS {
    interface Global {
       document: Document;
       window: Window;
       navigator: Navigator;
    } 
  }
}

Answer 2

In addition to other answers, you can also simply cast global directly at the assignment site:

(global as any).myvar = myvar;

Answer 3

I fixed this problem by doing this...

export interface Global {
  document: Document;
  window: Window;
}

declare var global: Global;

Answer 4

This is the right solution, not using Typescript's namespaces. It is also compatible with all eslint default rules:

// Declare a type.
interface CustomNodeJsGlobal extends NodeJS.Global {
    myExtraGlobalVariable: number;
    // You can declare anything you need.
}

Use it:

// Tell Typescript to use this type on the globally scoped `global` variable.
declare const global: CustomNodeJsGlobal;

function doSomething() {
  // Use it freely
  global.myExtraGlobalVariable = 5;
}

doSomething();

Answer 5

Avoid typecasting any, it removes the purpose of typings. Instead install the type definitions needed (e.g. yarn add --dev @types/jsdom @types/node) and import to use:

import { DOMWindow, JSDOM } from 'jsdom'

interface Global extends NodeJS.Global {
  window: DOMWindow,
  document: Document,
  navigator: {
    userAgent: string
  }
}

const globalNode: Global = {
  window: window,
  document: window.document,
  navigator: {
    userAgent: 'node.js',
  },
  ...global
}

Answer 6

How to declare something in global

1. Create global declaration file, for example: src/types/index.d.ts
2. Add your global declaration file to tsconfig.json:

{
  "compilerOptions": {
    /* ... */
    "typeRoots": [
      "./src/types",
    ],
    /* ... */
  },
  /* ... */
}

From Typescript Documentation

You can add declarations to the global scope from inside a module

So, for example, if you want to add something extra to the array interface, you need to do:

observable.ts (example)

// observable.ts
export class Observable<T> {
  // ... still no implementation ...
}

src/types/index.d.ts

declare global {
  interface Array<T> {
    toObservable(): Observable<T>;
  }
}

someWhereInApp.ts

Array.prototype.toObservable = function () {
  // ...
};

Declaring variables to access them from global

If you want to add a global variable to use as global.myVariable you need to do:

src/types/index.d.ts

/* eslint-disable no-var */
declare global {
/*  ↓↓↓ "var" is important  */  
    var myVariable: string[];
}
/* eslint-enable no-var */

someWhereInApp.ts

const { myVariable } = global

Answer 7

declare namespace NodeJS {
  export interface Global { window: any;
  }
}

Answer 8

A simple method can be use extend the Typescript "Window" type

step 1: append Window object

interface Window {
    foo:string // any type of your foo property
}

step 2: declare

let foo = 'value of foo'

step 3: add to window object

window.foo 

or

window.foo = foo

work for me...

Answer 9

I was creating a nodeJS application with typescript and what fixed it for me was updating the @types/node in devDependencies to match the version I was using.