It also means that globalThis can be shadowed, but because of the way I injected it, you cannot say globalThis.globalThis.globalThis.a

(typeof globalThis)["globalThis"] should work fine, right?

I kept a noImplicitThis error when an arrow function uses the global this. Strictly speaking this isn't of type any, but typeof globalThis, but it's still not good code; people should use globalThis.x instead of this.x because it's less confusing.

I assume this is specifically about sloppy mode code, right? In strict mode, or in modules, the global this should be undefined, not any or globalThis.

From later discussion, I noticed that window.x = 12, at least at top-level in a script, should result in binding a global variable 'x'.

@Kovensky you are right but that would probably be a big breaking change. It'll be easier to test in a separate PR, so I will do it that way. It would be a good idea to ship that change in the same version as this one, though.

I just ran the user tests and nothing failed there. That's a good sign.

Notes from Design meeting:

1. Need to forbid assignments to nested globalThis references: globalThis.globalThis = 1. This applies to other global consts; they should be readonly properties.
2. window property assignments seem weird and should definitely only work for JS.
3. A good, general polyfill seems out of reach, so we will ship without one at first. So I need to add a test that ensures that var globalThis = this/window/self works.
4. The type of globalThis should print as typeof globalThis. (this isn't my memory of our decision, but it's what Daniel wrote?)

Is this the same as what global::: can solve in C#?

That is, the outerWobbler variable in namespace PluginA can now be defined of type IWobbler with the help of globalThis below?

namespace Data {

    export namespace Components {
        export interface IWobbler {
            wobble(): void;
        }
    }
}

////IN SOME OTHER FILE

namespace PluginA {

    var outerWobbler: globalThis.Data.Components.IWobbler = undefined;

    //this namespace breaks outerWobbler since you can't reference Data.Components.IWobbler
    export namespace Data {

        //other stuff for PluginA's Data 

    }

}

Workaround at the moment is something like

////IN SOME OTHER FILE - HACKY WORKAROUND

type AliasForIWobbler = Data.Components.IWobbler;

namespace PluginB {
    var outerWobbler: AliasForIWobbler = undefined;
    export namespace Data {
        //other stuff for PluginB's Data 

    }
}

Ian Yates (@IanYates) This is already available as global on node and this or window (sort of mostly) in the browser. globalThis is just a standard name for it.

This PR adds a type for the global namespace so you get that instead of any. That is, the example you posted works today if you substitute global for globalThis, except you don't get completions. After this PR, you will.

All right, I think this is ready to go. Wesley Wigham (@weswigham) Mind taking another look?

Apparently the current implementation only works when variables are defined in a global file.
But doesn't this mean that we cannot use globalThis with imported types?

Currently, I'm using window as follows (like everyone apparently!). How can this be achieved with globalThis?

declare global {
  interface Window {
    MyAppStores: {
      FileStore: FileStoreI;
    }
  }
}
...
window.MyAppStore = { FileStore }

Apparently the current implementation only works when variables are defined in a global file.
But doesn't this mean that we cannot use globalThis with imported types?

Currently, I'm using window as follows (like everyone apparently!). How can this be achieved with globalThis?

declare global {
  interface Window {
    MyAppStores: {
      FileStore: FileStoreI;
    }
  }
}
...
window.MyAppStore = { FileStore }

dperetti you can try this

interface AppStore  {
    FileStore: FileStoreI;
}

declare global {
  var MyAppStores: AppStore;
}

Both window and globalThis will recognize the type for that variable. For typing globalThis you should use var not let or const

It doesn't seem there is a good way to extend globalThis using an interface.

interface globalThis extends Window {}

The above keeps failing with:

Declaration name conflicts with built-in global identifier 'globalThis'

I'm on typescript version 4.1.

Also I was expecting that extending Window will propagate the properties to globalThis, but it doesn't:

interface RuntimeGlobals {}
interface Window extends RuntimeGlobals {}