Fix typo in compiler reactNamespace error string

nojvek · nojvek · commit f04f93c41462 · 2016-01-30T11:37:02.000-08:00
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -2171,7 +2171,7 @@
         "category": "Error",
         "code": 5058
     },
-    "Invalide value for '--reactNamespace'. '{0}' is not a valid identifier.": {
+    "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier.": {
         "category": "Error",
         "code": 5059
     },
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -142,55 +142,55 @@ namespace ts {
     type ResolutionKindSpecificLoader = (candidate: string, extensions: string[], failedLookupLocations: string[], onlyRecordFalures: boolean, state: ModuleResolutionState) => string;
 
     /**
-     * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to 
-     * mitigate differences between design time structure of the project and its runtime counterpart so the same import name 
-     * can be resolved successfully by TypeScript compiler and runtime module loader. 
+     * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to
+     * mitigate differences between design time structure of the project and its runtime counterpart so the same import name
+     * can be resolved successfully by TypeScript compiler and runtime module loader.
      * If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will
      * fallback to standard resolution routine.
-     * 
+     *
      * - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative
      * names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then canditate location to resolve module name 'c/d' will
      * be '/a/b/c/d'
-     * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names 
-     * will be resolved based on the content of the module name. 
+     * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names
+     * will be resolved based on the content of the module name.
      * Structure of 'paths' compiler options
      * 'paths': {
      *    pattern-1: [...substitutions],
      *    pattern-2: [...substitutions],
      *    ...
      *    pattern-n: [...substitutions]
      * }
-     * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against 
+     * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against
      * all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case.
-     * If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>. 
-     * <MatchedStar> denotes part of the module name between <prefix> and <suffix>. 
+     * If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>.
+     * <MatchedStar> denotes part of the module name between <prefix> and <suffix>.
      * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.
-     * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module 
-     * from the candidate location. 
-     * Substitiution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every 
-     * substitution in the list and replace '*' with <MatchedStar> string. If candidate location is not rooted it 
+     * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module
+     * from the candidate location.
+     * Substitiution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every
+     * substitution in the list and replace '*' with <MatchedStar> string. If candidate location is not rooted it
      * will be converted to absolute using baseUrl.
      * For example:
      * baseUrl: /a/b/c
      * "paths": {
      *     // match all module names
-     *     "*": [ 
+     *     "*": [
      *         "*",        // use matched name as is,
      *                     // <matched name> will be looked as /a/b/c/<matched name>
      *
      *         "folder1/*" // substitution will convert matched name to 'folder1/<matched name>',
-     *                     // since it is not rooted then final candidate location will be /a/b/c/folder1/<matched name> 
+     *                     // since it is not rooted then final candidate location will be /a/b/c/folder1/<matched name>
      *     ],
      *     // match module names that start with 'components/'
      *     "components/*": [ "/root/components/*" ] // substitution will convert /components/folder1/<matched name> to '/root/components/folder1/<matched name>',
      *                                              // it is rooted so it will be final candidate location
      * }
      *
-     * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if 
+     * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if
      * they were in the same location. For example lets say there are two files
      * '/local/src/content/file1.ts'
      * '/shared/components/contracts/src/content/protocols/file2.ts'
-     * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so 
+     * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so
      * if file1 has the following import 'import {x} from "./protocols/file2"' it will be resolved successfully in runtime.
      * 'rootDirs' provides the way to tell compiler that in order to get the whole project it should behave as if content of all
      * root dirs were merged together.
@@ -229,7 +229,7 @@ namespace ts {
         let matchedNormalizedPrefix: string;
         for (const rootDir of state.compilerOptions.rootDirs) {
             // rootDirs are expected to be absolute
-            // in case of tsconfig.json this will happen automatically - compiler will expand relative names 
+            // in case of tsconfig.json this will happen automatically - compiler will expand relative names
             // using locaton of tsconfig.json as base location
             let normalizedRoot = normalizePath(rootDir);
             if (!endsWith(normalizedRoot, directorySeparator)) {
@@ -269,7 +269,7 @@ namespace ts {
             // then try to resolve using remaining entries in rootDirs
             for (const rootDir of state.compilerOptions.rootDirs) {
                 if (rootDir === matchedRootDir) {
-                    // skip the initially matched entry 
+                    // skip the initially matched entry
                     continue;
                 }
                 const candidate = combinePaths(normalizePath(rootDir), suffix);
@@ -412,7 +412,7 @@ namespace ts {
 
     /**
      * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
-     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations. 
+     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
      */
     function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
         return forEach(extensions, tryLoad);
@@ -450,7 +450,7 @@ namespace ts {
                 jsonContent = jsonText ? <{ typings?: string }>JSON.parse(jsonText) : { typings: undefined };
             }
             catch (e) {
-                // gracefully handle if readFile fails or returns not JSON 
+                // gracefully handle if readFile fails or returns not JSON
                 jsonContent = { typings: undefined };
             }
 
@@ -719,7 +719,7 @@ namespace ts {
 
         const filesByName = createFileMap<SourceFile>();
         // stores 'filename -> file association' ignoring case
-        // used to track cases when two file names differ only in casing 
+        // used to track cases when two file names differ only in casing
         const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;
 
         if (oldProgram) {
@@ -1295,7 +1295,7 @@ namespace ts {
                         }
 
                         // TypeScript 1.0 spec (April 2014): 12.1.6
-                        // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference other external modules 
+                        // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference other external modules
                         // only through top - level external module names. Relative external module names are not permitted.
                         if (!inAmbientModule || !isExternalModuleNameRelative((<LiteralExpression>moduleNameExpr).text)) {
                             (imports || (imports = [])).push(<LiteralExpression>moduleNameExpr);
@@ -1313,7 +1313,7 @@ namespace ts {
                                 (moduleAugmentations || (moduleAugmentations = [])).push(moduleName);
                             }
                             else if (!inAmbientModule) {
-                                // An AmbientExternalModuleDeclaration declares an external module. 
+                                // An AmbientExternalModuleDeclaration declares an external module.
                                 // This type of declaration is permitted only in the global module.
                                 // The StringLiteral must specify a top - level external module name.
                                 // Relative external module names are not permitted
@@ -1713,7 +1713,7 @@ namespace ts {
             }
 
             if (options.reactNamespace && !isIdentifier(options.reactNamespace, languageVersion)) {
-                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Invalide_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace));
+                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace));
             }
 
             // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
diff --git a/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt b/tests/baselines/reference/reactNamespaceInvalidInput.errors.txt
@@ -1,8 +1,8 @@
-error TS5059: Invalide value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier.
+error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier.
 tests/cases/compiler/reactNamespaceInvalidInput.tsx(2,2): error TS2304: Cannot find name 'my-React-Lib'.
 
 
-!!! error TS5059: Invalide value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier.
+!!! error TS5059: Invalid value for '--reactNamespace'. 'my-React-Lib' is not a valid identifier.
 ==== tests/cases/compiler/reactNamespaceInvalidInput.tsx (1 errors) ====
     
     <foo data/>;
