feat: add package scope-manager (#1939)

This commit is contained in:
Brad Zacher 2020-06-29 01:53:54 -07:00 committed by GitHub
parent 5c91beec72
commit 682eb7e009
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
607 changed files with 45335 additions and 55 deletions

View File

@ -12,7 +12,8 @@
"**/*.{json,snap}",
".cspell.json",
"yarn.lock",
".github/workflows/**"
".github/workflows/**",
".vscode/*.json"
],
"dictionaries": [
"typescript",
@ -57,6 +58,7 @@
"ESLint",
"ESLint's",
"espree",
"esrecurse",
"estree",
"IDE's",
"IIFE",
@ -75,11 +77,13 @@
"Premade",
"prettier's",
"recurse",
"redeclared",
"reimplement",
"resync",
"ROADMAP",
"ruleset",
"rulesets",
"serializers",
"superset",
"thenables",
"transpiles",

View File

@ -55,6 +55,11 @@ module.exports = {
'@typescript-eslint/prefer-nullish-coalescing': 'error',
'@typescript-eslint/prefer-optional-chain': 'error',
'@typescript-eslint/unbound-method': 'off',
'@typescript-eslint/prefer-as-const': 'error',
'@typescript-eslint/no-unused-vars': [
'warn',
{ varsIgnorePattern: '^_', argsIgnorePattern: '^_' },
],
// TODO - enable these new recommended rules
'@typescript-eslint/no-floating-promises': 'off',
@ -224,5 +229,18 @@ module.exports = {
'no-console': 'off',
},
},
// generated files
{
files: [
'packages/scope-manager/src/lib/*.ts',
'packages/eslint-plugin/src/configs/*.ts',
],
rules: {
// allow console logs in tools and tests
'@typescript-eslint/internal/no-poorly-typed-ts-props': 'off',
'@typescript-eslint/internal/no-typescript-default-import': 'off',
'@typescript-eslint/internal/prefer-ast-types-enum': 'off',
},
},
],
};

View File

@ -4,8 +4,6 @@ on:
push:
branches:
- master
# TODO - delete this before merging v3 into master
- v3
pull_request:
branches:
- '**'
@ -103,6 +101,12 @@ jobs:
env:
CI: true
- name: Run unit tests for scope-manager
run: yarn test
working-directory: packages/scope-manager
env:
CI: true
- name: Run unit tests for experimental-utils
run: yarn test
working-directory: packages/experimental-utils
@ -269,6 +273,12 @@ jobs:
env:
CI: true
- name: Run unit tests for scope-manager
run: yarn test
working-directory: packages/scope-manager
env:
CI: true
- name: Run unit tests for experimental-utils
run: yarn test
working-directory: packages/experimental-utils

View File

@ -1,4 +1,5 @@
**/tests/fixtures/**/*
!packages/scope-manager/tests/fixtures/**/*
**/tests/fixture-project/**/*
**/dist
**/coverage

View File

@ -1,10 +1,11 @@
{
"recommendations": [
"esbenp.prettier-vscode",
"davidanson.vscode-markdownlint",
"dbaeumer.vscode-eslint",
"editorconfig.editorconfig",
"esbenp.prettier-vscode",
"streetsidesoftware.code-spell-checker",
"davidanson.vscode-markdownlint"
"tlent.jest-snapshot-language-support"
],
"unwantedRecommendations": ["hookyqr.beautify", "dbaeumer.jshint"]
}

44
.vscode/launch.json vendored
View File

@ -32,6 +32,8 @@
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
},
{
@ -62,6 +64,8 @@
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
},
{
@ -92,6 +96,8 @@
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
},
{
@ -122,6 +128,8 @@
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
},
{
@ -152,7 +160,41 @@
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
}
},
{
"type": "node",
"request": "launch",
"name": "Run currently opened scope-manager test",
"cwd": "${workspaceFolder}/packages/scope-manager/",
"program": "${workspaceFolder}/node_modules/jest/bin/jest.js",
"args": [
"--runInBand",
"--no-cache",
"--no-coverage",
"${fileBasename}"
],
"sourceMaps": true,
"console": "integratedTerminal",
"internalConsoleOptions": "neverOpen",
"skipFiles": [
"${workspaceFolder}/packages/experimental-utils/src/index.ts",
"${workspaceFolder}/packages/experimental-utils/dist/index.js",
"${workspaceFolder}/packages/experimental-utils/src/ts-estree.ts",
"${workspaceFolder}/packages/experimental-utils/dist/ts-estree.js",
"${workspaceFolder}/packages/parser/src/index.ts",
"${workspaceFolder}/packages/parser/dist/index.js",
"${workspaceFolder}/packages/typescript-estree/src/index.ts",
"${workspaceFolder}/packages/typescript-estree/dist/index.js",
"${workspaceFolder}/packages/types/src/index.ts",
"${workspaceFolder}/packages/types/dist/index.js",
"${workspaceFolder}/packages/visitor-keys/src/index.ts",
"${workspaceFolder}/packages/visitor-keys/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
"${workspaceFolder}/packages/scope-manager/dist/index.js",
],
},
]
}

17
.vscode/settings.json vendored
View File

@ -18,4 +18,21 @@
"javascript.preferences.quoteStyle": "single",
"typescript.preferences.quoteStyle": "single",
"editor.defaultFormatter": "esbenp.prettier-vscode",
// make the .shot files from jest-specific-snapshot act like normal snapshots
"files.associations": {
"*.shot": "jest-snapshot"
},
"vsicons.associations.files": [
{
"icon": "jest_snapshot",
"extensions": [
".ts.shot",
".tsx.shot",
".js.shot",
".jsx.shot",
],
"extends": "jest_snapshot"
},
],
}

View File

@ -72,6 +72,7 @@
"@types/jest": "^25.2.1",
"@types/node": "^13.13.5",
"@types/prettier": "^2.0.0",
"@types/rimraf": "^3.0.0",
"all-contributors-cli": "^6.14.2",
"cspell": "^4.0.61",
"cz-conventional-changelog": "^3.2.0",

View File

