ts-loader - npm Package Compare versions

Comparing version 8.1.0 to 8.2.0

CHANGELOG.md

 # Changelog
 
+## v8.2.0
+
+* [Use caches for module resolution and type reference directives when using compiler default functions](https://github.com/TypeStrong/ts-loader/pull/1287) - thanks @sheetalkamat - uses: https://github.com/microsoft/TypeScript/pull/43700
+* This is a backport from v9.1.0 for webpack 4 compatibility
+
 ## v8.1.0
@@ -4,0 +9,0 @@ * [feat: remove top-level typescript import statements](https://github.com/TypeStrong/ts-loader/pull/1259) - thanks @ulivz

dist/interfaces.d.ts

@@ -74,3 +74,3 @@ import type * as typescript from 'typescript';
 }
-export interface WatchHost extends typescript.WatchCompilerHostOfFilesAndCompilerOptions<typescript.EmitAndSemanticDiagnosticsBuilderProgram> {
+export interface WatchHost extends typescript.WatchCompilerHostOfFilesAndCompilerOptions<typescript.EmitAndSemanticDiagnosticsBuilderProgram>, HostMayBeCacheable {
     invokeFileWatcher: WatchFactory['invokeFileWatcher'];
@@ -135,2 +135,26 @@ updateRootFileNames(): void;
 }
+interface CacheWithRedirects<T> {
+    ownMap: Map<string, T>;
+    redirectsMap: Map<typescript.Path, Map<string, T>>;
+    getOrCreateMapOfCacheRedirects(redirectedReference: typescript.ResolvedProjectReference | undefined): Map<string, T>;
+    clear(): void;
+    setOwnOptions(newOptions: typescript.CompilerOptions): void;
+    setOwnMap(newOwnMap: Map<string, T>): void;
+}
+interface PerModuleNameCache {
+    get(directory: string): typescript.ResolvedModuleWithFailedLookupLocations | undefined;
+    set(directory: string, result: typescript.ResolvedModuleWithFailedLookupLocations): void;
+}
+export interface ModuleResolutionCache extends typescript.ModuleResolutionCache {
+    directoryToModuleNameMap: CacheWithRedirects<Map<string, typescript.ResolvedModuleWithFailedLookupLocations>>;
+    moduleNameToDirectoryMap: CacheWithRedirects<PerModuleNameCache>;
+    clear(): void;
+    update(compilerOptions: typescript.CompilerOptions): void;
+    getPackageJsonInfoCache?(): any;
+}
+export interface TypeReferenceDirectiveResolutionCache {
+    getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: typescript.ResolvedProjectReference): Map<string, typescript.ResolvedTypeReferenceDirectiveWithFailedLookupLocations>;
+    clear(): void;
+    update(compilerOptions: typescript.CompilerOptions): void;
+}
 export interface TSInstance {
@@ -143,2 +167,4 @@ compiler: typeof typescript;
     rootFileNames: Set<string>;
+    moduleResolutionCache?: ModuleResolutionCache;
+    typeReferenceResolutionCache?: TypeReferenceDirectiveResolutionCache;
     /**
@@ -239,2 +265,3 @@ * a cache of all the files
 export declare type Severity = 'error' | 'warning';
+export {};
 //# sourceMappingURL=interfaces.d.ts.map

dist/servicesHost.js

@@ -111,10 +111,10 @@ "use strict";
 function makeResolvers(compiler, compilerOptions, moduleResolutionHost, customResolveTypeReferenceDirective, customResolveModuleName, resolveSync, appendTsTsxSuffixesIfRequired, scriptRegex, instance) {
-    const resolveTypeReferenceDirective = makeResolveTypeReferenceDirective(compiler, compilerOptions, moduleResolutionHost, customResolveTypeReferenceDirective);
-    const resolveTypeReferenceDirectives = (typeDirectiveNames, containingFile, _redirectedReference) => typeDirectiveNames.map(directive => resolveTypeReferenceDirective(directive, containingFile, _redirectedReference).resolvedTypeReferenceDirective);
-    const resolveModuleName = makeResolveModuleName(compiler, compilerOptions, moduleResolutionHost, customResolveModuleName);
-    const resolveModuleNames = (moduleNames, containingFile, _reusedNames, _redirectedReference) => {
-        const resolvedModules = moduleNames.map(moduleName => resolveModule(resolveSync, resolveModuleName, appendTsTsxSuffixesIfRequired, scriptRegex, moduleName, containingFile));
+    const resolveModuleName = makeResolveModuleName(compiler, compilerOptions, moduleResolutionHost, customResolveModuleName, instance);
+    const resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference) => {
+        const resolvedModules = moduleNames.map(moduleName => resolveModule(resolveSync, resolveModuleName, appendTsTsxSuffixesIfRequired, scriptRegex, moduleName, containingFile, redirectedReference));
         utils_1.populateDependencyGraph(resolvedModules, instance, containingFile);
         return resolvedModules;
     };
+    const resolveTypeReferenceDirective = makeResolveTypeReferenceDirective(compiler, compilerOptions, moduleResolutionHost, customResolveTypeReferenceDirective, instance);
+    const resolveTypeReferenceDirectives = (typeDirectiveNames, containingFile, redirectedReference) => typeDirectiveNames.map(directive => resolveTypeReferenceDirective(directive, containingFile, redirectedReference).resolvedTypeReferenceDirective);
     return {
@@ -234,4 +234,3 @@ resolveTypeReferenceDirectives,
     const { moduleResolutionHost, resolveModuleNames, resolveTypeReferenceDirectives, } = makeResolversAndModuleResolutionHost(scriptRegex, loader, instance, fileName => files.has(filePathKeyMapper(fileName)) ||
-        compiler.sys.fileExists(fileName), 
-    /*enabledCaching*/ false);
+        compiler.sys.fileExists(fileName), instance.loaderOptions.experimentalFileCaching);
     const watchHost = Object.assign(Object.assign({ rootFiles: getRootFileNames(), options: compilerOptions }, moduleResolutionHost), { readFile: readFileWithCachingText, watchFile: (fileName, callback, pollingInterval, options) => {
@@ -296,2 +295,44 @@ var _a;
 const missingFileModifiedTime = new Date(0);
+function identity(x) {
+    return x;
+}
+function toLowerCase(x) {
+    return x.toLowerCase();
+}
+const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
+function toFileNameLowerCase(x) {
+    return fileNameLowerCaseRegExp.test(x)
+        ? x.replace(fileNameLowerCaseRegExp, toLowerCase)
+        : x;
+}
+function createGetCanonicalFileName(instance) {
+    return utils_1.useCaseSensitiveFileNames(instance.compiler, instance.loaderOptions)
+        ? identity
+        : toFileNameLowerCase;
+}
+function createModuleResolutionCache(instance, moduleResolutionHost) {
+    const cache = instance.compiler.createModuleResolutionCache(moduleResolutionHost.getCurrentDirectory(), createGetCanonicalFileName(instance), instance.compilerOptions);
+    // Add new API optional methods
+    if (!cache.clear) {
+        cache.clear = () => {
+            cache.directoryToModuleNameMap.clear();
+            cache.moduleNameToDirectoryMap.clear();
+        };
+    }
+    if (!cache.update) {
+        cache.update = options => {
+            if (!options.configFile)
+                return;
+            const ref = {
+                sourceFile: options.configFile,
+                commandLine: { options },
+            };
+            cache.directoryToModuleNameMap.setOwnMap(cache.directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
+            cache.moduleNameToDirectoryMap.setOwnMap(cache.moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
+            cache.directoryToModuleNameMap.setOwnOptions(options);
+            cache.moduleNameToDirectoryMap.setOwnOptions(options);
+        };
+    }
+    return cache;
+}
 /**
@@ -305,5 +346,3 @@ * Create the TypeScript Watch host
         getCurrentDirectory: compiler.sys.getCurrentDirectory,
-        getCanonicalFileName: utils_1.useCaseSensitiveFileNames(compiler, instance.loaderOptions)
-            ? s => s
-            : s => s.toLowerCase(),
+        getCanonicalFileName: createGetCanonicalFileName(instance),
         getNewLine: () => compiler.sys.newLine,
@@ -359,3 +398,11 @@ };
     const sysHost = compiler.createSolutionBuilderWithWatchHost(compiler.sys, compiler.createEmitAndSemanticDiagnosticsBuilderProgram, reportDiagnostic, reportSolutionBuilderStatus, reportWatchStatus);
-    const solutionBuilderHost = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, sysHost), moduleResolutionHost), { resolveModuleNames,
+    const solutionBuilderHost = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, sysHost), moduleResolutionHost), { createProgram: (rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences) => {
+            var _a, _b, _c, _d;
+            (_a = instance.moduleResolutionCache) === null || _a === void 0 ? void 0 : _a.update(options || {});
+            (_b = instance.typeReferenceResolutionCache) === null || _b === void 0 ? void 0 : _b.update(options || {});
+            const result = sysHost.createProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences);
+            (_c = instance.typeReferenceResolutionCache) === null || _c === void 0 ? void 0 : _c.update(instance.compilerOptions);
+            (_d = instance.moduleResolutionCache) === null || _d === void 0 ? void 0 : _d.update(instance.compilerOptions);
+            return result;
+        }, resolveModuleNames,
         resolveTypeReferenceDirectives,
@@ -627,5 +674,13 @@ diagnostics }), createWatchFactory(filePathKeyMapper, compiler)), {
 exports.getSolutionErrors = getSolutionErrors;
-function makeResolveTypeReferenceDirective(compiler, compilerOptions, moduleResolutionHost, customResolveTypeReferenceDirective) {
+function makeResolveTypeReferenceDirective(compiler, compilerOptions, moduleResolutionHost, customResolveTypeReferenceDirective, instance) {
+    var _a, _b;
     if (customResolveTypeReferenceDirective === undefined) {
-        return (directive, containingFile, redirectedReference) => compiler.resolveTypeReferenceDirective(directive, containingFile, compilerOptions, moduleResolutionHost, redirectedReference);
+        // Until the api is published
+        if (compiler.createTypeReferenceDirectiveResolutionCache &&
+            !instance.typeReferenceResolutionCache) {
+            instance.typeReferenceResolutionCache = compiler.createTypeReferenceDirectiveResolutionCache(moduleResolutionHost.getCurrentDirectory(), createGetCanonicalFileName(instance), instance.compilerOptions, (_b = (_a = instance.moduleResolutionCache) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.call(_a));
+        }
+        return (directive, containingFile, redirectedReference) => 
+        // Until the api is published
+        compiler.resolveTypeReferenceDirective(directive, containingFile, compilerOptions, moduleResolutionHost, redirectedReference, instance.typeReferenceResolutionCache);
     }
@@ -638,3 +693,3 @@ return (directive, containingFile) => customResolveTypeReferenceDirective(directive, containingFile, compilerOptions, moduleResolutionHost, compiler.resolveTypeReferenceDirective);
 }
-function resolveModule(resolveSync, resolveModuleName, appendTsTsxSuffixesIfRequired, scriptRegex, moduleName, containingFile) {
+function resolveModule(resolveSync, resolveModuleName, appendTsTsxSuffixesIfRequired, scriptRegex, moduleName, containingFile, redirectedReference) {
     let resolutionResult;
@@ -649,10 +704,6 @@ try {
     catch (e) { }
-    const tsResolution = resolveModuleName(moduleName, containingFile);
+    const tsResolution = resolveModuleName(moduleName, containingFile, redirectedReference);
     if (tsResolution.resolvedModule !== undefined) {
         const resolvedFileName = path.normalize(tsResolution.resolvedModule.resolvedFileName);
-        const tsResolutionResult = {
-            originalFileName: resolvedFileName,
-            resolvedFileName,
-            isExternalLibraryImport: tsResolution.resolvedModule.isExternalLibraryImport,
-        };
+        const tsResolutionResult = Object.assign(Object.assign({}, tsResolution.resolvedModule), { originalFileName: resolvedFileName, resolvedFileName });
         return resolutionResult === undefined ||
@@ -667,5 +718,8 @@ resolutionResult.resolvedFileName ===
 }
-function makeResolveModuleName(compiler, compilerOptions, moduleResolutionHost, customResolveModuleName) {
+function makeResolveModuleName(compiler, compilerOptions, moduleResolutionHost, customResolveModuleName, instance) {
     if (customResolveModuleName === undefined) {
-        return (moduleName, containingFile) => compiler.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost);
+        if (!instance.moduleResolutionCache) {
+            instance.moduleResolutionCache = createModuleResolutionCache(instance, moduleResolutionHost);
+        }
+        return (moduleName, containingFile, redirectedReference) => compiler.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost, instance.moduleResolutionCache, redirectedReference);
     }
@@ -672,0 +726,0 @@ return (moduleName, containingFile) => customResolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost, compiler.resolveModuleName);

dist/watch-run.js

@@ -18,4 +18,7 @@ "use strict";
     return (compiler, callback) => {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f;
         (_b = (_a = instance.servicesHost) === null || _a === void 0 ? void 0 : _a.clearCache) === null || _b === void 0 ? void 0 : _b.call(_a);
+        (_d = (_c = instance.watchHost) === null || _c === void 0 ? void 0 : _c.clearCache) === null || _d === void 0 ? void 0 : _d.call(_c);
+        (_e = instance.moduleResolutionCache) === null || _e === void 0 ? void 0 : _e.clear();
+        (_f = instance.typeReferenceResolutionCache) === null || _f === void 0 ? void 0 : _f.clear();
         const promises = [];
@@ -22,0 +25,0 @@ if (instance.loaderOptions.transpileOnly) {

package.json

 {
   "name": "ts-loader",
-  "version": "8.1.0",
+  "version": "8.2.0",
   "description": "TypeScript loader for webpack",
@@ -5,0 +5,0 @@ "main": "index.js",

README.md

 # TypeScript loader for webpack
 
 [![npm version](https://img.shields.io/npm/v/ts-loader.svg)](https://www.npmjs.com/package/ts-loader)
-![GitHub build)](https://github.com/TypeStrong/ts-loader/workflows/Continuous%20Integration%20(build%20and%20test)/badge.svg)
+[![build and test](https://github.com/TypeStrong/ts-loader/actions/workflows/push.yml/badge.svg)](https://github.com/TypeStrong/ts-loader/actions/workflows/push.yml)
 [![Downloads](http://img.shields.io/npm/dm/ts-loader.svg)](https://npmjs.org/package/ts-loader)
@@ -130,3 +130,3 @@ [![node version](https://img.shields.io/node/v/ts-loader.svg)](https://www.npmjs.com/package/ts-loader)
 
-`ts-loader` works very well in combination with [babel](https://babeljs.io/) and [babel-loader](https://github.com/babel/babel-loader). There is an [example](https://github.com/Microsoft/TypeScriptSamples/tree/master/react-flux-babel-karma) of this in the official [TypeScript Samples](https://github.com/Microsoft/TypeScriptSamples). Alternatively take a look at our own [example](examples/react-babel-karma-gulp).
+`ts-loader` works very well in combination with [babel](https://babeljs.io/) and [babel-loader](https://github.com/babel/babel-loader). There is an [example](https://github.com/Microsoft/TypeScriptSamples/tree/master/react-flux-babel-karma) of this in the official [TypeScript Samples](https://github.com/Microsoft/TypeScriptSamples). 
 
@@ -742,4 +742,4 @@ ### Parallelising Builds
 plugins: [
-  new webpack.WatchIgnorePlugin(
-    paths:{[
+  new webpack.WatchIgnorePlugin({
+    paths:[
       /\.js$/,
@@ -746,0 +746,0 @@ /\.d\.ts$/

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

249138

increased by2.72%

Lines of code

3045

increased by2.87%

No dependency changes