typescript 4.6.0-dev.20220202 → 4.6.0-dev.20220206

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220206";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1263,11 +1263,11 @@ var ts;
         return result;
     }
     ts.getAllKeys = getAllKeys;
-    function getOwnValues(sparseArray) {
+    function getOwnValues(collection) {
         var values = [];
-        for (var key in sparseArray) {
-            if (hasOwnProperty.call(sparseArray, key)) {
-                values.push(sparseArray[key]);
+        for (var key in collection) {
+            if (hasOwnProperty.call(collection, key)) {
+                values.push(collection[key]);
             }
         }
         return values;
@@ -8670,12 +8670,10 @@ var ts;
         Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: diag(2802, ts.DiagnosticCategory.Error, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."),
         Cannot_assign_to_private_method_0_Private_methods_are_not_writable: diag(2803, ts.DiagnosticCategory.Error, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."),
         Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: diag(2804, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."),
-        Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag: diag(2805, ts.DiagnosticCategory.Error, "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805", "Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag."),
         Private_accessor_was_defined_without_a_getter: diag(2806, ts.DiagnosticCategory.Error, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."),
         This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."),
         A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, ts.DiagnosticCategory.Error, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"),
         Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."),
-        Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false: diag(2810, ts.DiagnosticCategory.Error, "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810", "Property '{0}' may not be used in a static property's initializer in the same class when 'target' is 'esnext' and 'useDefineForClassFields' is 'false'."),
         Initializer_for_property_0: diag(2811, ts.DiagnosticCategory.Error, "Initializer_for_property_0_2811", "Initializer for property '{0}'"),
         Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."),
         Class_declaration_cannot_implement_overload_list_for_0: diag(2813, ts.DiagnosticCategory.Error, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."),
@@ -9626,6 +9624,7 @@ var ts;
         Add_missing_attributes: diag(95167, ts.DiagnosticCategory.Message, "Add_missing_attributes_95167", "Add missing attributes"),
         Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"),
         Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
+        Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -12798,12 +12797,17 @@ var ts;
     /** Gets the text of a jsdoc comment, flattening links to their text. */
     function getTextOfJSDocComment(comment) {
         return typeof comment === "string" ? comment
-            : comment === null || comment === void 0 ? void 0 : comment.map(function (c) {
-                // TODO: Other kinds here
-                return c.kind === 319 /* JSDocText */ ? c.text : "{@link " + (c.name ? ts.entityNameToString(c.name) + " " : "") + c.text + "}";
-            }).join("");
+            : comment === null || comment === void 0 ? void 0 : comment.map(function (c) { return c.kind === 319 /* JSDocText */ ? c.text : formatJSDocLink(c); }).join("");
     }
     ts.getTextOfJSDocComment = getTextOfJSDocComment;
+    function formatJSDocLink(link) {
+        var kind = link.kind === 322 /* JSDocLink */ ? "link"
+            : link.kind === 323 /* JSDocLinkCode */ ? "linkcode"
+                : "linkplain";
+        var name = link.name ? ts.entityNameToString(link.name) : "";
+        var space = link.name && link.text.startsWith("://") ? "" : " ";
+        return "{@" + kind + " " + name + space + link.text + "}";
+    }
     /**
      * Gets the effective type parameters. If the node was parsed in a
      * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
@@ -72936,23 +72940,6 @@ var ts;
                 if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && ts.isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
                     grammarErrorOnNode(right, ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, ts.idText(right));
                 }
-                if ((lexicallyScopedSymbol === null || lexicallyScopedSymbol === void 0 ? void 0 : lexicallyScopedSymbol.valueDeclaration) && (ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && !useDefineForClassFields)) {
-                    var lexicalClass_1 = ts.getContainingClass(lexicallyScopedSymbol.valueDeclaration);
-                    var parentStaticFieldInitializer = ts.findAncestor(node, function (n) {
-                        if (n === lexicalClass_1)
-                            return "quit";
-                        if (ts.isPropertyDeclaration(n.parent) && ts.hasStaticModifier(n.parent) && n.parent.initializer === n && n.parent.parent === lexicalClass_1) {
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (parentStaticFieldInitializer) {
-                        var parentStaticFieldInitializerSymbol = getSymbolOfNode(parentStaticFieldInitializer.parent);
-                        ts.Debug.assert(parentStaticFieldInitializerSymbol, "Initializer without declaration symbol");
-                        var diagnostic = error(node, ts.Diagnostics.Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false, ts.symbolName(lexicallyScopedSymbol));
-                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(parentStaticFieldInitializer.parent, ts.Diagnostics.Initializer_for_property_0, ts.symbolName(parentStaticFieldInitializerSymbol)));
-                    }
-                }
                 if (isAnyLike) {
                     if (lexicallyScopedSymbol) {
                         return isErrorType(apparentType) ? errorType : apparentType;
@@ -78588,9 +78575,6 @@ var ts;
                 checkGrammarComputedPropertyName(node.name);
             checkVariableLikeDeclaration(node);
             setNodeLinksForPrivateIdentifierScope(node);
-            if (ts.isPrivateIdentifier(node.name) && ts.hasStaticModifier(node) && node.initializer && languageVersion === 99 /* ESNext */ && !compilerOptions.useDefineForClassFields) {
-                error(node.initializer, ts.Diagnostics.Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag);
-            }
             // property signatures already report "initializer not allowed in ambient context" elsewhere
             if (ts.hasSyntacticModifier(node, 128 /* Abstract */) && node.kind === 166 /* PropertyDeclaration */ && node.initializer) {
                 error(node, ts.Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
@@ -92280,10 +92264,12 @@ var ts;
         var languageVersion = ts.getEmitScriptTarget(compilerOptions);
         var useDefineForClassFields = ts.getUseDefineForClassFields(compilerOptions);
         var shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* ES2022 */;
+        // We need to transform `this` in a static initializer into a reference to the class
+        // when targeting < ES2022 since the assignment will be moved outside of the class body.
+        var shouldTransformThisInStaticInitializers = languageVersion < 9 /* ES2022 */;
         // We don't need to transform `super` property access when targeting ES5, ES3 because
         // the es2015 transformation handles those.
-        var shouldTransformSuperInStaticInitializers = (languageVersion <= 8 /* ES2021 */ || !useDefineForClassFields) && languageVersion >= 2 /* ES2015 */;
-        var shouldTransformThisInStaticInitializers = languageVersion <= 8 /* ES2021 */ || !useDefineForClassFields;
+        var shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2 /* ES2015 */;
         var previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
         var previousOnEmitNode = context.onEmitNode;
@@ -92512,6 +92498,10 @@ var ts;
             ts.Debug.assert(!ts.some(node.decorators));
             if (ts.isPrivateIdentifier(node.name)) {
                 if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
+                    if (ts.isStatic(node)) {
+                        // static fields are left as is
+                        return ts.visitEachChild(node, visitor, context);
+                    }
                     // Initializer is elided as the field is initialized in transformConstructor.
                     return factory.updatePropertyDeclaration(node, 
                     /*decorators*/ undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, 
@@ -92533,6 +92523,22 @@ var ts;
             if (expr && !ts.isSimpleInlineableExpression(expr)) {
                 getPendingExpressions().push(expr);
             }
+            if (ts.isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                var initializerStatement = transformPropertyOrClassStaticBlock(node, factory.createThis());
+                if (initializerStatement) {
+                    var staticBlock = factory.createClassStaticBlockDeclaration(
+                    /*decorators*/ undefined, 
+                    /*modifiers*/ undefined, factory.createBlock([initializerStatement]));
+                    ts.setOriginalNode(staticBlock, node);
+                    ts.setCommentRange(staticBlock, node);
+                    // Set the comment range for the statement to an empty synthetic range
+                    // and drop synthetic comments from the statement to avoid printing them twice.
+                    ts.setCommentRange(initializerStatement, { pos: -1, end: -1 });
+                    ts.setSyntheticLeadingComments(initializerStatement, undefined);
+                    ts.setSyntheticTrailingComments(initializerStatement, undefined);
+                    return staticBlock;
+                }
+            }
             return undefined;
         }
         function createPrivateIdentifierAccess(info, receiver) {
@@ -92920,7 +92926,6 @@ var ts;
             if (facts & 8 /* NeedsSubstitutionForThisInClassStaticField */) {
                 enableSubstitutionForClassStaticThisOrSuperReference();
             }
-            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             // If a class has private static fields, or a static field has a `this` or `super` reference,
             // then we need to allocate a temp variable to hold on to that reference.
             var pendingClassReferenceAssignment;
@@ -92948,6 +92953,7 @@ var ts;
             // From ES6 specification:
             //      HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using
             //                                  a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.
+            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             if (ts.some(staticProperties)) {
                 addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory.getInternalName(node));
             }
@@ -92986,7 +92992,7 @@ var ts;
             }
             var classExpression = factory.updateClassExpression(node, ts.visitNodes(node.decorators, visitor, ts.isDecorator), node.modifiers, node.name, 
             /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, heritageClauseVisitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass));
-            var hasTransformableStatics = ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifier(p.name)); });
+            var hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || ts.isPrivateIdentifier(p.name); });
             if (hasTransformableStatics || ts.some(pendingExpressions)) {
                 if (isDecoratedClassDeclaration) {
                     ts.Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
@@ -93033,6 +93039,7 @@ var ts;
             return undefined;
         }
         function transformClassMembers(node, isDerivedClass) {
+            var members = [];
             if (shouldTransformPrivateElementsOrClassStaticBlocks) {
                 // Declare private names.
                 for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
@@ -93045,12 +93052,20 @@ var ts;
                     createBrandCheckWeakSetForPrivateMethods();
                 }
             }
-            var members = [];
             var constructor = transformConstructor(node, isDerivedClass);
+            var visitedMembers = ts.visitNodes(node.members, classElementVisitor, ts.isClassElement);
             if (constructor) {
                 members.push(constructor);
             }
-            ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement));
+            if (!shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(pendingExpressions)) {
+                members.push(factory.createClassStaticBlockDeclaration(
+                /*decorators*/ undefined, 
+                /*modifiers*/ undefined, factory.createBlock([
+                    factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))
+                ])));
+                pendingExpressions = undefined;
+            }
+            ts.addRange(members, visitedMembers);
             return ts.setTextRange(factory.createNodeArray(members), /*location*/ node.members);
         }
         function createBrandCheckWeakSetForPrivateMethods() {
@@ -93193,24 +93208,34 @@ var ts;
         function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
             for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) {
                 var property = properties_7[_i];
-                var expression = ts.isClassStaticBlockDeclaration(property) ?
-                    transformClassStaticBlockDeclaration(property) :
-                    transformProperty(property, receiver);
-                if (!expression) {
+                if (ts.isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                    continue;
+                }
+                var statement = transformPropertyOrClassStaticBlock(property, receiver);
+                if (!statement) {
                     continue;
                 }
-                var statement = factory.createExpressionStatement(expression);
-                ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
-                ts.setCommentRange(statement, property);
-                ts.setOriginalNode(statement, property);
-                // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
-                // `statement` and `expression` have a copy of the synthesized comments.
-                // Drop the comments from expression to avoid printing them twice.
-                ts.setSyntheticLeadingComments(expression, undefined);
-                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
+        function transformPropertyOrClassStaticBlock(property, receiver) {
+            var expression = ts.isClassStaticBlockDeclaration(property) ?
+                transformClassStaticBlockDeclaration(property) :
+                transformProperty(property, receiver);
+            if (!expression) {
+                return undefined;
+            }
+            var statement = factory.createExpressionStatement(expression);
+            ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
+            ts.setCommentRange(statement, property);
+            ts.setOriginalNode(statement, property);
+            // `setOriginalNode` *copies* the `emitNode` from `property`, so now both
+            // `statement` and `expression` have a copy of the synthesized comments.
+            // Drop the comments from expression to avoid printing them twice.
+            ts.setSyntheticLeadingComments(expression, undefined);
+            ts.setSyntheticTrailingComments(expression, undefined);
+            return statement;
+        }
         /**
          * Generates assignment expressions for property initializers.
          *

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.6.0-dev.20220202",
+    "version": "4.6.0-dev.20220206",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [