Graham/angular-cli
1
0
Fork 0
mirror of https://github.com/angular/angular-cli.git synced 2025-05-17 02:54:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(@angular/cli): support TypeScript 4.2

Browse Source 
BREAKING CHANGE

Drop support for TypeScript versions prior to 4.2.3
This commit is contained in:
Alan Agius 2021-03-17 18:50:03 +01:00
parent b1fa5bd1bf
commit 79856644b4
13 changed files with 5488 additions and 2945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
package.json
View File

@ -223,7 +223,7 @@
"tslint": "^6.1.3",
"tslint-no-circular-imports": "^0.7.0",
"tslint-sonarts": "1.9.0",
"typescript": "4.1.5",
"typescript": "4.2.3",
"verdaccio": "4.12.0",
"verdaccio-auth-memory": "^9.7.2",
"webpack": "4.44.2",

2
packages/angular_devkit/build_angular/package.json
View File

@ -87,7 +87,7 @@
"protractor": "^7.0.0",
"tailwindcss": "^2.0.0",
"tslint": "^6.1.0",
"typescript": "~4.0.0 || ~4.1.0"
"typescript": "~4.2.3"
},
"peerDependenciesMeta": {
"@angular/localize": {

2
packages/angular_devkit/build_optimizer/package.json
View File

@ -12,7 +12,7 @@
"loader-utils": "2.0.0",
"source-map": "0.7.3",
"tslib": "2.1.0",
"typescript": "4.1.5",
"typescript": "4.2.3",
"webpack-sources": "2.2.0"
},
"peerDependencies": {

28
packages/angular_devkit/core/src/workspace/json/utilities.ts
View File

@ -37,9 +37,13 @@ type ChangeReporter = (
current?: JsonValue,
) => void;
// lib.es5 PropertyKey is string | number | symbol which doesn't overlap ProxyHandler PropertyKey which is string | symbol.
// See https://github.com/microsoft/TypeScript/issues/42894
type ProxyPropertyKey = string | symbol;
function findNode(
parent: JsonAstArray | JsonAstObject,
p: PropertyKey,
p: ProxyPropertyKey,
): { node?: JsonAstNode; parent: JsonAstArray | JsonAstKeyValue | JsonAstObject } {
if (parent.kind === 'object') {
const entry = parent.properties.find(entry => entry.key.value === p);
@ -120,8 +124,8 @@ function create(
ast: JsonAstObject | JsonAstArray,
path: string,
reporter: ChangeReporter,
excluded = new Set<PropertyKey>(),
included?: Set<PropertyKey>,
excluded = new Set<ProxyPropertyKey>(),
included?: Set<ProxyPropertyKey>,
base?: object,
) {
const cache = new Map<string, CacheEntry>();
@ -137,7 +141,7 @@ function create(
}
return new Proxy(base, {
getOwnPropertyDescriptor(target: {}, p: PropertyKey): PropertyDescriptor | undefined {
getOwnPropertyDescriptor(target: {}, p: ProxyPropertyKey): PropertyDescriptor | undefined {
const descriptor = Reflect.getOwnPropertyDescriptor(target, p);
if (descriptor || typeof p === 'symbol') {
return descriptor;
@ -162,7 +166,7 @@ function create(
return undefined;
},
has(target: {}, p: PropertyKey): boolean {
has(target: {}, p: ProxyPropertyKey): boolean {
if (Reflect.has(target, p)) {
return true;
} else if (typeof p === 'symbol' || excluded.has(p)) {
@ -171,7 +175,7 @@ function create(
return cache.has(path + '/' + escapeKey(p)) || findNode(ast, p) !== undefined;
},
get(target: {}, p: PropertyKey): unknown {
get(target: {}, p: ProxyPropertyKey): unknown {
if (typeof p === 'symbol' || Reflect.has(target, p)) {
return Reflect.get(target, p);
} else if (excluded.has(p) || (included && !included.has(p))) {
@ -206,7 +210,7 @@ function create(
return value;
},
set(target: {}, p: PropertyKey, value: unknown): boolean {
set(target: {}, p: ProxyPropertyKey, value: unknown): boolean {
if (value === undefined) {
// setting to undefined is equivalent to a delete
// tslint:disable-next-line: no-non-null-assertion
@ -242,7 +246,7 @@ function create(
return true;
},
deleteProperty(target: {}, p: PropertyKey): boolean {
deleteProperty(target: {}, p: ProxyPropertyKey): boolean {
if (typeof p === 'symbol' || Reflect.has(target, p)) {
return Reflect.deleteProperty(target, p);
} else if (excluded.has(p) || (included && !included.has(p))) {
@ -279,15 +283,15 @@ function create(
return true;
},
defineProperty(target: {}, p: PropertyKey, attributes: PropertyDescriptor): boolean {
defineProperty(target: {}, p: ProxyPropertyKey, attributes: PropertyDescriptor): boolean {
if (typeof p === 'symbol') {
return Reflect.defineProperty(target, p, attributes);
}
return false;
},
ownKeys(target: {}): PropertyKey[] {
let keys: PropertyKey[];
ownKeys(target: {}): ProxyPropertyKey[] {
let keys: ProxyPropertyKey[];
if (ast.kind === 'object') {
keys = ast.properties
.map(entry => entry.key.value)
@ -299,7 +303,7 @@ function create(
for (const key of cache.keys()) {
const relativeKey = key.substr(path.length + 1);
if (relativeKey.length > 0 && !relativeKey.includes('/')) {
keys.push(unescapeKey(relativeKey));
keys.push(`${unescapeKey(relativeKey)}`);
}
}

4
packages/ngtools/webpack/package.json
View File

@ -27,13 +27,13 @@
},
"peerDependencies": {
"@angular/compiler-cli": "^12.0.0-next",
"typescript": "~4.0.0 || ~4.1.0",
"typescript": "~4.2.3",
"webpack": "^4.0.0 || ^5.20.0"
},
"devDependencies": {
"@angular/compiler": "12.0.0-next.4",
"@angular/compiler-cli": "12.0.0-next.4",
"typescript": "4.1.5",
"typescript": "4.2.3",
"webpack": "5.21.2"
}
}

4
packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/BUILD.bazel vendored
View File

@ -1,7 +1,7 @@
load("//tools:defaults.bzl", "ts_library")
# files fetched on 2020-08-24 from
# https://github.com/microsoft/TypeScript/releases/tag/v4.0.2
# files fetched on 2021-03-17 from
# https://github.com/microsoft/TypeScript/releases/tag/v4.2.3
licenses(["notice"]) # Apache 2.0
ts_library(

224
packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.d.ts vendored
View File

@ -14,7 +14,7 @@ and limitations under the License.
***************************************************************************** */
declare namespace ts {
const versionMajorMinor = "4.1";
const versionMajorMinor = "4.2";
/** The version of the TypeScript compiler release */
const version: string;
/**
@ -81,7 +81,7 @@ declare namespace ts {
value: T;
done?: false;
} | {
value: never;
value: void;
done: true;
};
}
@ -1598,6 +1598,7 @@ declare namespace ts {
readonly kind: SyntaxKind.ImportEqualsDeclaration;
readonly parent: SourceFile | ModuleBlock;
readonly name: Identifier;
readonly isTypeOnly: boolean;
readonly moduleReference: ModuleReference;
}
export interface ExternalModuleReference extends Node {
@ -1668,7 +1669,7 @@ declare namespace ts {
readonly name: Identifier;
}
export type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
export type TypeOnlyCompatibleAliasDeclaration = ImportClause | NamespaceImport | ImportOrExportSpecifier;
export type TypeOnlyCompatibleAliasDeclaration = ImportClause | ImportEqualsDeclaration | NamespaceImport | ImportOrExportSpecifier;
/**
* This is either an `export =` or an `export default` declaration.
* Unless `isExportEquals` is set, this node was parsed as an `export default`.
@ -2590,7 +2591,10 @@ declare namespace ts {
Optional = 2,
Rest = 4,
Variadic = 8,
Variable = 12
Fixed = 3,
Variable = 12,
NonRequired = 14,
NonRest = 11
}
export interface TupleType extends GenericType {
elementFlags: readonly ElementFlags[];
@ -2831,6 +2835,7 @@ declare namespace ts {
noUnusedLocals?: boolean;
noUnusedParameters?: boolean;
noImplicitUseStrict?: boolean;
noPropertyAccessFromIndexSignature?: boolean;
assumeChangesOnlyAffectDirectDependencies?: boolean;
noLib?: boolean;
noResolve?: boolean;
@ -2879,6 +2884,8 @@ declare namespace ts {
watchDirectory?: WatchDirectoryKind;
fallbackPolling?: PollingWatchKind;
synchronousWatchDirectory?: boolean;
excludeDirectories?: string[];
excludeFiles?: string[];
[option: string]: CompilerOptionsValue | undefined;
}
export interface TypeAcquisition {
@ -2972,10 +2979,6 @@ declare namespace ts {
None = 0,
Recursive = 1
}
export interface ExpandResult {
fileNames: string[];
wildcardDirectories: MapLike<WatchDirectoryFlags>;
}
export interface CreateProgramOptions {
rootNames: readonly string[];
options: CompilerOptions;
@ -3228,7 +3231,11 @@ declare namespace ts {
updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode;
updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): FunctionTypeNode;
createConstructorTypeNode(modifiers: readonly Modifier[] | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
/** @deprecated */
createConstructorTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): ConstructorTypeNode;
updateConstructorTypeNode(node: ConstructorTypeNode, modifiers: readonly Modifier[] | undefined, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
/** @deprecated */
updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode): ConstructorTypeNode;
createTypeQueryNode(exprName: EntityName): TypeQueryNode;
updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName): TypeQueryNode;
@ -3406,8 +3413,8 @@ declare namespace ts {
updateCaseBlock(node: CaseBlock, clauses: readonly CaseOrDefaultClause[]): CaseBlock;
createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration;
updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration;
createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
createImportEqualsDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration;
createImportDeclaration(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration;
updateImportDeclaration(node: ImportDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression): ImportDeclaration;
createImportClause(isTypeOnly: boolean, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause;
@ -3681,8 +3688,8 @@ declare namespace ts {
*/
export type Visitor = (node: Node) => VisitResult<Node>;
export interface NodeVisitor {
<T extends Node>(nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T;
<T extends Node>(nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T | undefined;
<T extends Node>(nodes: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
<T extends Node>(nodes: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
}
export interface NodesVisitor {
<T extends Node>(nodes: NodeArray<T>, visitor: Visitor | undefined, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
@ -3862,7 +3869,7 @@ declare namespace ts {
readonly includeCompletionsForModuleExports?: boolean;
readonly includeAutomaticOptionalChainCompletions?: boolean;
readonly includeCompletionsWithInsertText?: boolean;
readonly importModuleSpecifierPreference?: "auto" | "relative" | "non-relative";
readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative";
/** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */
readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js";
readonly allowTextChangesInNewFiles?: boolean;
@ -3961,6 +3968,7 @@ declare namespace ts {
reScanJsxToken(): JsxTokenSyntaxKind;
reScanLessThanToken(): SyntaxKind;
reScanQuestionToken(): SyntaxKind;
reScanInvalidIdentifier(): SyntaxKind;
scanJsxToken(): JsxTokenSyntaxKind;
scanJsDocToken(): JSDocSyntaxKind;
scan(): SyntaxKind;
@ -4504,6 +4512,7 @@ declare namespace ts {
function isJSDocProtectedTag(node: Node): node is JSDocProtectedTag;
function isJSDocReadonlyTag(node: Node): node is JSDocReadonlyTag;
function isJSDocDeprecatedTag(node: Node): node is JSDocDeprecatedTag;
function isJSDocSeeTag(node: Node): node is JSDocSeeTag;
function isJSDocEnumTag(node: Node): node is JSDocEnumTag;
function isJSDocParameterTag(node: Node): node is JSDocParameterTag;
function isJSDocReturnTag(node: Node): node is JSDocReturnTag;
@ -4683,7 +4692,7 @@ declare namespace ts {
* @param test A callback to execute to verify the Node is valid.
* @param lift An optional callback to execute to lift a NodeArray into a valid Node.
*/
function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T;
function visitNode<T extends Node>(node: T, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
/**
* Visits a Node using the supplied visitor, possibly returning a new Node in its place.
*
@ -4692,7 +4701,7 @@ declare namespace ts {
* @param test A callback to execute to verify the Node is valid.
* @param lift An optional callback to execute to lift a NodeArray into a valid Node.
*/
function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T): T | undefined;
function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
/**
* Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
*
@ -5530,6 +5539,7 @@ declare namespace ts {
getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[] | undefined;
findReferences(fileName: string, position: number): ReferencedSymbol[] | undefined;
getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[] | undefined;
getFileReferences(fileName: string): ReferenceEntry[];
/** @deprecated */
getOccurrencesAtPosition(fileName: string, position: number): readonly ReferenceEntry[] | undefined;
getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
@ -5545,7 +5555,7 @@ declare namespace ts {
getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion | undefined;
getDocCommentTemplateAtPosition(fileName: string, position: number, options?: DocCommentTemplateOptions): TextInsertion | undefined;
isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
/**
* This will return a defined result if the position is after the `>` of the opening tag, or somewhere in the text, of a JSXElement with no closing tag.
@ -5565,7 +5575,7 @@ declare namespace ts {
applyCodeActionCommand(fileName: string, action: CodeActionCommand[]): Promise<ApplyCodeActionCommandResult[]>;
/** @deprecated `fileName` will be ignored */
applyCodeActionCommand(fileName: string, action: CodeActionCommand | CodeActionCommand[]): Promise<ApplyCodeActionCommandResult | ApplyCodeActionCommandResult[]>;
getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason): ApplicableRefactorInfo[];
getApplicableRefactors(fileName: string, positionOrRange: number | TextRange, preferences: UserPreferences | undefined, triggerReason?: RefactorTriggerReason, kind?: string): ApplicableRefactorInfo[];
getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string, preferences: UserPreferences | undefined): RefactorEditInfo | undefined;
organizeImports(scope: OrganizeImportsScope, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences | undefined): readonly FileTextChanges[];
@ -5791,6 +5801,10 @@ declare namespace ts {
* the current context.
*/
notApplicableReason?: string;
/**
* The hierarchical dotted name of the refactor action.
*/
kind?: string;
}
/**
* A set of edits to make in response to a refactor action, plus an optional
@ -6006,11 +6020,15 @@ declare namespace ts {
interface RenameInfoOptions {
readonly allowRenameOfImportPath?: boolean;
}
interface DocCommentTemplateOptions {
readonly generateReturnInDocTemplate?: boolean;
}
interface SignatureHelpParameter {
name: string;
documentation: SymbolDisplayPart[];
displayParts: SymbolDisplayPart[];
isOptional: boolean;
isRest?: boolean;
}
interface SelectionRange {
textSpan: TextSpan;
@ -6447,7 +6465,7 @@ declare namespace ts {
(text: string, isSingleQuote?: boolean | undefined, hasExtendedUnicodeEscape?: boolean | undefined): StringLiteral;
};
/** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */
const createStringLiteralFromNode: (sourceNode: Identifier | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral, isSingleQuote?: boolean | undefined) => StringLiteral;
const createStringLiteralFromNode: (sourceNode: PropertyNameLiteral, isSingleQuote?: boolean | undefined) => StringLiteral;
/** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */
const createRegularExpressionLiteral: (text: string) => RegularExpressionLiteral;
/** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */
@ -6483,19 +6501,19 @@ declare namespace ts {
/** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateTypeParameterDeclaration: (node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) => TypeParameterDeclaration;
/** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */
const createParameter: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined) => ParameterDeclaration;
const createParameter: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken | undefined, type?: TypeNode | undefined, initializer?: Expression | undefined) => ParameterDeclaration;
/** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */
const updateParameter: (node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => ParameterDeclaration;
const updateParameter: (node: ParameterDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => ParameterDeclaration;
/** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */
const createDecorator: (expression: Expression) => Decorator;
/** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */
const updateDecorator: (node: Decorator, expression: Expression) => Decorator;
/** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */
const createProperty: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration;
const createProperty: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration;
/** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */
const updateProperty: (node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration;
const updateProperty: (node: PropertyDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionOrExclamationToken: QuestionToken | ExclamationToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined) => PropertyDeclaration;
/** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */
const createMethod: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => MethodDeclaration;
const createMethod: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => MethodDeclaration;
/** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */
const updateMethod: (node: MethodDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => MethodDeclaration;
/** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */
@ -6503,11 +6521,11 @@ declare namespace ts {
/** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */
const updateConstructor: (node: ConstructorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], body: Block | undefined) => ConstructorDeclaration;
/** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createGetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration;
const createGetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration;
/** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateGetAccessor: (node: GetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined) => GetAccessorDeclaration;
/** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const createSetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration;
const createSetAccessor: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration;
/** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */
const updateSetAccessor: (node: SetAccessorDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: PropertyName, parameters: readonly ParameterDeclaration[], body: Block | undefined) => SetAccessorDeclaration;
/** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */
@ -6527,7 +6545,7 @@ declare namespace ts {
/** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */
const updateTypePredicateNodeWithModifier: (node: TypePredicateNode, assertsModifier: AssertsKeyword | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) => TypePredicateNode;
/** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */
const createTypeReferenceNode: (typeName: string | Identifier | QualifiedName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode;
const createTypeReferenceNode: (typeName: string | EntityName, typeArguments?: readonly TypeNode[] | undefined) => TypeReferenceNode;
/** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */
const updateTypeReferenceNode: (node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined) => TypeReferenceNode;
/** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */
@ -6579,9 +6597,9 @@ declare namespace ts {
/** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */
const updateInferTypeNode: (node: InferTypeNode, typeParameter: TypeParameterDeclaration) => InferTypeNode;
/** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */
const createImportTypeNode: (argument: TypeNode, qualifier?: Identifier | QualifiedName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode;
const createImportTypeNode: (argument: TypeNode, qualifier?: EntityName | undefined, typeArguments?: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode;
/** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */
const updateImportTypeNode: (node: ImportTypeNode, argument: TypeNode, qualifier: Identifier | QualifiedName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode;
const updateImportTypeNode: (node: ImportTypeNode, argument: TypeNode, qualifier: EntityName | undefined, typeArguments: readonly TypeNode[] | undefined, isTypeOf?: boolean | undefined) => ImportTypeNode;
/** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */
const createParenthesizedType: (type: TypeNode) => ParenthesizedTypeNode;
/** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */
@ -6599,9 +6617,9 @@ declare namespace ts {
/** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */
const updateMappedTypeNode: (node: MappedTypeNode, readonlyToken: ReadonlyKeyword | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: QuestionToken | PlusToken | MinusToken | undefined, type: TypeNode | undefined) => MappedTypeNode;
/** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */
const createLiteralTypeNode: (literal: LiteralExpression | TrueLiteral | FalseLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
const createLiteralTypeNode: (literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
/** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */
const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | TrueLiteral | FalseLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
const updateLiteralTypeNode: (node: LiteralTypeNode, literal: LiteralExpression | BooleanLiteral | PrefixUnaryExpression | NullLiteral) => LiteralTypeNode;
/** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */
const createObjectBindingPattern: (elements: readonly BindingElement[]) => ObjectBindingPattern;
/** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */
@ -6611,84 +6629,84 @@ declare namespace ts {
/** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */
const updateArrayBindingPattern: (node: ArrayBindingPattern, elements: readonly ArrayBindingElement[]) => ArrayBindingPattern;
/** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */
const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | undefined, name: string | Identifier | ObjectBindingPattern | ArrayBindingPattern, initializer?: Expression | undefined) => BindingElement;
const createBindingElement: (dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression | undefined) => BindingElement;
/** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */
const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement;
/** @deprecated Use `factory.createArrayLiteral` or the factory supplied by your transformation context instead. */
const updateBindingElement: (node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined) => BindingElement;
/** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const createArrayLiteral: (elements?: readonly Expression[] | undefined, multiLine?: boolean | undefined) => ArrayLiteralExpression;
/** @deprecated Use `factory.updateArrayLiteral` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */
const updateArrayLiteral: (node: ArrayLiteralExpression, elements: readonly Expression[]) => ArrayLiteralExpression;
/** @deprecated Use `factory.createObjectLiteral` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const createObjectLiteral: (properties?: readonly ObjectLiteralElementLike[] | undefined, multiLine?: boolean | undefined) => ObjectLiteralExpression;
/** @deprecated Use `factory.updateObjectLiteral` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */
const updateObjectLiteral: (node: ObjectLiteralExpression, properties: readonly ObjectLiteralElementLike[]) => ObjectLiteralExpression;
/** @deprecated Use `factory.createPropertyAccess` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */
const createPropertyAccess: (expression: Expression, name: string | Identifier | PrivateIdentifier) => PropertyAccessExpression;
/** @deprecated Use `factory.updatePropertyAccess` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */
const updatePropertyAccess: (node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateIdentifier) => PropertyAccessExpression;
/** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */
const createPropertyAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, name: string | Identifier | PrivateIdentifier) => PropertyAccessChain;
/** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */
const updatePropertyAccessChain: (node: PropertyAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, name: Identifier | PrivateIdentifier) => PropertyAccessChain;
/** @deprecated Use `factory.createElementAccess` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */
const createElementAccess: (expression: Expression, index: number | Expression) => ElementAccessExpression;
/** @deprecated Use `factory.updateElementAccess` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */
const updateElementAccess: (node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) => ElementAccessExpression;
/** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */
const createElementAccessChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, index: number | Expression) => ElementAccessChain;
/** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */
const updateElementAccessChain: (node: ElementAccessChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, argumentExpression: Expression) => ElementAccessChain;
/** @deprecated Use `factory.createCall` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */
const createCall: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallExpression;
/** @deprecated Use `factory.updateCall` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */
const updateCall: (node: CallExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallExpression;
/** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */
const createCallChain: (expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => CallChain;
/** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */
const updateCallChain: (node: CallChain, expression: Expression, questionDotToken: QuestionDotToken | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[]) => CallChain;
/** @deprecated Use `factory.createNew` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */
const createNew: (expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
/** @deprecated Use `factory.updateNew` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */
const updateNew: (node: NewExpression, expression: Expression, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly Expression[] | undefined) => NewExpression;
/** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */
const createTypeAssertion: (type: TypeNode, expression: Expression) => TypeAssertion;
/** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */
const updateTypeAssertion: (node: TypeAssertion, type: TypeNode, expression: Expression) => TypeAssertion;
/** @deprecated Use `factory.createParen` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */
const createParen: (expression: Expression) => ParenthesizedExpression;
/** @deprecated Use `factory.updateParen` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */
const updateParen: (node: ParenthesizedExpression, expression: Expression) => ParenthesizedExpression;
/** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */
const createFunctionExpression: (modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block) => FunctionExpression;
/** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */
const updateFunctionExpression: (node: FunctionExpression, modifiers: readonly Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block) => FunctionExpression;
/** @deprecated Use `factory.createDelete` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */
const createDelete: (expression: Expression) => DeleteExpression;
/** @deprecated Use `factory.updateDelete` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */
const updateDelete: (node: DeleteExpression, expression: Expression) => DeleteExpression;
/** @deprecated Use `factory.createTypeOf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */
const createTypeOf: (expression: Expression) => TypeOfExpression;
/** @deprecated Use `factory.updateTypeOf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */
const updateTypeOf: (node: TypeOfExpression, expression: Expression) => TypeOfExpression;
/** @deprecated Use `factory.createVoid` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */
const createVoid: (expression: Expression) => VoidExpression;
/** @deprecated Use `factory.updateVoid` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */
const updateVoid: (node: VoidExpression, expression: Expression) => VoidExpression;
/** @deprecated Use `factory.createAwait` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */
const createAwait: (expression: Expression) => AwaitExpression;
/** @deprecated Use `factory.updateAwait` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */
const updateAwait: (node: AwaitExpression, expression: Expression) => AwaitExpression;
/** @deprecated Use `factory.createPrefix` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */
const createPrefix: (operator: PrefixUnaryOperator, operand: Expression) => PrefixUnaryExpression;
/** @deprecated Use `factory.updatePrefix` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */
const updatePrefix: (node: PrefixUnaryExpression, operand: Expression) => PrefixUnaryExpression;
/** @deprecated Use `factory.createPostfix` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const createPostfix: (operand: Expression, operator: PostfixUnaryOperator) => PostfixUnaryExpression;
/** @deprecated Use `factory.updatePostfix` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */
const updatePostfix: (node: PostfixUnaryExpression, operand: Expression) => PostfixUnaryExpression;
/** @deprecated Use `factory.createBinary` or the factory supplied by your transformation context instead. */
const createBinary: (left: Expression, operator: SyntaxKind.CommaToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | BinaryOperatorToken, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.updateConditional` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */
const createBinary: (left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression) => BinaryExpression;
/** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */
const updateConditional: (node: ConditionalExpression, condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression) => ConditionalExpression;
/** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */
const createTemplateExpression: (head: TemplateHead, templateSpans: readonly TemplateSpan[]) => TemplateExpression;
@ -6714,11 +6732,11 @@ declare namespace ts {
(text: string, rawText?: string | undefined): NoSubstitutionTemplateLiteral;
(text: string | undefined, rawText: string): NoSubstitutionTemplateLiteral;
};
/** @deprecated Use `factory.updateYield` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */
const updateYield: (node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression | undefined) => YieldExpression;
/** @deprecated Use `factory.createSpread` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */
const createSpread: (expression: Expression) => SpreadElement;
/** @deprecated Use `factory.updateSpread` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */
const updateSpread: (node: SpreadElement, expression: Expression) => SpreadElement;
/** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */
const createOmittedExpression: () => OmittedExpression;
@ -6762,61 +6780,61 @@ declare namespace ts {
const createStatement: (expression: Expression) => ExpressionStatement;
/** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */
const updateStatement: (node: ExpressionStatement, expression: Expression) => ExpressionStatement;
/** @deprecated Use `factory.createIf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */
const createIf: (expression: Expression, thenStatement: Statement, elseStatement?: Statement | undefined) => IfStatement;
/** @deprecated Use `factory.updateIf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */
const updateIf: (node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined) => IfStatement;
/** @deprecated Use `factory.createDo` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */
const createDo: (statement: Statement, expression: Expression) => DoStatement;
/** @deprecated Use `factory.updateDo` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */
const updateDo: (node: DoStatement, statement: Statement, expression: Expression) => DoStatement;
/** @deprecated Use `factory.createWhile` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */
const createWhile: (expression: Expression, statement: Statement) => WhileStatement;
/** @deprecated Use `factory.updateWhile` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */
const updateWhile: (node: WhileStatement, expression: Expression, statement: Statement) => WhileStatement;
/** @deprecated Use `factory.createFor` or the factory supplied by your transformation context instead. */
const createFor: (initializer: Expression | VariableDeclarationList | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
/** @deprecated Use `factory.updateFor` or the factory supplied by your transformation context instead. */
const updateFor: (node: ForStatement, initializer: Expression | VariableDeclarationList | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
/** @deprecated Use `factory.createForIn` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */
const createFor: (initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
/** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */
const updateFor: (node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement) => ForStatement;
/** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */
const createForIn: (initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
/** @deprecated Use `factory.updateForIn` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */
const updateForIn: (node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement) => ForInStatement;
/** @deprecated Use `factory.createForOf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */
const createForOf: (awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
/** @deprecated Use `factory.updateForOf` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */
const updateForOf: (node: ForOfStatement, awaitModifier: AwaitKeyword | undefined, initializer: ForInitializer, expression: Expression, statement: Statement) => ForOfStatement;
/** @deprecated Use `factory.createContinue` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */
const createContinue: (label?: string | Identifier | undefined) => ContinueStatement;
/** @deprecated Use `factory.updateContinue` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */
const updateContinue: (node: ContinueStatement, label: Identifier | undefined) => ContinueStatement;
/** @deprecated Use `factory.createBreak` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */
const createBreak: (label?: string | Identifier | undefined) => BreakStatement;
/** @deprecated Use `factory.updateBreak` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */
const updateBreak: (node: BreakStatement, label: Identifier | undefined) => BreakStatement;
/** @deprecated Use `factory.createReturn` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */
const createReturn: (expression?: Expression | undefined) => ReturnStatement;
/** @deprecated Use `factory.updateReturn` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */
const updateReturn: (node: ReturnStatement, expression: Expression | undefined) => ReturnStatement;
/** @deprecated Use `factory.createWith` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */
const createWith: (expression: Expression, statement: Statement) => WithStatement;
/** @deprecated Use `factory.updateWith` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */
const updateWith: (node: WithStatement, expression: Expression, statement: Statement) => WithStatement;
/** @deprecated Use `factory.createSwitch` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */
const createSwitch: (expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
/** @deprecated Use `factory.updateSwitch` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */
const updateSwitch: (node: SwitchStatement, expression: Expression, caseBlock: CaseBlock) => SwitchStatement;
/** @deprecated Use `factory.createLabel` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */
const createLabel: (label: string | Identifier, statement: Statement) => LabeledStatement;
/** @deprecated Use `factory.updateLabel` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */
const updateLabel: (node: LabeledStatement, label: Identifier, statement: Statement) => LabeledStatement;
/** @deprecated Use `factory.createThrow` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */
const createThrow: (expression: Expression) => ThrowStatement;
/** @deprecated Use `factory.updateThrow` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */
const updateThrow: (node: ThrowStatement, expression: Expression) => ThrowStatement;
/** @deprecated Use `factory.createTry` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */
const createTry: (tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
/** @deprecated Use `factory.updateTry` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */
const updateTry: (node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined) => TryStatement;
/** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */
const createDebuggerStatement: () => DebuggerStatement;
@ -6845,9 +6863,9 @@ declare namespace ts {
/** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */
const updateEnumDeclaration: (node: EnumDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, members: readonly EnumMember[]) => EnumDeclaration;
/** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */
const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration;
const createModuleDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags | undefined) => ModuleDeclaration;
/** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */
const updateModuleDeclaration: (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: Identifier | ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | undefined) => ModuleDeclaration;
const updateModuleDeclaration: (node: ModuleDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined) => ModuleDeclaration;
/** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */
const createModuleBlock: (statements: readonly Statement[]) => ModuleBlock;
/** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */
@ -6861,9 +6879,9 @@ declare namespace ts {
/** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */
const updateNamespaceExportDeclaration: (node: NamespaceExportDeclaration, name: Identifier) => NamespaceExportDeclaration;
/** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const createImportEqualsDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration;
const createImportEqualsDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: string | Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration;
/** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */
const updateImportEqualsDeclaration: (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration;
const updateImportEqualsDeclaration: (node: ImportEqualsDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference) => ImportEqualsDeclaration;
/** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */
const createImportDeclaration: (decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression) => ImportDeclaration;
/** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */
@ -7005,7 +7023,7 @@ declare namespace ts {
/** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */
const updateCatchClause: (node: CatchClause, variableDeclaration: VariableDeclaration | undefined, block: Block) => CatchClause;
/** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */
const createPropertyAssignment: (name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, initializer: Expression) => PropertyAssignment;
const createPropertyAssignment: (name: string | PropertyName, initializer: Expression) => PropertyAssignment;
/** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */
const updatePropertyAssignment: (node: PropertyAssignment, name: PropertyName, initializer: Expression) => PropertyAssignment;
/** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */
@ -7017,7 +7035,7 @@ declare namespace ts {
/** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */
const updateSpreadAssignment: (node: SpreadAssignment, expression: Expression) => SpreadAssignment;
/** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */
const createEnumMember: (name: string | Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier, initializer?: Expression | undefined) => EnumMember;
const createEnumMember: (name: string | PropertyName, initializer?: Expression | undefined) => EnumMember;
/** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */
const updateEnumMember: (node: EnumMember, name: PropertyName, initializer: Expression | undefined) => EnumMember;
/** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */
@ -7028,9 +7046,9 @@ declare namespace ts {
const createPartiallyEmittedExpression: (expression: Expression, original?: Node | undefined) => PartiallyEmittedExpression;
/** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */
const updatePartiallyEmittedExpression: (node: PartiallyEmittedExpression, expression: Expression) => PartiallyEmittedExpression;
/** @deprecated Use `factory.createCommaList` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */
const createCommaList: (elements: readonly Expression[]) => CommaListExpression;
/** @deprecated Use `factory.updateCommaList` or the factory supplied by your transformation context instead. */
/** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */
const updateCommaList: (node: CommaListExpression, elements: readonly Expression[]) => CommaListExpression;
/** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */
const createBundle: (sourceFiles: readonly SourceFile[], prepends?: readonly (UnparsedSource | InputFiles)[] | undefined) => Bundle;
@ -7184,7 +7202,7 @@ declare namespace ts {
* NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be
* captured with respect to transformations.
*
* @deprecated Use `factory.cloneNode` instead and use `setCommentRange` or `setSourceMapRange` and avoid setting `parent`.
* @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`.
*/
const getMutableClone: <T extends Node>(node: T) => T;
/** @deprecated Use `isTypeAssertionExpression` instead. */

7714
packages/schematics/angular/third_party/github.com/Microsoft/TypeScript/lib/typescript.js vendored
View File

File diff suppressed because it is too large Load Diff

4
packages/schematics/angular/utility/latest-versions.ts
View File

@ -11,8 +11,8 @@ export const latestVersions = {
Angular: '~12.0.0-next.4',
RxJs: '~6.6.0',
ZoneJs: '~0.11.4',
TypeScript: '~4.1.2',
TsLib: '^2.0.0',
TypeScript: '~4.2.3',
TsLib: '^2.1.0',
// The versions below must be manually updated when making a new devkit release.
// For our e2e tests, these versions must match the latest tag present on the branch.

2
packages/schematics/schematics/schematic/files/package.json
View File

@ -15,7 +15,7 @@
"dependencies": {
"@angular-devkit/core": "^<%= coreVersion %>",
"@angular-devkit/schematics": "^<%= schematicsVersion %>",
"typescript": "~4.1.2"
"typescript": "~4.2.3"
},
"devDependencies": {
"@types/node": "^12.11.1",

9
tests/legacy-cli/e2e/setup/500-create-project.ts
View File

@ -28,6 +28,15 @@ export default async function() {
await expectFileToExist(join(process.cwd(), 'test-project'));
process.chdir('./test-project');
// Disable the TS version check to make TS updates easier.
// Only VE does it, but on Ivy the i18n extraction uses VE.
await updateJsonFile('tsconfig.json', config => {
if (!config.angularCompilerOptions) {
config.angularCompilerOptions = {};
}
config.angularCompilerOptions.disableTypeScriptVersionCheck = true;
});
// If on CI, the user configuration set above will handle project usage
if (!isCI) {
// Ensure local test registry is used inside a project

22
tests/legacy-cli/e2e/utils/project.ts
View File

@ -34,28 +34,6 @@ export function ngServe(...args: string[]) {
/ Compiled successfully./);
}
export async function createProject(name: string, ...args: string[]) {
const extraArgs = [];
process.chdir(getGlobalVariable('tmp-root'));
await ng('new', name, '--skip-install', ...extraArgs, ...args);
process.chdir(name);
if (fs.existsSync('tsconfig.json')) {
// Disable the TS version check to make TS updates easier.
// Only VE does it, but on Ivy the i18n extraction uses VE.
await updateJsonFile('tsconfig.json', config => {
if (!config.angularCompilerOptions) {
config.angularCompilerOptions = {};
}
config.angularCompilerOptions.disableTypeScriptVersionCheck = true;
});
}
await prepareProjectForE2e(name);
}
export async function prepareProjectForE2e(name) {
const argv: string[] = getGlobalVariable('argv');

10
yarn.lock
View File

@ -87,8 +87,7 @@
"@angular/dev-infra-private@https://github.com/angular/dev-infra-private-builds.git#6b6fba2b22d33fe3c52341f4b3970e4087e50557":
version "0.0.0"
uid "6b6fba2b22d33fe3c52341f4b3970e4087e50557"
resolved "https://github.com/angular/dev-infra-private-builds.git#6b6fba2b22d33fe3c52341f4b3970e4087e50557"
resolved "https://github.com/angular/dev-infra-private-builds.git#a6b42dabedcf7c724bd36a614ebe9fa99c777e62"
dependencies:
"@angular/benchpress" "0.2.1"
"@bazel/buildifier" "^0.29.0"
@ -12514,7 +12513,12 @@ typedarray@^0.0.6:
resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
typescript@4.1.5, typescript@~4.1.2:
typescript@4.2.3:
version "4.2.3"
resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3"
integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==
typescript@~4.1.2:
version "4.1.5"
resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.1.5.tgz#123a3b214aaff3be32926f0d8f1f6e704eb89a72"
integrity sha512-6OSu9PTIzmn9TCDiovULTnET6BgXtDYL4Gg4szY+cGsc3JP1dQL8qvE8kShTRx1NIw4Q9IBHlwODjkjWEtMUyA==