@ -1,5 +1,7 @@
'use strict';
// @ts-check
/** @type {import('@jest/types').Config.InitialOptions} */
module.exports = {
globals: {
'ts-jest': {

View File

@ -1,5 +1,7 @@
'use strict';
// @ts-check
/** @type {import('@jest/types').Config.InitialOptions} */
module.exports = {
globals: {
'ts-jest': {

View File

@ -1,5 +1,7 @@
'use strict';
// @ts-check
/** @type {import('@jest/types').Config.InitialOptions} */
module.exports = {
globals: {
'ts-jest': {

View File

@ -1,3 +1,7 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:configs
export = {
extends: ['./configs/base', './configs/eslint-recommended'],
rules: {

View File

@ -1,3 +1,7 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:configs
export = {
parser: '@typescript-eslint/parser',
parserOptions: { sourceType: 'module' },

View File

@ -1,3 +1,7 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:configs
export = {
extends: ['./configs/base', './configs/eslint-recommended'],
rules: {

View File

@ -1,3 +1,7 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:configs
export = {
extends: ['./configs/base', './configs/eslint-recommended'],
rules: {

View File

@ -5,6 +5,16 @@ import path from 'path';
import { format, resolveConfig } from 'prettier';
import rules from '../src/rules';
function addAutoGeneratedComment(code: string): string {
return [
'// THIS CODE WAS AUTOMATICALLY GENERATED',
'// DO NOT EDIT THIS CODE BY HAND',
'// YOU CAN REGENERATE IT USING yarn generate:configs',
'',
code,
].join('\n');
}
const prettierConfig = resolveConfig.sync(__dirname);
interface LinterConfigRules {
@ -117,8 +127,9 @@ function reducer<TMessageIds extends string>(
* Helper function writes configuration.
*/
function writeConfig(config: LinterConfig, filePath: string): void {
// note: we use `export =` because ESLint will import these configs via a commonjs import
const code = `export = ${JSON.stringify(config)};`;
const configStr = format(code, {
const configStr = format(addAutoGeneratedComment(code), {
parser: 'typescript',
...prettierConfig,
});

View File

@ -1,5 +1,7 @@
'use strict';
// @ts-check
/** @type {import('@jest/types').Config.InitialOptions} */
module.exports = {
globals: {
'ts-jest': {

View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2019 TypeScript ESLint and other contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

View File

@ -0,0 +1,98 @@
<h1 align="center">TypeScript Scope Manager</h1>
<p align="center">
<img src="https://github.com/typescript-eslint/typescript-eslint/workflows/CI/badge.svg" alt="CI" />
<a href="https://www.npmjs.com/package/@typescript-eslint/scope-manager"><img src="https://img.shields.io/npm/v/@typescript-eslint/scope-manager.svg?style=flat-square" alt="NPM Version" /></a>
<a href="https://www.npmjs.com/package/@typescript-eslint/scope-manager"><img src="https://img.shields.io/npm/dm/@typescript-eslint/scope-manager.svg?style=flat-square" alt="NPM Downloads" /></a>
</p>
This is a fork of [`eslint-scope`](https://github.com/eslint/eslint-scope), enhanced to support TypeScript functionality.
[You can view the original licence for the code here](https://github.com/eslint/eslint-scope/blob/dbddf14d5771b21b5da704213e4508c660ca1c64/LICENSE).
This package is consumed automatically by [`@typescript-eslint/parser`](../parser).
You probably don't want to use it directly.
## Getting Started
**[You can find our Getting Started docs here](../../docs/getting-started/linting/README.md)**
## Installation
```bash
$ yarn add -D typescript @typescript-eslint/scope-manager
$ npm i --save-dev typescript @typescript-eslint/scope-manager
```
## API
### `analyze(tree, options)`
Analyses a given AST and returns the resulting `ScopeManager`.
```ts
interface AnalyzeOptions {
/**
* Known visitor keys.
*/
childVisitorKeys?: Record<string, string[]> | null;
/**
* Which ECMAScript version is considered.
* Defaults to `2018`.
*/
ecmaVersion?: EcmaVersion;
/**
* Whether the whole script is executed under node.js environment.
* When enabled, the scope manager adds a function scope immediately following the global scope.
* Defaults to `false`.
*/
globalReturn?: boolean;
/**
* Implied strict mode (if ecmaVersion >= 5).
* Defaults to `false`.
*/
impliedStrict?: boolean;
/**
* The lib used by the project.
* This automatically defines a type variable for any types provided by the configured TS libs.
* For more information, see https://www.typescriptlang.org/tsconfig#lib
*
* Defaults to the lib for the provided `ecmaVersion`.
*/
lib?: Lib[];
/**
* The source type of the script.
*/
sourceType?: 'script' | 'module';
}
```
Example usage:
```ts
import { analyze } from '@typescript-eslint/scope-manager';
import { parse } from '@typescript-eslint/typescript-estree';
const code = `const hello: string = 'world';`;
const ast = parse(code, {
// note that scope-manager requires ranges on the AST
range: true,
});
const scope = analyze(ast, {
ecmaVersion: 2020,
sourceType: 'module',
});
```
## References
- https://eslint.org/docs/developer-guide/scope-manager-interface
- https://github.com/eslint/eslint-scope
## Contributing
[See the contributing guide here](../../CONTRIBUTING.md)

View File

@ -0,0 +1,24 @@
'use strict';
// @ts-check
/** @type {import('@jest/types').Config.InitialOptions} */
module.exports = {
globals: {
'ts-jest': {
isolatedModules: true,
},
},
testEnvironment: 'node',
transform: {
[/^.+\.tsx?$/.source]: 'ts-jest',
},
testRegex: [
/.\/tests\/.+\.test\.ts$/.source,
/.\/tests\/eslint-scope\/[^/]+\.test\.ts$/.source,
],
collectCoverage: false,
collectCoverageFrom: ['src/**/*.{js,jsx,ts,tsx}'],
moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
coverageReporters: ['text-summary', 'lcov'],
setupFilesAfterEnv: ['./tests/util/serializers/index.ts'],
};

View File

@ -0,0 +1,67 @@
{
"name": "@typescript-eslint/scope-manager",
"version": "3.4.0",
"description": "TypeScript scope analyser for ESLint",
"keywords": [
"eslint",
"typescript",
"estree"
],
"engines": {
"node": "^8.10.0 || ^10.13.0 || >=11.10.1"
},
"files": [
"dist",
"package.json",
"README.md",
"LICENSE"
],
"repository": {
"type": "git",
"url": "https://github.com/typescript-eslint/typescript-eslint.git",
"directory": "packages/scope-manager"
},
"bugs": {
"url": "https://github.com/typescript-eslint/typescript-eslint/issues"
},
"license": "MIT",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"scripts": {
"build": "tsc -b tsconfig.build.json",
"postbuild": "downlevel-dts dist _ts3.4/dist",
"clean": "tsc -b tsconfig.build.json --clean",
"format": "prettier --write \"./**/*.{ts,js,json,md}\" --ignore-path ../../.prettierignore",
"generate:lib": "../../node_modules/.bin/ts-node --files --transpile-only tools/generate-lib.ts",
"lint": "eslint . --ext .js,.ts --ignore-path='../../.eslintignore'",
"test": "jest --coverage",
"typecheck": "tsc -p tsconfig.json --noEmit"
},
"dependencies": {
"@typescript-eslint/types": "3.4.0",
"@typescript-eslint/visitor-keys": "3.4.0"
},
"devDependencies": {
"@types/jest-specific-snapshot": "^0.5.4",
"@types/mkdirp": "^1.0.0",
"@typescript-eslint/typescript-estree": "3.4.0",
"glob": "^7.1.6",
"jest-specific-snapshot": "^3.0.0",
"make-dir": "^3.1.0",
"prettier": "*",
"pretty-format": "^25.5.0",
"rimraf": "*",
"typescript": "*"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/typescript-eslint"
},
"typesVersions": {
"<3.8": {
"*": [
"_ts3.4/*"
]
}
}
}

View File

@ -0,0 +1,20 @@
const ID_CACHE = new Map<number, number>();
let NEXT_KEY = 0;
function createIdGenerator(): () => number {
const key = (NEXT_KEY += 1);
ID_CACHE.set(key, 0);
return (): number => {
const current = ID_CACHE.get(key) ?? 0;
const next = current + 1;
ID_CACHE.set(key, next);
return next;
};
}
function resetIds(): void {
ID_CACHE.clear();
}
export { createIdGenerator, resetIds };

View File

@ -0,0 +1,251 @@
import { TSESTree } from '@typescript-eslint/types';
import { assert } from './assert';
import {
BlockScope,
CatchScope,
ClassScope,
ConditionalTypeScope,
ForScope,
FunctionExpressionNameScope,
FunctionScope,
FunctionTypeScope,
GlobalScope,
MappedTypeScope,
ModuleScope,
Scope,
SwitchScope,
TSEnumScope,
TSModuleScope,
TypeScope,
WithScope,
} from './scope';
import { Variable } from './variable';
interface ScopeManagerOptions {
globalReturn?: boolean;
sourceType?: 'module' | 'script';
impliedStrict?: boolean;
ecmaVersion?: number;
}
class ScopeManager {
public currentScope: Scope | null;
public readonly declaredVariables: WeakMap<TSESTree.Node, Variable[]>;
/**
* The root scope
* @public
*/
public globalScope: GlobalScope | null;
public readonly nodeToScope: WeakMap<TSESTree.Node, Scope[]>;
readonly #options: ScopeManagerOptions;
/**
* All scopes
* @public
*/
public readonly scopes: Scope[];
public get variables(): Variable[] {
const variables = new Set<Variable>();
function recurse(scope: Scope): void {
scope.variables.forEach(v => variables.add(v));
scope.childScopes.forEach(recurse);
}
this.scopes.forEach(recurse);
return Array.from(variables).sort((a, b) => a.$id - b.$id);
}
constructor(options: ScopeManagerOptions) {
this.scopes = [];
this.globalScope = null;
this.nodeToScope = new WeakMap();
this.currentScope = null;
this.#options = options;
this.declaredVariables = new WeakMap();
}
public isGlobalReturn(): boolean {
return this.#options.globalReturn === true;
}
public isModule(): boolean {
return this.#options.sourceType === 'module';
}
public isImpliedStrict(): boolean {
return this.#options.impliedStrict === true;
}
public isStrictModeSupported(): boolean {
return this.#options.ecmaVersion != null && this.#options.ecmaVersion >= 5;
}
public isES6(): boolean {
return this.#options.ecmaVersion != null && this.#options.ecmaVersion >= 6;
}
/**
* Get the variables that a given AST node defines. The gotten variables' `def[].node`/`def[].parent` property is the node.
* If the node does not define any variable, this returns an empty array.
* @param node An AST node to get their variables.
* @public
*/
public getDeclaredVariables(node: TSESTree.Node): Variable[] {
return this.declaredVariables.get(node) ?? [];
}
/**
* Get the scope of a given AST node. The gotten scope's `block` property is the node.
* This method never returns `function-expression-name` scope. If the node does not have their scope, this returns `null`.
*
* @param node An AST node to get their scope.
* @param inner If the node has multiple scopes, this returns the outermost scope normally.
* If `inner` is `true` then this returns the innermost scope.
* @public
*/
public acquire(node: TSESTree.Node, inner = false): Scope | null {
function predicate(testScope: Scope): boolean {
if (testScope.type === 'function' && testScope.functionExpressionScope) {
return false;
}
return true;
}
const scopes = this.nodeToScope.get(node);
if (!scopes || scopes.length === 0) {
return null;
}
// Heuristic selection from all scopes.
// If you would like to get all scopes, please use ScopeManager#acquireAll.
if (scopes.length === 1) {
return scopes[0];
}
if (inner) {
for (let i = scopes.length - 1; i >= 0; --i) {
const scope = scopes[i];
if (predicate(scope)) {
return scope;
}
}
} else {
for (let i = 0; i < scopes.length; ++i) {
const scope = scopes[i];
if (predicate(scope)) {
return scope;
}
}
}
return null;
}
protected nestScope<T extends Scope>(scope: T): T;
protected nestScope(scope: Scope): Scope {
if (scope instanceof GlobalScope) {
assert(this.currentScope === null);
this.globalScope = scope;
}
this.currentScope = scope;
return scope;
}
public nestBlockScope(node: BlockScope['block']): BlockScope {
assert(this.currentScope);
return this.nestScope(new BlockScope(this, this.currentScope, node));
}
public nestCatchScope(node: CatchScope['block']): CatchScope {
assert(this.currentScope);
return this.nestScope(new CatchScope(this, this.currentScope, node));
}
public nestClassScope(node: ClassScope['block']): ClassScope {
assert(this.currentScope);
return this.nestScope(new ClassScope(this, this.currentScope, node));
}
public nestConditionalTypeScope(
node: ConditionalTypeScope['block'],
): ConditionalTypeScope {
assert(this.currentScope);
return this.nestScope(
new ConditionalTypeScope(this, this.currentScope, node),
);
}
public nestForScope(node: ForScope['block']): ForScope {
assert(this.currentScope);
return this.nestScope(new ForScope(this, this.currentScope, node));
}
public nestFunctionExpressionNameScope(
node: FunctionExpressionNameScope['block'],
): FunctionExpressionNameScope {
assert(this.currentScope);
return this.nestScope(
new FunctionExpressionNameScope(this, this.currentScope, node),
);
}
public nestFunctionScope(
node: FunctionScope['block'],
isMethodDefinition: boolean,
): FunctionScope {
assert(this.currentScope);
return this.nestScope(
new FunctionScope(this, this.currentScope, node, isMethodDefinition),
);
}
public nestFunctionTypeScope(
node: FunctionTypeScope['block'],
): FunctionTypeScope {
assert(this.currentScope);
return this.nestScope(new FunctionTypeScope(this, this.currentScope, node));
}
public nestGlobalScope(node: GlobalScope['block']): GlobalScope {
return this.nestScope(new GlobalScope(this, node));
}
public nestMappedTypeScope(node: MappedTypeScope['block']): MappedTypeScope {
assert(this.currentScope);
return this.nestScope(new MappedTypeScope(this, this.currentScope, node));
}
public nestModuleScope(node: ModuleScope['block']): ModuleScope {
assert(this.currentScope);
return this.nestScope(new ModuleScope(this, this.currentScope, node));
}
public nestSwitchScope(node: SwitchScope['block']): SwitchScope {
assert(this.currentScope);
return this.nestScope(new SwitchScope(this, this.currentScope, node));
}
public nestTSEnumScope(node: TSEnumScope['block']): TSEnumScope {
assert(this.currentScope);
return this.nestScope(new TSEnumScope(this, this.currentScope, node));
}
public nestTSModuleScope(node: TSModuleScope['block']): TSModuleScope {
assert(this.currentScope);
return this.nestScope(new TSModuleScope(this, this.currentScope, node));
}
public nestTypeScope(node: TypeScope['block']): TypeScope {
assert(this.currentScope);
return this.nestScope(new TypeScope(this, this.currentScope, node));
}
public nestWithScope(node: WithScope['block']): WithScope {
assert(this.currentScope);
return this.nestScope(new WithScope(this, this.currentScope, node));
}
}
export { ScopeManager };

View File

@ -0,0 +1,103 @@
import { TSESTree, EcmaVersion, Lib } from '@typescript-eslint/types';
import { visitorKeys } from '@typescript-eslint/visitor-keys';
import { Referencer, ReferencerOptions } from './referencer';
import { ScopeManager } from './ScopeManager';
////////////////////////////////////////////////////
// MAKE SURE THIS IS KEPT IN SYNC WITH THE README //
////////////////////////////////////////////////////
interface AnalyzeOptions {
/**
* Known visitor keys.
*/
childVisitorKeys?: ReferencerOptions['childVisitorKeys'];
/**
* Which ECMAScript version is considered.
* Defaults to `2018`.
*/
ecmaVersion?: EcmaVersion;
/**
* Whether the whole script is executed under node.js environment.
* When enabled, the scope manager adds a function scope immediately following the global scope.
* Defaults to `false`.
*/
globalReturn?: boolean;
/**
* Implied strict mode (if ecmaVersion >= 5).
* Defaults to `false`.
*/
impliedStrict?: boolean;
/**
* The lib used by the project.
* This automatically defines a type variable for any types provided by the configured TS libs.
* Defaults to the lib for the provided `ecmaVersion`.
*
* https://www.typescriptlang.org/tsconfig#lib
*/
lib?: Lib[];
/**
* The source type of the script.
*/
sourceType?: 'script' | 'module';
}
const DEFAULT_OPTIONS: Required<AnalyzeOptions> = {
childVisitorKeys: visitorKeys,
ecmaVersion: 2018,
globalReturn: false,
impliedStrict: false,
lib: ['es2018'],
sourceType: 'script',
};
function mapEcmaVersion(version: EcmaVersion | undefined): Lib {
if (version == null || version === 3 || version === 5) {
return 'es5';
}
if (version > 2000) {
return `es${version}` as Lib;
}
const year = 2015 + (version - 6);
return `es${year}` as Lib;
}
/**
* Takes an AST and returns the analyzed scopes.
*/
function analyze(
tree: TSESTree.Node,
providedOptions?: AnalyzeOptions,
): ScopeManager {
const ecmaVersion =
providedOptions?.ecmaVersion ?? DEFAULT_OPTIONS.ecmaVersion;
const options: Required<AnalyzeOptions> = {
globalReturn: providedOptions?.globalReturn ?? DEFAULT_OPTIONS.globalReturn,
impliedStrict:
providedOptions?.impliedStrict ?? DEFAULT_OPTIONS.impliedStrict,
sourceType: providedOptions?.sourceType ?? DEFAULT_OPTIONS.sourceType,
ecmaVersion,
childVisitorKeys:
providedOptions?.childVisitorKeys ?? DEFAULT_OPTIONS.childVisitorKeys,
lib: providedOptions?.lib ?? [mapEcmaVersion(ecmaVersion)],
};
// ensure the option is lower cased
options.lib = options.lib.map(l => l.toLowerCase() as Lib);
const scopeManager = new ScopeManager(options);
const referencer = new Referencer(options, scopeManager);
referencer.visit(tree);
return scopeManager;
}
export { analyze, AnalyzeOptions };

View File

@ -0,0 +1,8 @@
// the base assert module doesn't use ts assertion syntax
function assert(value: unknown, message?: string): asserts value {
if (value == null) {
throw new Error(message);
}
}
export { assert };

View File

@ -0,0 +1,19 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class CatchClauseDefinition extends DefinitionBase<
DefinitionType.CatchClause,
TSESTree.CatchClause,
null,
TSESTree.BindingName
> {
constructor(name: TSESTree.BindingName, node: CatchClauseDefinition['node']) {
super(DefinitionType.CatchClause, name, node, null);
}
public readonly isTypeDefinition = false;
public readonly isVariableDefinition = true;
}
export { CatchClauseDefinition };

View File

@ -0,0 +1,19 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class ClassNameDefinition extends DefinitionBase<
DefinitionType.ClassName,
TSESTree.ClassDeclaration | TSESTree.ClassExpression,
null,
TSESTree.Identifier
> {
constructor(name: TSESTree.Identifier, node: ClassNameDefinition['node']) {
super(DefinitionType.ClassName, name, node, null);
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition = true;
}
export { ClassNameDefinition };

View File

@ -0,0 +1,26 @@
import { CatchClauseDefinition } from './CatchClauseDefinition';
import { ClassNameDefinition } from './ClassNameDefinition';
import { FunctionNameDefinition } from './FunctionNameDefinition';
import { ImplicitGlobalVariableDefinition } from './ImplicitGlobalVariableDefinition';
import { ImportBindingDefinition } from './ImportBindingDefinition';
import { ParameterDefinition } from './ParameterDefinition';
import { TSEnumMemberDefinition } from './TSEnumMemberDefinition';
import { TSEnumNameDefinition } from './TSEnumNameDefinition';
import { TSModuleNameDefinition } from './TSModuleNameDefinition';
import { TypeDefinition } from './TypeDefinition';
import { VariableDefinition } from './VariableDefinition';
type Definition =
| CatchClauseDefinition
| ClassNameDefinition
| FunctionNameDefinition
| ImplicitGlobalVariableDefinition
| ImportBindingDefinition
| ParameterDefinition
| TSEnumMemberDefinition
| TSEnumNameDefinition
| TSModuleNameDefinition
| TypeDefinition
| VariableDefinition;
export { Definition };

View File

@ -0,0 +1,60 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { createIdGenerator } from '../ID';
const generator = createIdGenerator();
abstract class DefinitionBase<
TType extends DefinitionType,
TNode extends TSESTree.Node,
TParent extends TSESTree.Node | null,
TName extends TSESTree.Node = TSESTree.BindingName
> {
/**
* A unique ID for this instance - primarily used to help debugging and testing
*/
public readonly $id: number = generator();
/**
* The type of the definition
* @public
*/
public readonly type: TType;
/**
* The `Identifier` node of this definition
* @public
*/
public readonly name: TName;
/**
* The enclosing node of the name.
* @public
*/
public readonly node: TNode;
/**
* the enclosing statement node of the identifier.
* @public
*/
public readonly parent: TParent;
constructor(type: TType, name: TName, node: TNode, parent: TParent) {
this.type = type;
this.name = name;
this.node = node;
this.parent = parent;
}
/**
* `true` if the variable is valid in a type context, false otherwise
*/
public abstract readonly isTypeDefinition: boolean;
/**
* `true` if the variable is valid in a value context, false otherwise
*/
public abstract readonly isVariableDefinition: boolean;
}
export { DefinitionBase };

View File

@ -0,0 +1,16 @@
enum DefinitionType {
// eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
CatchClause = 'CatchClause',
ClassName = 'ClassName',
FunctionName = 'FunctionName',
ImplicitGlobalVariable = 'ImplicitGlobalVariable',
ImportBinding = 'ImportBinding',
Parameter = 'Parameter',
TSEnumName = 'TSEnumName',
TSEnumMember = 'TSEnumMemberName',
TSModuleName = 'TSModuleName',
Type = 'Type',
Variable = 'Variable',
}
export { DefinitionType };

View File

@ -0,0 +1,22 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class FunctionNameDefinition extends DefinitionBase<
DefinitionType.FunctionName,
| TSESTree.FunctionDeclaration
| TSESTree.FunctionExpression
| TSESTree.TSDeclareFunction
| TSESTree.TSEmptyBodyFunctionExpression,
null,
TSESTree.Identifier
> {
constructor(name: TSESTree.Identifier, node: FunctionNameDefinition['node']) {
super(DefinitionType.FunctionName, name, node, null);
}
public readonly isTypeDefinition = false;
public readonly isVariableDefinition = true;
}
export { FunctionNameDefinition };

View File

@ -0,0 +1,22 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class ImplicitGlobalVariableDefinition extends DefinitionBase<
DefinitionType.ImplicitGlobalVariable,
TSESTree.Node,
null,
TSESTree.BindingName
> {
constructor(
name: TSESTree.BindingName,
node: ImplicitGlobalVariableDefinition['node'],
) {
super(DefinitionType.ImplicitGlobalVariable, name, node, null);
}
public readonly isTypeDefinition = false;
public readonly isVariableDefinition = true;
}
export { ImplicitGlobalVariableDefinition };

View File

@ -0,0 +1,44 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class ImportBindingDefinition extends DefinitionBase<
DefinitionType.ImportBinding,
| TSESTree.ImportSpecifier
| TSESTree.ImportDefaultSpecifier
| TSESTree.ImportNamespaceSpecifier
| TSESTree.TSImportEqualsDeclaration,
TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration,
TSESTree.Identifier
> {
constructor(
name: TSESTree.Identifier,
node: TSESTree.TSImportEqualsDeclaration,
decl: TSESTree.TSImportEqualsDeclaration,
);
constructor(
name: TSESTree.Identifier,
node: Exclude<
ImportBindingDefinition['node'],
TSESTree.TSImportEqualsDeclaration
>,
decl: TSESTree.ImportDeclaration,
);
constructor(
name: TSESTree.Identifier,
node: ImportBindingDefinition['node'],
decl: TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration,
) {
super(DefinitionType.ImportBinding, name, node, decl);
if ('importKind' in this.parent && this.parent.importKind === 'type') {
this.isVariableDefinition = false;
} else {
this.isVariableDefinition = true;
}
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition: boolean;
}
export { ImportBindingDefinition };

View File

@ -0,0 +1,37 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class ParameterDefinition extends DefinitionBase<
DefinitionType.Parameter,
| TSESTree.ArrowFunctionExpression
| TSESTree.FunctionDeclaration
| TSESTree.FunctionExpression
| TSESTree.TSCallSignatureDeclaration
| TSESTree.TSConstructorType
| TSESTree.TSConstructSignatureDeclaration
| TSESTree.TSDeclareFunction
| TSESTree.TSEmptyBodyFunctionExpression
| TSESTree.TSFunctionType
| TSESTree.TSMethodSignature,
null,
TSESTree.BindingName
> {
/**
* Whether the parameter definition is a part of a rest parameter.
*/
public readonly rest: boolean;
constructor(
name: TSESTree.BindingName,
node: ParameterDefinition['node'],
rest: boolean,
) {
super(DefinitionType.Parameter, name, node, null);
this.rest = rest;
}
public readonly isTypeDefinition = false;
public readonly isVariableDefinition = true;
}
export { ParameterDefinition };

View File

@ -0,0 +1,22 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class TSEnumMemberDefinition extends DefinitionBase<
DefinitionType.TSEnumMember,
TSESTree.TSEnumMember,
null,
TSESTree.Identifier | TSESTree.StringLiteral
> {
constructor(
name: TSESTree.Identifier | TSESTree.StringLiteral,
node: TSEnumMemberDefinition['node'],
) {
super(DefinitionType.TSEnumMember, name, node, null);
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition = true;
}
export { TSEnumMemberDefinition };

View File

@ -0,0 +1,19 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class TSEnumNameDefinition extends DefinitionBase<
DefinitionType.TSEnumName,
TSESTree.TSEnumDeclaration,
null,
TSESTree.Identifier
> {
constructor(name: TSESTree.Identifier, node: TSEnumNameDefinition['node']) {
super(DefinitionType.TSEnumName, name, node, null);
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition = true;
}
export { TSEnumNameDefinition };

View File

@ -0,0 +1,19 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class TSModuleNameDefinition extends DefinitionBase<
DefinitionType.TSModuleName,
TSESTree.TSModuleDeclaration,
null,
TSESTree.Identifier
> {
constructor(name: TSESTree.Identifier, node: TSModuleNameDefinition['node']) {
super(DefinitionType.TSModuleName, name, node, null);
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition = true;
}
export { TSModuleNameDefinition };

View File

@ -0,0 +1,21 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class TypeDefinition extends DefinitionBase<
DefinitionType.Type,
| TSESTree.TSInterfaceDeclaration
| TSESTree.TSTypeAliasDeclaration
| TSESTree.TSTypeParameter,
null,
TSESTree.Identifier
> {
constructor(name: TSESTree.Identifier, node: TypeDefinition['node']) {
super(DefinitionType.Type, name, node, null);
}
public readonly isTypeDefinition = true;
public readonly isVariableDefinition = false;
}
export { TypeDefinition };

View File

@ -0,0 +1,23 @@
import { TSESTree } from '@typescript-eslint/types';
import { DefinitionType } from './DefinitionType';
import { DefinitionBase } from './DefinitionBase';
class VariableDefinition extends DefinitionBase<
DefinitionType.Variable,
TSESTree.VariableDeclarator,
TSESTree.VariableDeclaration,
TSESTree.Identifier
> {
constructor(
name: TSESTree.Identifier,
node: VariableDefinition['node'],
decl: TSESTree.VariableDeclaration,
) {
super(DefinitionType.Variable, name, node, decl);
}
public readonly isTypeDefinition = false;
public readonly isVariableDefinition = true;
}
export { VariableDefinition };

View File

@ -0,0 +1,13 @@
export * from './CatchClauseDefinition';
export * from './ClassNameDefinition';
export * from './Definition';
export * from './DefinitionType';
export * from './FunctionNameDefinition';
export * from './ImplicitGlobalVariableDefinition';
export * from './ImportBindingDefinition';
export * from './ParameterDefinition';
export * from './TSEnumMemberDefinition';
export * from './TSEnumNameDefinition';
export * from './TSModuleNameDefinition';
export * from './TypeDefinition';
export * from './VariableDefinition';

View File

@ -0,0 +1,12 @@
export { analyze, AnalyzeOptions } from './analyze';
export * from './definition';
export { Reference } from './referencer/Reference';
export { Visitor } from './referencer/Visitor';
export {
PatternVisitor,
PatternVisitorCallback,
PatternVisitorOptions,
} from './referencer/PatternVisitor';
export * from './scope';
export { ScopeManager } from './ScopeManager';
export * from './variable';

View File

@ -0,0 +1,372 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const dom_iterable = {
AudioParam: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AudioParam',
writeable: false,
},
AudioParamMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AudioParamMap',
writeable: false,
},
BaseAudioContext: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BaseAudioContext',
writeable: false,
},
CSSRuleList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'CSSRuleList',
writeable: false,
},
CSSStyleDeclaration: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'CSSStyleDeclaration',
writeable: false,
},
Cache: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Cache',
writeable: false,
},
CanvasPathDrawingStyles: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'CanvasPathDrawingStyles',
writeable: false,
},
ClientRectList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ClientRectList',
writeable: false,
},
DOMRectList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DOMRectList',
writeable: false,
},
DOMStringList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DOMStringList',
writeable: false,
},
DOMTokenList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DOMTokenList',
writeable: false,
},
DataTransferItemList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DataTransferItemList',
writeable: false,
},
FileList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'FileList',
writeable: false,
},
FormData: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'FormData',
writeable: false,
},
HTMLAllCollection: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'HTMLAllCollection',
writeable: false,
},
HTMLCollectionBase: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'HTMLCollectionBase',
writeable: false,
},
HTMLCollectionOf: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'HTMLCollectionOf',
writeable: false,
},
HTMLFormElement: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'HTMLFormElement',
writeable: false,
},
HTMLSelectElement: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'HTMLSelectElement',
writeable: false,
},
Headers: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Headers',
writeable: false,
},
IDBObjectStore: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IDBObjectStore',
writeable: false,
},
MediaKeyStatusMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MediaKeyStatusMap',
writeable: false,
},
MediaList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MediaList',
writeable: false,
},
MimeTypeArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MimeTypeArray',
writeable: false,
},
NamedNodeMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NamedNodeMap',
writeable: false,
},
Navigator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Navigator',
writeable: false,
},
NodeList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NodeList',
writeable: false,
},
NodeListOf: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NodeListOf',
writeable: false,
},
Plugin: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Plugin',
writeable: false,
},
PluginArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PluginArray',
writeable: false,
},
RTCRtpTransceiver: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RTCRtpTransceiver',
writeable: false,
},
RTCStatsReport: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RTCStatsReport',
writeable: false,
},
SVGLengthList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SVGLengthList',
writeable: false,
},
SVGNumberList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SVGNumberList',
writeable: false,
},
SVGPointList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SVGPointList',
writeable: false,
},
SVGStringList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SVGStringList',
writeable: false,
},
SourceBufferList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SourceBufferList',
writeable: false,
},
SpeechGrammarList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SpeechGrammarList',
writeable: false,
},
SpeechRecognitionResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SpeechRecognitionResult',
writeable: false,
},
SpeechRecognitionResultList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SpeechRecognitionResultList',
writeable: false,
},
StyleSheetList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'StyleSheetList',
writeable: false,
},
TextTrackCueList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TextTrackCueList',
writeable: false,
},
TextTrackList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TextTrackList',
writeable: false,
},
TouchList: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TouchList',
writeable: false,
},
URLSearchParams: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'URLSearchParams',
writeable: false,
},
VRDisplay: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'VRDisplay',
writeable: false,
},
WEBGL_draw_buffers: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WEBGL_draw_buffers',
writeable: false,
},
WebAuthentication: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WebAuthentication',
writeable: false,
},
WebGL2RenderingContextBase: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WebGL2RenderingContextBase',
writeable: false,
},
WebGL2RenderingContextOverloads: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WebGL2RenderingContextOverloads',
writeable: false,
},
WebGLRenderingContextBase: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WebGLRenderingContextBase',
writeable: false,
},
WebGLRenderingContextOverloads: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WebGLRenderingContextOverloads',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,78 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_collection = {
Map: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Map',
writeable: false,
},
MapConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MapConstructor',
writeable: false,
},
ReadonlyMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyMap',
writeable: false,
},
WeakMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'WeakMap',
writeable: false,
},
WeakMapConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakMapConstructor',
writeable: false,
},
Set: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Set',
writeable: false,
},
SetConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SetConstructor',
writeable: false,
},
ReadonlySet: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlySet',
writeable: false,
},
WeakSet: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'WeakSet',
writeable: false,
},
WeakSetConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakSetConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,92 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_core = {
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayConstructor',
writeable: false,
},
DateConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DateConstructor',
writeable: false,
},
Function: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Function',
writeable: false,
},
Math: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Math',
writeable: false,
},
NumberConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NumberConstructor',
writeable: false,
},
ObjectConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ObjectConstructor',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
RegExp: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExp',
writeable: false,
},
RegExpConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpConstructor',
writeable: false,
},
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
StringConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'StringConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,31 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_iterable } from './es2015.iterable';
export const es2015_generator = {
...es2015_iterable,
Generator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Generator',
writeable: false,
},
GeneratorFunction: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'GeneratorFunction',
writeable: false,
},
GeneratorFunctionConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'GeneratorFunctionConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,311 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_symbol } from './es2015.symbol';
export const es2015_iterable = {
...es2015_symbol,
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
IteratorYieldResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IteratorYieldResult',
writeable: false,
},
IteratorReturnResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IteratorReturnResult',
writeable: false,
},
IteratorResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IteratorResult',
writeable: false,
},
Iterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Iterator',
writeable: false,
},
Iterable: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Iterable',
writeable: false,
},
IterableIterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IterableIterator',
writeable: false,
},
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayConstructor',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
IArguments: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IArguments',
writeable: false,
},
Map: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Map',
writeable: false,
},
ReadonlyMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyMap',
writeable: false,
},
MapConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MapConstructor',
writeable: false,
},
WeakMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakMap',
writeable: false,
},
WeakMapConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakMapConstructor',
writeable: false,
},
Set: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Set',
writeable: false,
},
ReadonlySet: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlySet',
writeable: false,
},
SetConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SetConstructor',
writeable: false,
},
WeakSet: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakSet',
writeable: false,
},
WeakSetConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakSetConstructor',
writeable: false,
},
Promise: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Promise',
writeable: false,
},
PromiseConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructor',
writeable: false,
},
Reflect: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Reflect',
writeable: false,
},
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
Int8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8Array',
writeable: false,
},
Int8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8ArrayConstructor',
writeable: false,
},
Uint8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8Array',
writeable: false,
},
Uint8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ArrayConstructor',
writeable: false,
},
Uint8ClampedArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArray',
writeable: false,
},
Uint8ClampedArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArrayConstructor',
writeable: false,
},
Int16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16Array',
writeable: false,
},
Int16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16ArrayConstructor',
writeable: false,
},
Uint16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16Array',
writeable: false,
},
Uint16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16ArrayConstructor',
writeable: false,
},
Int32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32Array',
writeable: false,
},
Int32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32ArrayConstructor',
writeable: false,
},
Uint32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32Array',
writeable: false,
},
Uint32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32ArrayConstructor',
writeable: false,
},
Float32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32Array',
writeable: false,
},
Float32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32ArrayConstructor',
writeable: false,
},
Float64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64Array',
writeable: false,
},
Float64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64ArrayConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_promise = {
PromiseConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,22 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_proxy = {
ProxyHandler: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ProxyHandler',
writeable: false,
},
ProxyConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ProxyConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_reflect = {
Reflect: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Reflect',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2015_symbol = {
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,234 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_symbol } from './es2015.symbol';
export const es2015_symbol_wellknown = {
...es2015_symbol,
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
Symbol: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Symbol',
writeable: false,
},
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
Date: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Date',
writeable: false,
},
Map: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Map',
writeable: false,
},
WeakMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakMap',
writeable: false,
},
Set: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Set',
writeable: false,
},
WeakSet: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'WeakSet',
writeable: false,
},
JSON: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'JSON',
writeable: false,
},
Function: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Function',
writeable: false,
},
GeneratorFunction: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'GeneratorFunction',
writeable: false,
},
Math: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Math',
writeable: false,
},
Promise: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Promise',
writeable: false,
},
PromiseConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructor',
writeable: false,
},
RegExp: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExp',
writeable: false,
},
RegExpConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpConstructor',
writeable: false,
},
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
ArrayBuffer: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBuffer',
writeable: false,
},
DataView: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DataView',
writeable: false,
},
Int8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8Array',
writeable: false,
},
Uint8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8Array',
writeable: false,
},
Uint8ClampedArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArray',
writeable: false,
},
Int16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16Array',
writeable: false,
},
Uint16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16Array',
writeable: false,
},
Int32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32Array',
writeable: false,
},
Uint32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32Array',
writeable: false,
},
Float32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32Array',
writeable: false,
},
Float64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64Array',
writeable: false,
},
ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayConstructor',
writeable: false,
},
MapConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MapConstructor',
writeable: false,
},
SetConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SetConstructor',
writeable: false,
},
ArrayBufferConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,28 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es5 } from './es5';
import { es2015_core } from './es2015.core';
import { es2015_collection } from './es2015.collection';
import { es2015_iterable } from './es2015.iterable';
import { es2015_generator } from './es2015.generator';
import { es2015_promise } from './es2015.promise';
import { es2015_proxy } from './es2015.proxy';
import { es2015_reflect } from './es2015.reflect';
import { es2015_symbol } from './es2015.symbol';
import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
export const es2015 = {
...es5,
...es2015_core,
...es2015_collection,
...es2015_iterable,
...es2015_generator,
...es2015_promise,
...es2015_proxy,
...es2015_reflect,
...es2015_symbol,
...es2015_symbol_wellknown,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,85 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2016_array_include = {
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
Int8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8Array',
writeable: false,
},
Uint8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8Array',
writeable: false,
},
Uint8ClampedArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArray',
writeable: false,
},
Int16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16Array',
writeable: false,
},
Uint16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16Array',
writeable: false,
},
Int32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32Array',
writeable: false,
},
Uint32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32Array',
writeable: false,
},
Float32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32Array',
writeable: false,
},
Float64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64Array',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2016 } from './es2016';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const es2016_full = {
...es2016,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,12 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015 } from './es2015';
import { es2016_array_include } from './es2016.array.include';
export const es2016 = {
...es2015,
...es2016_array_include,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2017 } from './es2017';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const es2017_full = {
...es2017,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2017_intl = {
Intl: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Intl',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2017_object = {
ObjectConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ObjectConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,40 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_symbol } from './es2015.symbol';
import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
export const es2017_sharedmemory = {
...es2015_symbol,
...es2015_symbol_wellknown,
SharedArrayBuffer: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'SharedArrayBuffer',
writeable: false,
},
SharedArrayBufferConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SharedArrayBufferConstructor',
writeable: false,
},
ArrayBufferTypes: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferTypes',
writeable: false,
},
Atomics: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Atomics',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2017_string = {
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,20 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2016 } from './es2016';
import { es2017_object } from './es2017.object';
import { es2017_sharedmemory } from './es2017.sharedmemory';
import { es2017_string } from './es2017.string';
import { es2017_intl } from './es2017.intl';
import { es2017_typedarrays } from './es2017.typedarrays';
export const es2017 = {
...es2016,
...es2017_object,
...es2017_sharedmemory,
...es2017_string,
...es2017_intl,
...es2017_typedarrays,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,71 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2017_typedarrays = {
Int8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8ArrayConstructor',
writeable: false,
},
Uint8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ArrayConstructor',
writeable: false,
},
Uint8ClampedArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArrayConstructor',
writeable: false,
},
Int16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16ArrayConstructor',
writeable: false,
},
Uint16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16ArrayConstructor',
writeable: false,
},
Int32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32ArrayConstructor',
writeable: false,
},
Uint32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32ArrayConstructor',
writeable: false,
},
Float32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32ArrayConstructor',
writeable: false,
},
Float64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64ArrayConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,31 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2018_asynciterable } from './es2018.asynciterable';
export const es2018_asyncgenerator = {
...es2018_asynciterable,
AsyncGenerator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncGenerator',
writeable: false,
},
AsyncGeneratorFunction: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncGeneratorFunction',
writeable: false,
},
AsyncGeneratorFunctionConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncGeneratorFunctionConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,40 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_symbol } from './es2015.symbol';
import { es2015_iterable } from './es2015.iterable';
export const es2018_asynciterable = {
...es2015_symbol,
...es2015_iterable,
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
AsyncIterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterator',
writeable: false,
},
AsyncIterable: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterable',
writeable: false,
},
AsyncIterableIterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterableIterator',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2018 } from './es2018';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const es2018_full = {
...es2018,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2018_intl = {
Intl: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Intl',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2018_promise = {
Promise: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Promise',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,29 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2018_regexp = {
RegExpMatchArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpMatchArray',
writeable: false,
},
RegExpExecArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpExecArray',
writeable: false,
},
RegExp: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExp',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,20 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2017 } from './es2017';
import { es2018_asynciterable } from './es2018.asynciterable';
import { es2018_asyncgenerator } from './es2018.asyncgenerator';
import { es2018_promise } from './es2018.promise';
import { es2018_regexp } from './es2018.regexp';
import { es2018_intl } from './es2018.intl';
export const es2018 = {
...es2017,
...es2018_asynciterable,
...es2018_asyncgenerator,
...es2018_promise,
...es2018_regexp,
...es2018_intl,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,29 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2019_array = {
FlatArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'FlatArray',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2019 } from './es2019';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const es2019_full = {
...es2019,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,17 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_iterable } from './es2015.iterable';
export const es2019_object = {
...es2015_iterable,
ObjectConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ObjectConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2019_string = {
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2019_symbol = {
Symbol: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Symbol',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2018 } from './es2018';
import { es2019_array } from './es2019.array';
import { es2019_object } from './es2019.object';
import { es2019_string } from './es2019.string';
import { es2019_symbol } from './es2019.symbol';
export const es2019 = {
...es2018,
...es2019_array,
...es2019_object,
...es2019_string,
...es2019_symbol,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,57 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2020_bigint = {
BigInt: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigInt',
writeable: false,
},
BigIntConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigIntConstructor',
writeable: false,
},
BigInt64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigInt64Array',
writeable: false,
},
BigInt64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigInt64ArrayConstructor',
writeable: false,
},
BigUint64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigUint64Array',
writeable: false,
},
BigUint64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigUint64ArrayConstructor',
writeable: false,
},
DataView: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DataView',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2020 } from './es2020';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const es2020_full = {
...es2020,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,36 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es2020_promise = {
PromiseFulfilledResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseFulfilledResult',
writeable: false,
},
PromiseRejectedResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseRejectedResult',
writeable: false,
},
PromiseSettledResult: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseSettledResult',
writeable: false,
},
PromiseConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,17 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_iterable } from './es2015.iterable';
export const es2020_string = {
...es2015_iterable,
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,26 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_iterable } from './es2015.iterable';
import { es2015_symbol } from './es2015.symbol';
export const es2020_symbol_wellknown = {
...es2015_iterable,
...es2015_symbol,
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
RegExp: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExp',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2019 } from './es2019';
import { es2020_bigint } from './es2020.bigint';
import { es2020_promise } from './es2020.promise';
import { es2020_string } from './es2020.string';
import { es2020_symbol_wellknown } from './es2020.symbol.wellknown';
export const es2020 = {
...es2019,
...es2020_bigint,
...es2020_promise,
...es2020_string,
...es2020_symbol_wellknown,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,680 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const es5 = {
Symbol: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Symbol',
writeable: false,
},
PropertyKey: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PropertyKey',
writeable: false,
},
PropertyDescriptor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PropertyDescriptor',
writeable: false,
},
PropertyDescriptorMap: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PropertyDescriptorMap',
writeable: false,
},
Object: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Object',
writeable: false,
},
ObjectConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ObjectConstructor',
writeable: false,
},
Function: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Function',
writeable: false,
},
FunctionConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'FunctionConstructor',
writeable: false,
},
ThisParameterType: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ThisParameterType',
writeable: false,
},
OmitThisParameter: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'OmitThisParameter',
writeable: false,
},
CallableFunction: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'CallableFunction',
writeable: false,
},
NewableFunction: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NewableFunction',
writeable: false,
},
IArguments: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'IArguments',
writeable: false,
},
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'String',
writeable: false,
},
StringConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'StringConstructor',
writeable: false,
},
Boolean: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Boolean',
writeable: false,
},
BooleanConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BooleanConstructor',
writeable: false,
},
Number: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Number',
writeable: false,
},
NumberConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NumberConstructor',
writeable: false,
},
TemplateStringsArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TemplateStringsArray',
writeable: false,
},
ImportMeta: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ImportMeta',
writeable: false,
},
Math: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Math',
writeable: false,
},
Date: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Date',
writeable: false,
},
DateConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DateConstructor',
writeable: false,
},
RegExpMatchArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpMatchArray',
writeable: false,
},
RegExpExecArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpExecArray',
writeable: false,
},
RegExp: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'RegExp',
writeable: false,
},
RegExpConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RegExpConstructor',
writeable: false,
},
Error: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Error',
writeable: false,
},
ErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ErrorConstructor',
writeable: false,
},
EvalError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'EvalError',
writeable: false,
},
EvalErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'EvalErrorConstructor',
writeable: false,
},
RangeError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'RangeError',
writeable: false,
},
RangeErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'RangeErrorConstructor',
writeable: false,
},
ReferenceError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'ReferenceError',
writeable: false,
},
ReferenceErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReferenceErrorConstructor',
writeable: false,
},
SyntaxError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'SyntaxError',
writeable: false,
},
SyntaxErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SyntaxErrorConstructor',
writeable: false,
},
TypeError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'TypeError',
writeable: false,
},
TypeErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TypeErrorConstructor',
writeable: false,
},
URIError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'URIError',
writeable: false,
},
URIErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'URIErrorConstructor',
writeable: false,
},
JSON: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'JSON',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
ConcatArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ConcatArray',
writeable: false,
},
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Array',
writeable: false,
},
ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayConstructor',
writeable: false,
},
TypedPropertyDescriptor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TypedPropertyDescriptor',
writeable: false,
},
ClassDecorator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ClassDecorator',
writeable: false,
},
PropertyDecorator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PropertyDecorator',
writeable: false,
},
MethodDecorator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'MethodDecorator',
writeable: false,
},
ParameterDecorator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ParameterDecorator',
writeable: false,
},
PromiseConstructorLike: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructorLike',
writeable: false,
},
PromiseLike: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseLike',
writeable: false,
},
Promise: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Promise',
writeable: false,
},
ArrayLike: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayLike',
writeable: false,
},
Partial: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Partial',
writeable: false,
},
Required: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Required',
writeable: false,
},
Readonly: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Readonly',
writeable: false,
},
Pick: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Pick',
writeable: false,
},
Record: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Record',
writeable: false,
},
Exclude: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Exclude',
writeable: false,
},
Extract: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Extract',
writeable: false,
},
Omit: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Omit',
writeable: false,
},
NonNullable: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'NonNullable',
writeable: false,
},
Parameters: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Parameters',
writeable: false,
},
ConstructorParameters: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ConstructorParameters',
writeable: false,
},
ReturnType: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReturnType',
writeable: false,
},
InstanceType: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'InstanceType',
writeable: false,
},
ThisType: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ThisType',
writeable: false,
},
ArrayBuffer: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'ArrayBuffer',
writeable: false,
},
ArrayBufferTypes: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferTypes',
writeable: false,
},
ArrayBufferLike: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferLike',
writeable: false,
},
ArrayBufferConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferConstructor',
writeable: false,
},
ArrayBufferView: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ArrayBufferView',
writeable: false,
},
DataView: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'DataView',
writeable: false,
},
DataViewConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DataViewConstructor',
writeable: false,
},
Int8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Int8Array',
writeable: false,
},
Int8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int8ArrayConstructor',
writeable: false,
},
Uint8Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Uint8Array',
writeable: false,
},
Uint8ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ArrayConstructor',
writeable: false,
},
Uint8ClampedArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Uint8ClampedArray',
writeable: false,
},
Uint8ClampedArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint8ClampedArrayConstructor',
writeable: false,
},
Int16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Int16Array',
writeable: false,
},
Int16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int16ArrayConstructor',
writeable: false,
},
Uint16Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Uint16Array',
writeable: false,
},
Uint16ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint16ArrayConstructor',
writeable: false,
},
Int32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Int32Array',
writeable: false,
},
Int32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Int32ArrayConstructor',
writeable: false,
},
Uint32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Uint32Array',
writeable: false,
},
Uint32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Uint32ArrayConstructor',
writeable: false,
},
Float32Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Float32Array',
writeable: false,
},
Float32ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float32ArrayConstructor',
writeable: false,
},
Float64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Float64Array',
writeable: false,
},
Float64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Float64ArrayConstructor',
writeable: false,
},
Intl: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Intl',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,28 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es5 } from './es5';
import { es2015_core } from './es2015.core';
import { es2015_collection } from './es2015.collection';
import { es2015_iterable } from './es2015.iterable';
import { es2015_generator } from './es2015.generator';
import { es2015_promise } from './es2015.promise';
import { es2015_proxy } from './es2015.proxy';
import { es2015_reflect } from './es2015.reflect';
import { es2015_symbol } from './es2015.symbol';
import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
export const es6 = {
...es5,
...es2015_core,
...es2015_collection,
...es2015_iterable,
...es2015_generator,
...es2015_promise,
...es2015_proxy,
...es2015_reflect,
...es2015_symbol,
...es2015_symbol_wellknown,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,12 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015 } from './es2015';
import { es2016_array_include } from './es2016.array.include';
export const es7 = {
...es2015,
...es2016_array_include,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,29 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_array = {
FlatArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'FlatArray',
writeable: false,
},
ReadonlyArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ReadonlyArray',
writeable: false,
},
Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Array',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,40 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2015_symbol } from './es2015.symbol';
import { es2015_iterable } from './es2015.iterable';
export const esnext_asynciterable = {
...es2015_symbol,
...es2015_iterable,
SymbolConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'SymbolConstructor',
writeable: false,
},
AsyncIterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterator',
writeable: false,
},
AsyncIterable: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterable',
writeable: false,
},
AsyncIterableIterator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AsyncIterableIterator',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,57 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_bigint = {
BigInt: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigInt',
writeable: false,
},
BigIntConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigIntConstructor',
writeable: false,
},
BigInt64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigInt64Array',
writeable: false,
},
BigInt64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigInt64ArrayConstructor',
writeable: false,
},
BigUint64Array: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'BigUint64Array',
writeable: false,
},
BigUint64ArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'BigUint64ArrayConstructor',
writeable: false,
},
DataView: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DataView',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,18 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { esnext } from './esnext';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { dom_iterable } from './dom.iterable';
export const esnext_full = {
...esnext,
...dom,
...webworker_importscripts,
...scripthost,
...dom_iterable,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_intl = {
Intl: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Intl',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,29 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_promise = {
AggregateError: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'AggregateError',
writeable: false,
},
AggregateErrorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'AggregateErrorConstructor',
writeable: false,
},
PromiseConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'PromiseConstructor',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_string = {
String: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'String',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,15 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const esnext_symbol = {
Symbol: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Symbol',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,16 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es2020 } from './es2020';
import { esnext_intl } from './esnext.intl';
import { esnext_string } from './esnext.string';
import { esnext_promise } from './esnext.promise';
export const esnext = {
...es2020,
...esnext_intl,
...esnext_string,
...esnext_promise,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,123 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { es5 } from './es5';
import { es6 } from './es6';
import { es2015 } from './es2015';
import { es7 } from './es7';
import { es2016 } from './es2016';
import { es2017 } from './es2017';
import { es2018 } from './es2018';
import { es2019 } from './es2019';
import { es2020 } from './es2020';
import { esnext } from './esnext';
import { dom } from './dom';
import { dom_iterable } from './dom.iterable';
import { webworker } from './webworker';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
import { es2015_core } from './es2015.core';
import { es2015_collection } from './es2015.collection';
import { es2015_generator } from './es2015.generator';
import { es2015_iterable } from './es2015.iterable';
import { es2015_promise } from './es2015.promise';
import { es2015_proxy } from './es2015.proxy';
import { es2015_reflect } from './es2015.reflect';
import { es2015_symbol } from './es2015.symbol';
import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
import { es2016_array_include } from './es2016.array.include';
import { es2017_object } from './es2017.object';
import { es2017_sharedmemory } from './es2017.sharedmemory';
import { es2017_string } from './es2017.string';
import { es2017_intl } from './es2017.intl';
import { es2017_typedarrays } from './es2017.typedarrays';
import { es2018_asyncgenerator } from './es2018.asyncgenerator';
import { es2018_asynciterable } from './es2018.asynciterable';
import { es2018_intl } from './es2018.intl';
import { es2018_promise } from './es2018.promise';
import { es2018_regexp } from './es2018.regexp';
import { es2019_array } from './es2019.array';
import { es2019_object } from './es2019.object';
import { es2019_string } from './es2019.string';
import { es2019_symbol } from './es2019.symbol';
import { es2020_bigint } from './es2020.bigint';
import { es2020_promise } from './es2020.promise';
import { es2020_string } from './es2020.string';
import { es2020_symbol_wellknown } from './es2020.symbol.wellknown';
import { esnext_array } from './esnext.array';
import { esnext_symbol } from './esnext.symbol';
import { esnext_asynciterable } from './esnext.asynciterable';
import { esnext_intl } from './esnext.intl';
import { esnext_bigint } from './esnext.bigint';
import { esnext_string } from './esnext.string';
import { esnext_promise } from './esnext.promise';
import { es2016_full } from './es2016.full';
import { es2017_full } from './es2017.full';
import { es2018_full } from './es2018.full';
import { es2019_full } from './es2019.full';
import { es2020_full } from './es2020.full';
import { esnext_full } from './esnext.full';
import { lib as libBase } from './lib';
const lib = {
es5,
es6,
es2015,
es7,
es2016,
es2017,
es2018,
es2019,
es2020,
esnext,
dom,
'dom.iterable': dom_iterable,
webworker,
'webworker.importscripts': webworker_importscripts,
scripthost,
'es2015.core': es2015_core,
'es2015.collection': es2015_collection,
'es2015.generator': es2015_generator,
'es2015.iterable': es2015_iterable,
'es2015.promise': es2015_promise,
'es2015.proxy': es2015_proxy,
'es2015.reflect': es2015_reflect,
'es2015.symbol': es2015_symbol,
'es2015.symbol.wellknown': es2015_symbol_wellknown,
'es2016.array.include': es2016_array_include,
'es2017.object': es2017_object,
'es2017.sharedmemory': es2017_sharedmemory,
'es2017.string': es2017_string,
'es2017.intl': es2017_intl,
'es2017.typedarrays': es2017_typedarrays,
'es2018.asyncgenerator': es2018_asyncgenerator,
'es2018.asynciterable': es2018_asynciterable,
'es2018.intl': es2018_intl,
'es2018.promise': es2018_promise,
'es2018.regexp': es2018_regexp,
'es2019.array': es2019_array,
'es2019.object': es2019_object,
'es2019.string': es2019_string,
'es2019.symbol': es2019_symbol,
'es2020.bigint': es2020_bigint,
'es2020.promise': es2020_promise,
'es2020.string': es2020_string,
'es2020.symbol.wellknown': es2020_symbol_wellknown,
'esnext.array': esnext_array,
'esnext.symbol': esnext_symbol,
'esnext.asynciterable': esnext_asynciterable,
'esnext.intl': esnext_intl,
'esnext.bigint': esnext_bigint,
'esnext.string': esnext_string,
'esnext.promise': esnext_promise,
'es2016.full': es2016_full,
'es2017.full': es2017_full,
'es2018.full': es2018_full,
'es2019.full': es2019_full,
'es2020.full': es2020_full,
'esnext.full': esnext_full,
lib: libBase,
} as const;
export { lib };

View File

@ -0,0 +1,16 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
import { es5 } from './es5';
import { dom } from './dom';
import { webworker_importscripts } from './webworker.importscripts';
import { scripthost } from './scripthost';
export const lib = {
...es5,
...dom,
...webworker_importscripts,
...scripthost,
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,99 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const scripthost = {
ActiveXObject: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'ActiveXObject',
writeable: false,
},
ITextWriter: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'ITextWriter',
writeable: false,
},
TextStreamBase: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TextStreamBase',
writeable: false,
},
TextStreamWriter: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TextStreamWriter',
writeable: false,
},
TextStreamReader: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'TextStreamReader',
writeable: false,
},
SafeArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'SafeArray',
writeable: false,
},
Enumerator: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'Enumerator',
writeable: false,
},
EnumeratorConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'EnumeratorConstructor',
writeable: false,
},
VBArray: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'VBArray',
writeable: false,
},
VBArrayConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'VBArrayConstructor',
writeable: false,
},
VarDate: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: true,
name: 'VarDate',
writeable: false,
},
DateConstructor: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'DateConstructor',
writeable: false,
},
Date: {
eslintImplicitGlobalSetting: 'readonly',
isTypeVariable: true,
isValueVariable: false,
name: 'Date',
writeable: false,
},
} as Record<string, ImplicitLibVariableOptions>;

