- Removing ts. from jsTyping.js

- Adding ".json" file extension filter when retrieving json files from host and removoing filter - simplify isTypingEnabled check

Author: jramsay

src/services/jsTyping.ts

@@ -29,17 +29,6 @@ namespace ts.JsTyping {
  return undefined;
  }
 
- function isTypingEnabled(options: TypingOptions): boolean {
- if (options) {
- if (options.enableAutoDiscovery ||
- (options.include && options.include.length > 0) ||
- (options.exclude && options.exclude.length > 0)) {
- return true;
- }
- }
- return false;
- }
-
  /**
  * @param host is the object providing I/O related operations.
  * @param fileNames are the file names that belong to the same project.
@@ -60,15 +49,15 @@ namespace ts.JsTyping {
  // A typing name to typing file path mapping
  const inferredTypings: Map<string> = {};
 
- if (!isTypingEnabled(typingOptions)) {
+ if (!typingOptions || !typingOptions.enableAutoDiscovery) {
  return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
  }
 
  const cachePath = projectRootPath || globalCachePath;
  // Only infer typings for .js and .jsx files
- fileNames = filter(map(fileNames, ts.normalizePath), f => scriptKindIs(f, /*LanguageServiceHost*/ undefined, ScriptKind.JS, ScriptKind.JSX));
+ fileNames = filter(map(fileNames, normalizePath), f => scriptKindIs(f, /*LanguageServiceHost*/ undefined, ScriptKind.JS, ScriptKind.JSX));
 
- const safeListFilePath = ts.combinePaths(globalCachePath, "safeList.json");
+ const safeListFilePath = combinePaths(globalCachePath, "safeList.json");
  if (!safeList && host.fileExists(safeListFilePath)) {
  safeList = tryParseJson(safeListFilePath, host);
  }
@@ -82,28 +71,28 @@ namespace ts.JsTyping {
  exclude = typingOptions.exclude || [];
 
  if (typingOptions.enableAutoDiscovery) {
- const possibleSearchDirs = map(fileNames, ts.getDirectoryPath);
+ const possibleSearchDirs = map(fileNames, getDirectoryPath);
  if (projectRootPath !== undefined) {
  possibleSearchDirs.push(projectRootPath);
  }
- searchDirs = ts.deduplicate(possibleSearchDirs);
+ searchDirs = deduplicate(possibleSearchDirs);
  for (const searchDir of searchDirs) {
- const packageJsonPath = ts.combinePaths(searchDir, "package.json");
+ const packageJsonPath = combinePaths(searchDir, "package.json");
  getTypingNamesFromJson(packageJsonPath, filesToWatch);
 
- const bowerJsonPath = ts.combinePaths(searchDir, "bower.json");
+ const bowerJsonPath = combinePaths(searchDir, "bower.json");
  getTypingNamesFromJson(bowerJsonPath, filesToWatch);
 
- const nodeModulesPath = ts.combinePaths(searchDir, "node_modules");
+ const nodeModulesPath = combinePaths(searchDir, "node_modules");
  getTypingNamesFromNodeModuleFolder(nodeModulesPath, filesToWatch);
  }
 
  getTypingNamesFromSourceFileNames(fileNames);
  getTypingNamesFromCompilerOptions(compilerOptions);
  }
 
- const typingsPath = ts.combinePaths(cachePath, "typings");
- const tsdJsonPath = ts.combinePaths(cachePath, "tsd.json");
+ const typingsPath = combinePaths(cachePath, "typings");
+ const tsdJsonPath = combinePaths(cachePath, "tsd.json");
  const tsdJsonDict = tryParseJson(tsdJsonPath, host);
  if (tsdJsonDict) {
  for (const notFoundTypingName of notFoundTypingNames) {
@@ -122,7 +111,7 @@ namespace ts.JsTyping {
  // If the inferred[cachedTypingName] is already not null, which means we found a corresponding
  // d.ts file that coming with the package. That one should take higher priority.
  if (hasProperty(inferredTypings, cachedTypingName) && !inferredTypings[cachedTypingName]) {
- inferredTypings[cachedTypingName] = ts.combinePaths(typingsPath, cachedTypingPath);
+ inferredTypings[cachedTypingName] = combinePaths(typingsPath, cachedTypingPath);
  }
  }
  }
@@ -190,7 +179,7 @@ namespace ts.JsTyping {
  */
  function getTypingNamesFromSourceFileNames(fileNames: string[]) {
  const jsFileNames = filter(fileNames, hasJavaScriptFileExtension);
- const inferredTypingNames = map(jsFileNames, f => ts.removeFileExtension(ts.getBaseFileName(f.toLowerCase())));
+ const inferredTypingNames = map(jsFileNames, f => removeFileExtension(getBaseFileName(f.toLowerCase())));
  const cleanedTypingNames = map(inferredTypingNames, f => f.replace(/((?:\.|-)min(?=\.|$))|((?:-|\.)\d+)/g, ""));
  if (safeList === undefined) {
  mergeTypings(cleanedTypingNames);
@@ -216,16 +205,13 @@ namespace ts.JsTyping {
  }
 
  const typingNames: string[] = [];
- const packageJsonFiles =
- filter(
- host.readDirectory(nodeModulesPath, /*extension*/ undefined, /*exclude*/ undefined, /*depth*/ 2),
- f => ts.getBaseFileName(f) === "package.json");
-
- for (const packageJsonFile of packageJsonFiles) {
- const packageJsonDict = tryParseJson(packageJsonFile, host);
+ const jsonFiles = host.readDirectory(nodeModulesPath, "*.json", /*exclude*/ undefined, /*depth*/ 2);
+ for (const jsonFile of jsonFiles) {
+ if (getBaseFileName(jsonFile) !== "package.json") { continue; }
+ const packageJsonDict = tryParseJson(jsonFile, host);
  if (!packageJsonDict) { continue; }
 
- filesToWatch.push(packageJsonFile);
+ filesToWatch.push(jsonFile);
 
  // npm 3 has the package.json contains a "_requiredBy" field
  // we should include all the top level module names for npm 2, and only module names whose
@@ -239,8 +225,8 @@ namespace ts.JsTyping {
  // to download d.ts files from DefinitelyTyped
  const packageName = packageJsonDict["name"];
  if (hasProperty(packageJsonDict, "typings")) {
- const absPath = ts.getNormalizedAbsolutePath(packageJsonDict.typings, ts.getDirectoryPath(packageJsonFile));
- inferredTypings[packageName] = absPath;
+ const absolutePath = getNormalizedAbsolutePath(packageJsonDict.typings, getDirectoryPath(jsonFile));
+ inferredTypings[packageName] = absolutePath;
  }
  else {
  typingNames.push(packageName);
@@ -267,7 +253,7 @@ namespace ts.JsTyping {
  * @param host The object providing I/O related operations.
  */
  export function updateNotFoundTypingNames(newTypingNames: string[], cachePath: string, host: TypingResolutionHost): void {
- const tsdJsonPath = ts.combinePaths(cachePath, "tsd.json");
+ const tsdJsonPath = combinePaths(cachePath, "tsd.json");
  const cacheTsdJsonDict = tryParseJson(tsdJsonPath, host);
  if (cacheTsdJsonDict) {
  const installedTypingFiles = hasProperty(cacheTsdJsonDict, "installed")