View File

@ -0,0 +1,10 @@
// THIS CODE WAS AUTOMATICALLY GENERATED
// DO NOT EDIT THIS CODE BY HAND
// YOU CAN REGENERATE IT USING yarn generate:lib
import { ImplicitLibVariableOptions } from '../variable';
export const webworker_importscripts = {} as Record<
string,
ImplicitLibVariableOptions
>;

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,72 @@
import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
import { Referencer } from './Referencer';
import { Visitor } from './Visitor';
type ExportNode =
| TSESTree.ExportAllDeclaration
| TSESTree.ExportDefaultDeclaration
| TSESTree.ExportNamedDeclaration;
class ExportVisitor extends Visitor {
readonly #referencer: Referencer;
readonly #exportNode: ExportNode;
constructor(node: ExportNode, referencer: Referencer) {
super(referencer);
this.#exportNode = node;
this.#referencer = referencer;
}
static visit(referencer: Referencer, node: ExportNode): void {
const exportReferencer = new ExportVisitor(node, referencer);
exportReferencer.visit(node);
}
protected Identifier(node: TSESTree.Identifier): void {
if (this.#exportNode.exportKind === 'type') {
// type exports can only reference types
this.#referencer.currentScope().referenceType(node);
} else {
this.#referencer.currentScope().referenceDualValueType(node);
}
}
protected ExportDefaultDeclaration(
node: TSESTree.ExportDefaultDeclaration,
): void {
if (node.declaration.type === AST_NODE_TYPES.Identifier) {
// export default A;
// this could be a type or a variable
this.visit(node.declaration);
} else {
// export const a = 1;
// export something();
// etc
// these not included in the scope of this visitor as they are all guaranteed to be values or declare variables
}
}
protected ExportNamedDeclaration(
node: TSESTree.ExportNamedDeclaration,
): void {
if (node.source) {
// export ... from 'foo';
// these are external identifiers so there shouldn't be references or defs
return;
}
if (!node.declaration) {
// export { x };
this.visitChildren(node);
} else {
// export const x = 1;
// this is not included in the scope of this visitor as it creates a variable
}
}
protected ExportSpecifier(node: TSESTree.ExportSpecifier): void {
this.visit(node.local);
}
}
export { ExportVisitor };

Some files were not shown because too many files have changed in this diff Show More