rollup-plugin-typescript2 - npm Package Compare versions

Comparing version 0.0.1 to 0.1.0

dist/rollup-plugin-typescript2.cjs.js

 /* eslint-disable */
 'use strict';
 
+var fs = require('fs-extra');
 var ts = require('typescript');
-var rollupPluginutils = require('rollup-pluginutils');
-var fs = require('fs');
+var _ = require('lodash');
+var graph = require('graphlib');
+var hash = require('object-hash');
 var path = require('path');
-var _ = require('lodash');
+var colors = require('colors/safe');
 
-const __assign = Object.assign || function (target) {
-    for (var source, i = 1; i < arguments.length; i++) {
-        source = arguments[i];
-        for (var prop in source) {
-            if (Object.prototype.hasOwnProperty.call(source, prop)) {
-                target[prop] = source[prop];
-            }
-        }
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+
+var __assign = Object.assign || function __assign(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
     }
-    return target;
+    return t;
 };
 
+var VerbosityLevel;
+(function (VerbosityLevel) {
+    VerbosityLevel[VerbosityLevel["Error"] = 0] = "Error";
+    VerbosityLevel[VerbosityLevel["Warning"] = 1] = "Warning";
+    VerbosityLevel[VerbosityLevel["Info"] = 2] = "Info";
+    VerbosityLevel[VerbosityLevel["Debug"] = 3] = "Debug";
+})(VerbosityLevel || (VerbosityLevel = {}));
+var ConsoleContext = (function () {
+    function ConsoleContext(verbosity, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.verbosity = verbosity;
+        this.prefix = prefix;
+    }
+    ConsoleContext.prototype.warn = function (message) {
+        if (this.verbosity < VerbosityLevel.Warning)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.error = function (message) {
+        if (this.verbosity < VerbosityLevel.Error)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.info = function (message) {
+        if (this.verbosity < VerbosityLevel.Info)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.debug = function (message) {
+        if (this.verbosity < VerbosityLevel.Debug)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    return ConsoleContext;
+}());
+
+var LanguageServiceHost = (function () {
+    function LanguageServiceHost(parsedConfig) {
+        this.parsedConfig = parsedConfig;
+        this.cwd = process.cwd();
+        this.snapshots = {};
+    }
+    LanguageServiceHost.prototype.setSnapshot = function (fileName, data) {
+        var snapshot = ts.ScriptSnapshot.fromString(data);
+        this.snapshots[fileName] = snapshot;
+        return snapshot;
+    };
+    LanguageServiceHost.prototype.getScriptSnapshot = function (fileName) {
+        if (_.has(this.snapshots, fileName))
+            return this.snapshots[fileName];
+        if (fs.existsSync(fileName)) {
+            this.snapshots[fileName] = ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName));
+            return this.snapshots[fileName];
+        }
+        return undefined;
+    };
+    LanguageServiceHost.prototype.getCurrentDirectory = function () {
+        return this.cwd;
+    };
+    LanguageServiceHost.prototype.getScriptVersion = function (_fileName) {
+        return "0";
+    };
+    LanguageServiceHost.prototype.getScriptFileNames = function () {
+        return this.parsedConfig.fileNames;
+    };
+    LanguageServiceHost.prototype.getCompilationSettings = function () {
+        return this.parsedConfig.options;
+    };
+    LanguageServiceHost.prototype.getDefaultLibFileName = function (opts) {
+        return ts.getDefaultLibFilePath(opts);
+    };
+    return LanguageServiceHost;
+}());
+
+/**
+ * Saves data in new cache folder or reads it from old one.
+ * Avoids perpetually growing cache and situations when things need to consider changed and then reverted data to be changed.
+ */
+var RollingCache = (function () {
+    /**
+     * @param cacheRoot: root folder for the cache
+     * @param checkNewCache: whether to also look in new cache when reading from cache
+     */
+    function RollingCache(cacheRoot, checkNewCache) {
+        this.cacheRoot = cacheRoot;
+        this.checkNewCache = checkNewCache;
+        this.oldCacheRoot = this.cacheRoot + "/cache";
+        this.newCacheRoot = this.cacheRoot + "/cache_";
+        fs.emptyDirSync(this.newCacheRoot);
+    }
+    /**
+     * @returns true if name exist in old cache (or either old of new cache if checkNewCache is true)
+     */
+    RollingCache.prototype.exists = function (name) {
+        if (this.checkNewCache && fs.existsSync(this.newCacheRoot + "/" + name))
+            return true;
+        return fs.existsSync(this.oldCacheRoot + "/" + name);
+    };
+    /**
+     * @returns true if old cache contains all names and nothing more
+     */
+    RollingCache.prototype.match = function (names) {
+        if (!fs.existsSync(this.oldCacheRoot))
+            return names.length === 0; // empty folder matches
+        return _.isEqual(fs.readdirSync(this.oldCacheRoot).sort(), names.sort());
+    };
+    /**
+     * @returns data for name, must exist in old cache (or either old of new cache if checkNewCache is true)
+     */
+    RollingCache.prototype.read = function (name) {
+        if (this.checkNewCache && fs.existsSync(this.newCacheRoot + "/" + name))
+            return fs.readJsonSync(this.newCacheRoot + "/" + name, "utf8");
+        return fs.readJsonSync(this.oldCacheRoot + "/" + name, "utf8");
+    };
+    RollingCache.prototype.write = function (name, data) {
+        if (data === undefined)
+            return;
+        if (this.checkNewCache)
+            fs.writeJsonSync(this.newCacheRoot + "/" + name, data);
+        else
+            fs.writeJson(this.newCacheRoot + "/" + name, data, { encoding: "utf8" }, function () {  });
+    };
+    RollingCache.prototype.touch = function (name) {
+        if (this.checkNewCache)
+            fs.ensureFileSync(this.newCacheRoot + "/" + name);
+        else
+            fs.ensureFile(this.newCacheRoot + "/" + name, function () {  });
+    };
+    /**
+     * clears old cache and moves new in its place
+     */
+    RollingCache.prototype.roll = function () {
+        var _this = this;
+        fs.remove(this.oldCacheRoot, function () {
+            fs.move(_this.newCacheRoot, _this.oldCacheRoot, function () {  });
+        });
+    };
+    return RollingCache;
+}());
+
+var Cache = (function () {
+    function Cache(host, cache, options, rootFilenames, context) {
+        var _this = this;
+        this.host = host;
+        this.options = options;
+        this.context = context;
+        this.cacheVersion = "1";
+        this.ambientTypesDirty = false;
+        this.cacheDir = cache + "/" + hash.sha1({ version: this.cacheVersion, rootFilenames: rootFilenames, options: this.options });
+        this.dependencyTree = new graph.Graph({ directed: true });
+        this.dependencyTree.setDefaultNodeLabel(function (_node) { return { dirty: false }; });
+        this.ambientTypes = _.filter(rootFilenames, function (file) { return _.endsWith(file, ".d.ts"); })
+            .map(function (id) { return { id: id, snapshot: _this.host.getScriptSnapshot(id) }; });
+        this.init();
+    }
+    Cache.prototype.clean = function () {
+        this.context.info("cleaning cache: " + this.cacheDir);
+        fs.emptyDirSync(this.cacheDir);
+        this.init();
+    };
+    Cache.prototype.walkTree = function (cb) {
+        var acyclic = graph.alg.isAcyclic(this.dependencyTree);
+        if (acyclic) {
+            _.each(graph.alg.topsort(this.dependencyTree), function (id) { return cb(id); });
+            return;
+        }
+        this.context.info("import tree has cycles");
+        _.each(this.dependencyTree.nodes(), function (id) { return cb(id); });
+    };
+    Cache.prototype.setDependency = function (importee, importer) {
+        // importee -> importer
+        this.context.debug(importee + " -> " + importer);
+        this.dependencyTree.setEdge(importer, importee);
+    };
+    Cache.prototype.compileDone = function () {
+        var _this = this;
+        var typeNames = _.filter(this.ambientTypes, function (snaphot) { return snaphot.snapshot !== undefined; })
+            .map(function (snaphot) { return _this.makeName(snaphot.id, snaphot.snapshot); });
+        // types dirty if any d.ts changed, added or removed
+        this.ambientTypesDirty = !this.typesCache.match(typeNames);
+        if (this.ambientTypesDirty)
+            this.context.info("ambient types changed, redoing all diagnostics");
+        _.each(typeNames, function (name) { return _this.typesCache.touch(name); });
+    };
+    Cache.prototype.diagnosticsDone = function () {
+        this.codeCache.roll();
+        this.diagnosticsCache.roll();
+        this.typesCache.roll();
+    };
+    Cache.prototype.getCompiled = function (id, snapshot, transform) {
+        var name = this.makeName(id, snapshot);
+        if (!this.codeCache.exists(name) || this.isDirty(id, snapshot, false)) {
+            this.context.debug("fresh transpile for: " + id);
+            var data_1 = transform();
+            this.codeCache.write(name, data_1);
+            this.markAsDirty(id, snapshot);
+            return data_1;
+        }
+        this.context.debug("old transpile for: " + id);
+        var data = this.codeCache.read(name);
+        this.codeCache.write(name, data);
+        return data;
+    };
+    Cache.prototype.getDiagnostics = function (id, snapshot, check) {
+        var name = this.makeName(id, snapshot);
+        if (!this.diagnosticsCache.exists(name) || this.isDirty(id, snapshot, true)) {
+            this.context.debug("fresh diagnostics for: " + id);
+            var data_2 = this.convert(check());
+            this.diagnosticsCache.write(name, data_2);
+            this.markAsDirty(id, snapshot);
+            return data_2;
+        }
+        this.context.debug("old diagnostics for: " + id);
+        var data = this.diagnosticsCache.read(name);
+        this.diagnosticsCache.write(name, data);
+        return data;
+    };
+    Cache.prototype.init = function () {
+        this.codeCache = new RollingCache(this.cacheDir + "/code", true);
+        this.typesCache = new RollingCache(this.cacheDir + "/types", false);
+        this.diagnosticsCache = new RollingCache(this.cacheDir + "/diagnostics", false);
+    };
+    Cache.prototype.markAsDirty = function (id, _snapshot) {
+        this.context.debug("changed: " + id);
+        this.dependencyTree.setNode(id, { dirty: true });
+    };
+    // returns true if node or any of its imports or any of global types changed
+    Cache.prototype.isDirty = function (id, _snapshot, checkImports) {
+        var _this = this;
+        var label = this.dependencyTree.node(id);
+        if (!label)
+            return false;
+        if (!checkImports || label.dirty)
+            return label.dirty;
+        if (this.ambientTypesDirty)
+            return true;
+        var dependencies = graph.alg.dijkstra(this.dependencyTree, id);
+        return _.some(dependencies, function (dependency, node) {
+            if (!node || dependency.distance === Infinity)
+                return false;
+            var l = _this.dependencyTree.node(node);
+            var dirty = l === undefined ? true : l.dirty;
+            if (dirty)
+                _this.context.debug("import changed: " + id + " -> " + node);
+            return dirty;
+        });
+    };
+    Cache.prototype.makeName = function (id, snapshot) {
+        var data = snapshot.getText(0, snapshot.getLength());
+        return hash.sha1({ data: data, id: id });
+    };
+    Cache.prototype.convert = function (data) {
+        return _.map(data, function (diagnostic) {
+            var entry = {
+                flatMessage: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+            };
+            if (diagnostic.file) {
+                var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
+                entry.fileLine = diagnostic.file.fileName + " (" + (line + 1) + "," + (character + 1) + ")";
+            }
+            return entry;
+        });
+    };
+    return Cache;
+}());
+
+// tslint:disable-next-line:no-var-requires
+var createFilter = require("rollup-pluginutils").createFilter;
 function getOptionsOverrides() {
@@ -36,5 +320,4 @@ return {
     var fp = cwd ? (cwd + "/" + filename) : filename;
-    if (fs.existsSync(fp)) {
+    if (fs.existsSync(fp))
         return fp;
-    }
     var segs = cwd.split(path.sep);
@@ -45,5 +328,4 @@ var len = segs.length;
         fp = cwd + "/" + filename;
-        if (fs.existsSync(fp)) {
+        if (fs.existsSync(fp))
             return fp;
-        }
     }
@@ -66,2 +348,4 @@ return null;
     var fileName = findFile(process.cwd(), "tsconfig.json");
+    if (!fileName)
+        throw new Error("couldn't find 'tsconfig.json' in " + process.cwd());
     var text = ts.sys.readFile(fileName);
@@ -73,10 +357,7 @@ var result = ts.parseConfigFileTextToJson(fileName, text);
 function printDiagnostics(context, diagnostics) {
-    diagnostics.forEach(function (diagnostic) {
-        var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-        if (diagnostic.file) {
-            var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
-            context.warn({ message: diagnostic.file.fileName + " (" + (line + 1) + "," + (character + 1) + "): " + message });
-        }
+    _.each(diagnostics, function (diagnostic) {
+        if (diagnostic.fileLine)
+            context.warn(diagnostic.fileLine + ": " + colors.yellow(diagnostic.flatMessage));
         else
-            context.warn({ message: message });
+            context.warn(colors.yellow(diagnostic.flatMessage));
     });
@@ -87,19 +368,18 @@ }
     options = __assign({}, options);
-    var filter = rollupPluginutils.createFilter(options.include || ["*.ts+(|x)", "**/*.ts+(|x)"], options.exclude || ["*.d.ts", "**/*.d.ts"]);
-    delete options.include;
-    delete options.exclude;
+    _.defaults(options, {
+        check: true,
+        verbosity: VerbosityLevel.Info,
+        clean: false,
+        cacheRoot: process.cwd() + "/.rts2_cache",
+        include: ["*.ts+(|x)", "**/*.ts+(|x)"],
+        exclude: ["*.d.ts", "**/*.d.ts"],
+    });
+    var filter$$1 = createFilter(options.include, options.exclude);
     var parsedConfig = parseTsConfig();
-    var servicesHost = {
-        getScriptFileNames: function () { return parsedConfig.fileNames; },
-        getScriptVersion: function (_fileName) { return "0"; },
-        getScriptSnapshot: function (fileName) {
-            if (!fs.existsSync(fileName))
-                return undefined;
-            return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName));
-        },
-        getCurrentDirectory: function () { return process.cwd(); },
-        getCompilationSettings: function () { return parsedConfig.options; },
-        getDefaultLibFileName: function (opts) { return ts.getDefaultLibFilePath(opts); },
-    };
+    var servicesHost = new LanguageServiceHost(parsedConfig);
     var services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry());
+    var context = new ConsoleContext(options.verbosity, "rollup-plugin-typescript2: ");
+    var cache = new Cache(servicesHost, options.cacheRoot, parsedConfig.options, parsedConfig.fileNames, context);
+    if (options.clean)
+        cache.clean();
     return {
@@ -114,2 +394,4 @@ resolveId: function (importee, importer) {
             if (result.resolvedModule && result.resolvedModule.resolvedFileName) {
+                if (filter$$1(result.resolvedModule.resolvedFileName))
+                    cache.setDependency(result.resolvedModule.resolvedFileName, importer);
                 if (_.endsWith(result.resolvedModule.resolvedFileName, ".d.ts"))
@@ -124,21 +406,42 @@ return null;
                 return tslibSource;
+            return undefined;
         },
-        transform: function (_code, id) {
-            if (!filter(id))
-                return null;
-            var output = services.getEmitOutput(id);
-            var allDiagnostics = services
-                .getCompilerOptionsDiagnostics()
-                .concat(services.getSyntacticDiagnostics(id))
-                .concat(services.getSemanticDiagnostics(id));
-            printDiagnostics(this, allDiagnostics);
-            if (output.emitSkipped)
-                this.error({ message: "failed to transpile " + id });
-            var code = _.find(output.outputFiles, function (entry) { return _.endsWith(entry.name, ".js"); });
-            var map = _.find(output.outputFiles, function (entry) { return _.endsWith(entry.name, ".map"); });
-            return {
-                code: code ? code.text : undefined,
-                map: map ? JSON.parse(map.text) : { mappings: "" },
-            };
+        transform: function (code, id) {
+            var _this = this;
+            if (!filter$$1(id))
+                return undefined;
+            var snapshot = servicesHost.setSnapshot(id, code);
+            var result = cache.getCompiled(id, snapshot, function () {
+                var output = services.getEmitOutput(id);
+                if (output.emitSkipped)
+                    _this.error({ message: colors.red("failed to transpile " + id) });
+                var transpiled = _.find(output.outputFiles, function (entry) { return _.endsWith(entry.name, ".js"); });
+                var map$$1 = _.find(output.outputFiles, function (entry) { return _.endsWith(entry.name, ".map"); });
+                return {
+                    code: transpiled ? transpiled.text : undefined,
+                    map: map$$1 ? JSON.parse(map$$1.text) : { mappings: "" },
+                };
+            });
+            return result;
         },
+        outro: function () {
+            cache.compileDone();
+            if (options.check) {
+                cache.walkTree(function (id) {
+                    var snapshot = servicesHost.getScriptSnapshot(id);
+                    if (!snapshot) {
+                        context.error(colors.red("failed lo load snapshot for " + id));
+                        return;
+                    }
+                    var diagnostics = cache.getDiagnostics(id, snapshot, function () {
+                        return services
+                            .getCompilerOptionsDiagnostics()
+                            .concat(services.getSyntacticDiagnostics(id))
+                            .concat(services.getSemanticDiagnostics(id));
+                    });
+                    printDiagnostics(context, diagnostics);
+                });
+            }
+            cache.diagnosticsDone();
+        },
     };
@@ -145,0 +448,0 @@ }

dist/rollup-plugin-typescript2.es.js

 /* eslint-disable */
+import { emptyDirSync, ensureFile, ensureFileSync, existsSync, move, readFileSync, readJsonSync, readdirSync, remove, writeJson, writeJsonSync } from 'fs-extra';
+import * as fs from 'fs-extra';
 import { ModuleKind, ScriptSnapshot, createDocumentRegistry, createLanguageService, flattenDiagnosticMessageText, getDefaultLibFilePath, nodeModuleNameResolver, parseConfigFileTextToJson, parseJsonConfigFileContent, sys } from 'typescript';
 import * as ts from 'typescript';
-import { createFilter } from 'rollup-pluginutils';
-import { existsSync, readFileSync } from 'fs';
-import * as fs from 'fs';
+import { defaults, each, endsWith, filter, find, has, isEqual, map, some } from 'lodash';
+import * as _ from 'lodash';
+import { Graph, alg } from 'graphlib';
+import * as graph from 'graphlib';
+import { sha1 } from 'object-hash';
+import * as hash from 'object-hash';
 import { dirname, sep } from 'path';
 import * as path from 'path';
-import { endsWith, find } from 'lodash';
-import * as _ from 'lodash';
+import { red, yellow } from 'colors/safe';
+import * as colors from 'colors/safe';
 
-const __assign = Object.assign || function (target) {
-    for (var source, i = 1; i < arguments.length; i++) {
-        source = arguments[i];
-        for (var prop in source) {
-            if (Object.prototype.hasOwnProperty.call(source, prop)) {
-                target[prop] = source[prop];
-            }
-        }
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+
+var __assign = Object.assign || function __assign(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
     }
-    return target;
+    return t;
 };
 
+var VerbosityLevel;
+(function (VerbosityLevel) {
+    VerbosityLevel[VerbosityLevel["Error"] = 0] = "Error";
+    VerbosityLevel[VerbosityLevel["Warning"] = 1] = "Warning";
+    VerbosityLevel[VerbosityLevel["Info"] = 2] = "Info";
+    VerbosityLevel[VerbosityLevel["Debug"] = 3] = "Debug";
+})(VerbosityLevel || (VerbosityLevel = {}));
+var ConsoleContext = (function () {
+    function ConsoleContext(verbosity, prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.verbosity = verbosity;
+        this.prefix = prefix;
+    }
+    ConsoleContext.prototype.warn = function (message) {
+        if (this.verbosity < VerbosityLevel.Warning)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.error = function (message) {
+        if (this.verbosity < VerbosityLevel.Error)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.info = function (message) {
+        if (this.verbosity < VerbosityLevel.Info)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    ConsoleContext.prototype.debug = function (message) {
+        if (this.verbosity < VerbosityLevel.Debug)
+            return;
+        console.log("" + this.prefix + message);
+    };
+    return ConsoleContext;
+}());
+
+var LanguageServiceHost = (function () {
+    function LanguageServiceHost(parsedConfig) {
+        this.parsedConfig = parsedConfig;
+        this.cwd = process.cwd();
+        this.snapshots = {};
+    }
+    LanguageServiceHost.prototype.setSnapshot = function (fileName, data) {
+        var snapshot = ScriptSnapshot.fromString(data);
+        this.snapshots[fileName] = snapshot;
+        return snapshot;
+    };
+    LanguageServiceHost.prototype.getScriptSnapshot = function (fileName) {
+        if (has(this.snapshots, fileName))
+            return this.snapshots[fileName];
+        if (existsSync(fileName)) {
+            this.snapshots[fileName] = ScriptSnapshot.fromString(sys.readFile(fileName));
+            return this.snapshots[fileName];
+        }
+        return undefined;
+    };
+    LanguageServiceHost.prototype.getCurrentDirectory = function () {
+        return this.cwd;
+    };
+    LanguageServiceHost.prototype.getScriptVersion = function (_fileName) {
+        return "0";
+    };
+    LanguageServiceHost.prototype.getScriptFileNames = function () {
+        return this.parsedConfig.fileNames;
+    };
+    LanguageServiceHost.prototype.getCompilationSettings = function () {
+        return this.parsedConfig.options;
+    };
+    LanguageServiceHost.prototype.getDefaultLibFileName = function (opts) {
+        return getDefaultLibFilePath(opts);
+    };
+    return LanguageServiceHost;
+}());
+
+/**
+ * Saves data in new cache folder or reads it from old one.
+ * Avoids perpetually growing cache and situations when things need to consider changed and then reverted data to be changed.
+ */
+var RollingCache = (function () {
+    /**
+     * @param cacheRoot: root folder for the cache
+     * @param checkNewCache: whether to also look in new cache when reading from cache
+     */
+    function RollingCache(cacheRoot, checkNewCache) {
+        this.cacheRoot = cacheRoot;
+        this.checkNewCache = checkNewCache;
+        this.oldCacheRoot = this.cacheRoot + "/cache";
+        this.newCacheRoot = this.cacheRoot + "/cache_";
+        emptyDirSync(this.newCacheRoot);
+    }
+    /**
+     * @returns true if name exist in old cache (or either old of new cache if checkNewCache is true)
+     */
+    RollingCache.prototype.exists = function (name) {
+        if (this.checkNewCache && existsSync(this.newCacheRoot + "/" + name))
+            return true;
+        return existsSync(this.oldCacheRoot + "/" + name);
+    };
+    /**
+     * @returns true if old cache contains all names and nothing more
+     */
+    RollingCache.prototype.match = function (names) {
+        if (!existsSync(this.oldCacheRoot))
+            return names.length === 0; // empty folder matches
+        return isEqual(readdirSync(this.oldCacheRoot).sort(), names.sort());
+    };
+    /**
+     * @returns data for name, must exist in old cache (or either old of new cache if checkNewCache is true)
+     */
+    RollingCache.prototype.read = function (name) {
+        if (this.checkNewCache && existsSync(this.newCacheRoot + "/" + name))
+            return readJsonSync(this.newCacheRoot + "/" + name, "utf8");
+        return readJsonSync(this.oldCacheRoot + "/" + name, "utf8");
+    };
+    RollingCache.prototype.write = function (name, data) {
+        if (data === undefined)
+            return;
+        if (this.checkNewCache)
+            writeJsonSync(this.newCacheRoot + "/" + name, data);
+        else
+            writeJson(this.newCacheRoot + "/" + name, data, { encoding: "utf8" }, function () {  });
+    };
+    RollingCache.prototype.touch = function (name) {
+        if (this.checkNewCache)
+            ensureFileSync(this.newCacheRoot + "/" + name);
+        else
+            ensureFile(this.newCacheRoot + "/" + name, function () {  });
+    };
+    /**
+     * clears old cache and moves new in its place
+     */
+    RollingCache.prototype.roll = function () {
+        var _this = this;
+        remove(this.oldCacheRoot, function () {
+            move(_this.newCacheRoot, _this.oldCacheRoot, function () {  });
+        });
+    };
+    return RollingCache;
+}());
+
+var Cache = (function () {
+    function Cache(host, cache, options, rootFilenames, context) {
+        var _this = this;
+        this.host = host;
+        this.options = options;
+        this.context = context;
+        this.cacheVersion = "1";
+        this.ambientTypesDirty = false;
+        this.cacheDir = cache + "/" + sha1({ version: this.cacheVersion, rootFilenames: rootFilenames, options: this.options });
+        this.dependencyTree = new Graph({ directed: true });
+        this.dependencyTree.setDefaultNodeLabel(function (_node) { return { dirty: false }; });
+        this.ambientTypes = filter(rootFilenames, function (file) { return endsWith(file, ".d.ts"); })
+            .map(function (id) { return { id: id, snapshot: _this.host.getScriptSnapshot(id) }; });
+        this.init();
+    }
+    Cache.prototype.clean = function () {
+        this.context.info("cleaning cache: " + this.cacheDir);
+        emptyDirSync(this.cacheDir);
+        this.init();
+    };
+    Cache.prototype.walkTree = function (cb) {
+        var acyclic = alg.isAcyclic(this.dependencyTree);
+        if (acyclic) {
+            each(alg.topsort(this.dependencyTree), function (id) { return cb(id); });
+            return;
+        }
+        this.context.info("import tree has cycles");
+        each(this.dependencyTree.nodes(), function (id) { return cb(id); });
+    };
+    Cache.prototype.setDependency = function (importee, importer) {
+        // importee -> importer
+        this.context.debug(importee + " -> " + importer);
+        this.dependencyTree.setEdge(importer, importee);
+    };
+    Cache.prototype.compileDone = function () {
+        var _this = this;
+        var typeNames = filter(this.ambientTypes, function (snaphot) { return snaphot.snapshot !== undefined; })
+            .map(function (snaphot) { return _this.makeName(snaphot.id, snaphot.snapshot); });
+        // types dirty if any d.ts changed, added or removed
+        this.ambientTypesDirty = !this.typesCache.match(typeNames);
+        if (this.ambientTypesDirty)
+            this.context.info("ambient types changed, redoing all diagnostics");
+        each(typeNames, function (name) { return _this.typesCache.touch(name); });
+    };
+    Cache.prototype.diagnosticsDone = function () {
+        this.codeCache.roll();
+        this.diagnosticsCache.roll();
+        this.typesCache.roll();
+    };
+    Cache.prototype.getCompiled = function (id, snapshot, transform) {
+        var name = this.makeName(id, snapshot);
+        if (!this.codeCache.exists(name) || this.isDirty(id, snapshot, false)) {
+            this.context.debug("fresh transpile for: " + id);
+            var data_1 = transform();
+            this.codeCache.write(name, data_1);
+            this.markAsDirty(id, snapshot);
+            return data_1;
+        }
+        this.context.debug("old transpile for: " + id);
+        var data = this.codeCache.read(name);
+        this.codeCache.write(name, data);
+        return data;
+    };
+    Cache.prototype.getDiagnostics = function (id, snapshot, check) {
+        var name = this.makeName(id, snapshot);
+        if (!this.diagnosticsCache.exists(name) || this.isDirty(id, snapshot, true)) {
+            this.context.debug("fresh diagnostics for: " + id);
+            var data_2 = this.convert(check());
+            this.diagnosticsCache.write(name, data_2);
+            this.markAsDirty(id, snapshot);
+            return data_2;
+        }
+        this.context.debug("old diagnostics for: " + id);
+        var data = this.diagnosticsCache.read(name);
+        this.diagnosticsCache.write(name, data);
+        return data;
+    };
+    Cache.prototype.init = function () {
+        this.codeCache = new RollingCache(this.cacheDir + "/code", true);
+        this.typesCache = new RollingCache(this.cacheDir + "/types", false);
+        this.diagnosticsCache = new RollingCache(this.cacheDir + "/diagnostics", false);
+    };
+    Cache.prototype.markAsDirty = function (id, _snapshot) {
+        this.context.debug("changed: " + id);
+        this.dependencyTree.setNode(id, { dirty: true });
+    };
+    // returns true if node or any of its imports or any of global types changed
+    Cache.prototype.isDirty = function (id, _snapshot, checkImports) {
+        var _this = this;
+        var label = this.dependencyTree.node(id);
+        if (!label)
+            return false;
+        if (!checkImports || label.dirty)
+            return label.dirty;
+        if (this.ambientTypesDirty)
+            return true;
+        var dependencies = alg.dijkstra(this.dependencyTree, id);
+        return some(dependencies, function (dependency, node) {
+            if (!node || dependency.distance === Infinity)
+                return false;
+            var l = _this.dependencyTree.node(node);
+            var dirty = l === undefined ? true : l.dirty;
+            if (dirty)
+                _this.context.debug("import changed: " + id + " -> " + node);
+            return dirty;
+        });
+    };
+    Cache.prototype.makeName = function (id, snapshot) {
+        var data = snapshot.getText(0, snapshot.getLength());
+        return sha1({ data: data, id: id });
+    };
+    Cache.prototype.convert = function (data) {
+        return map(data, function (diagnostic) {
+            var entry = {
+                flatMessage: flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+            };
+            if (diagnostic.file) {
+                var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
+                entry.fileLine = diagnostic.file.fileName + " (" + (line + 1) + "," + (character + 1) + ")";
+            }
+            return entry;
+        });
+    };
+    return Cache;
+}());
+
+// tslint:disable-next-line:no-var-requires
+var createFilter = require("rollup-pluginutils").createFilter;
 function getOptionsOverrides() {
@@ -38,5 +325,4 @@ return {
     var fp = cwd ? (cwd + "/" + filename) : filename;
-    if (existsSync(fp)) {
+    if (existsSync(fp))
         return fp;
-    }
     var segs = cwd.split(sep);
@@ -47,5 +333,4 @@ var len = segs.length;
         fp = cwd + "/" + filename;
-        if (existsSync(fp)) {
+        if (existsSync(fp))
             return fp;
-        }
     }
@@ -68,2 +353,4 @@ return null;
     var fileName = findFile(process.cwd(), "tsconfig.json");
+    if (!fileName)
+        throw new Error("couldn't find 'tsconfig.json' in " + process.cwd());
     var text = sys.readFile(fileName);
@@ -75,10 +362,7 @@ var result = parseConfigFileTextToJson(fileName, text);
 function printDiagnostics(context, diagnostics) {
-    diagnostics.forEach(function (diagnostic) {
-        var message = flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-        if (diagnostic.file) {
-            var _a = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start), line = _a.line, character = _a.character;
-            context.warn({ message: diagnostic.file.fileName + " (" + (line + 1) + "," + (character + 1) + "): " + message });
-        }
+    each(diagnostics, function (diagnostic) {
+        if (diagnostic.fileLine)
+            context.warn(diagnostic.fileLine + ": " + yellow(diagnostic.flatMessage));
         else
-            context.warn({ message: message });
+            context.warn(yellow(diagnostic.flatMessage));
     });
@@ -89,19 +373,18 @@ }
     options = __assign({}, options);
-    var filter = createFilter(options.include || ["*.ts+(|x)", "**/*.ts+(|x)"], options.exclude || ["*.d.ts", "**/*.d.ts"]);
-    delete options.include;
-    delete options.exclude;
+    defaults(options, {
+        check: true,
+        verbosity: VerbosityLevel.Info,
+        clean: false,
+        cacheRoot: process.cwd() + "/.rts2_cache",
+        include: ["*.ts+(|x)", "**/*.ts+(|x)"],
+        exclude: ["*.d.ts", "**/*.d.ts"],
+    });
+    var filter$$1 = createFilter(options.include, options.exclude);
     var parsedConfig = parseTsConfig();
-    var servicesHost = {
-        getScriptFileNames: function () { return parsedConfig.fileNames; },
-        getScriptVersion: function (_fileName) { return "0"; },
-        getScriptSnapshot: function (fileName) {
-            if (!existsSync(fileName))
-                return undefined;
-            return ScriptSnapshot.fromString(sys.readFile(fileName));
-        },
-        getCurrentDirectory: function () { return process.cwd(); },
-        getCompilationSettings: function () { return parsedConfig.options; },
-        getDefaultLibFileName: function (opts) { return getDefaultLibFilePath(opts); },
-    };
+    var servicesHost = new LanguageServiceHost(parsedConfig);
     var services = createLanguageService(servicesHost, createDocumentRegistry());
+    var context = new ConsoleContext(options.verbosity, "rollup-plugin-typescript2: ");
+    var cache = new Cache(servicesHost, options.cacheRoot, parsedConfig.options, parsedConfig.fileNames, context);
+    if (options.clean)
+        cache.clean();
     return {
@@ -116,2 +399,4 @@ resolveId: function (importee, importer) {
             if (result.resolvedModule && result.resolvedModule.resolvedFileName) {
+                if (filter$$1(result.resolvedModule.resolvedFileName))
+                    cache.setDependency(result.resolvedModule.resolvedFileName, importer);
                 if (endsWith(result.resolvedModule.resolvedFileName, ".d.ts"))
@@ -126,21 +411,42 @@ return null;
                 return tslibSource;
+            return undefined;
         },
-        transform: function (_code, id) {
-            if (!filter(id))
-                return null;
-            var output = services.getEmitOutput(id);
-            var allDiagnostics = services
-                .getCompilerOptionsDiagnostics()
-                .concat(services.getSyntacticDiagnostics(id))
-                .concat(services.getSemanticDiagnostics(id));
-            printDiagnostics(this, allDiagnostics);
-            if (output.emitSkipped)
-                this.error({ message: "failed to transpile " + id });
-            var code = find(output.outputFiles, function (entry) { return endsWith(entry.name, ".js"); });
-            var map = find(output.outputFiles, function (entry) { return endsWith(entry.name, ".map"); });
-            return {
-                code: code ? code.text : undefined,
-                map: map ? JSON.parse(map.text) : { mappings: "" },
-            };
+        transform: function (code, id) {
+            var _this = this;
+            if (!filter$$1(id))
+                return undefined;
+            var snapshot = servicesHost.setSnapshot(id, code);
+            var result = cache.getCompiled(id, snapshot, function () {
+                var output = services.getEmitOutput(id);
+                if (output.emitSkipped)
+                    _this.error({ message: red("failed to transpile " + id) });
+                var transpiled = find(output.outputFiles, function (entry) { return endsWith(entry.name, ".js"); });
+                var map$$1 = find(output.outputFiles, function (entry) { return endsWith(entry.name, ".map"); });
+                return {
+                    code: transpiled ? transpiled.text : undefined,
+                    map: map$$1 ? JSON.parse(map$$1.text) : { mappings: "" },
+                };
+            });
+            return result;
         },
+        outro: function () {
+            cache.compileDone();
+            if (options.check) {
+                cache.walkTree(function (id) {
+                    var snapshot = servicesHost.getScriptSnapshot(id);
+                    if (!snapshot) {
+                        context.error(red("failed lo load snapshot for " + id));
+                        return;
+                    }
+                    var diagnostics = cache.getDiagnostics(id, snapshot, function () {
+                        return services
+                            .getCompilerOptionsDiagnostics()
+                            .concat(services.getSyntacticDiagnostics(id))
+                            .concat(services.getSemanticDiagnostics(id));
+                    });
+                    printDiagnostics(context, diagnostics);
+                });
+            }
+            cache.diagnosticsDone();
+        },
     };
@@ -147,0 +453,0 @@ }

package.json

 {
   "name": "rollup-plugin-typescript2",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Seamless integration between Rollup and TypeScript. Now with errors.",
@@ -23,7 +23,10 @@ "main": "dist/rollup-plugin-typescript2.cjs.js",
     "build": "rollup -c",
-    "lint": "tslint -c ./tslint.json src/*.ts",
-    "postinstall": "typings install"
+    "lint": "tslint -c ./tslint.json src/*.ts"
   },
   "dependencies": {
+    "colors": "^1.1.2",
+    "fs-extra": "^2.0.0",
+    "graphlib": "^2.1.1",
     "lodash": "^4.17.4",
+    "object-hash": "^1.1.5",
     "rollup-pluginutils": "^2.0.1",
@@ -33,8 +36,13 @@ "tslib": "^1.5.0"
   "peerDependencies": {
-    "typescript": "^2.0"
+    "typescript": "^2.0",
+    "tslib": "^1.5.0"
   },
   "devDependencies": {
-    "@alexlur/rollup-plugin-typescript": "^0.8.1",
+    "rollup-plugin-typescript2": "^0.0.1",
+    "@types/colors": "^1.1.1",
+    "@types/fs-extra": "0.0.37",
+    "@types/graphlib": "^2.1.3",
     "@types/lodash": "^4.14.52",
     "@types/node": "^6.0.53",
+    "@types/object-hash": "^0.5.28",
     "rimraf": "^2.5.4",
@@ -41,0 +49,0 @@ "rollup": "^0.41.4",

README.md

 # rollup-plugin-typescript2
+![npm-version](https://img.shields.io/npm/v/rollup-plugin-typescript2.svg?maxAge=2592000)
+![npm-dependencies](https://img.shields.io/david/ezolenko/rollup-plugin-typescript2.svg?maxAge=2592000)
 
@@ -7,3 +9,3 @@ Rollup plugin for typescript with compiler errors.
 
-This version is significantly slower than original, but it will print out typescript errors and warnings.
+This version is somewhat slower than original, but it will print out typescript syntactic and semantic diagnostic messages (the main reason for using typescript after all).
 
@@ -17,7 +19,7 @@ ## Usage
 export default {
-  entry: './main.ts',
+	entry: './main.ts',
 
-  plugins: [
-    typescript()
-  ]
+	plugins: [
+		typescript()
+	]
 }
@@ -35,5 +37,17 @@ ```
 
-Plugin itself takes standard include/exclude options (each a minimatch pattern, or array of minimatch patterns), which determine which files are transpiled by Typescript (all `.ts` and `.tsx` files by default)
+Plugin takes following options:
+* `check`: true
+	- set to false to avoid doing any diagnostic checks on the code
+* `verbosity`: 2
+	- goes up to 3
+* `clean`: false
+	- set to true for clean build (wipes out cache)
+* `cacheRoot`: ".rts2_cache"
+	- path to cache
+* `include`: `[ "*.ts+(|x)", "**/*.ts+(|x)" ]`
+	- passes all .ts files through typescript compiler. 
+* `exclude`: `[ "*.d.ts", "**/*.d.ts" ]`
+	- but not types
 
 ### TypeScript version
-This plugin currently requires TypeScript > 2.0.
+This plugin currently requires TypeScript 2.0+.

src/index.ts

@@ -0,8 +1,13 @@
+import { IContext, ConsoleContext, IRollupContext, VerbosityLevel } from "./context";
+import { LanguageServiceHost } from "./host";
+import { Cache, ICode, IDiagnostics } from "./cache";
 import * as ts from "typescript";
-import { createFilter } from "rollup-pluginutils";
-import * as fs from "fs";
+import * as fs from "fs-extra";
 import * as path from "path";
-import { existsSync } from "fs";
 import * as _ from "lodash";
+import * as colors from "colors/safe";
 
+// tslint:disable-next-line:no-var-requires
+const createFilter = require("rollup-pluginutils").createFilter;
+
 function getOptionsOverrides(): ts.CompilerOptions
@@ -26,6 +31,4 @@ {
 
-	if (existsSync(fp))
-	{
+	if (fs.existsSync(fp))
 		return fp;
-	}
 
@@ -39,6 +42,4 @@ const segs = cwd.split(path.sep);
 		fp = cwd + "/" + filename;
-		if (existsSync(fp))
-		{
+		if (fs.existsSync(fp))
 			return fp;
-		}
 	}
@@ -66,2 +67,5 @@
 	const fileName = findFile(process.cwd(), "tsconfig.json");
+	if (!fileName)
+		throw new Error(`couldn't find 'tsconfig.json' in ${process.cwd()}`);
+
 	const text = ts.sys.readFile(fileName);
@@ -74,54 +78,52 @@ const result = ts.parseConfigFileTextToJson(fileName, text);
 
-interface Message
+function printDiagnostics(context: IContext, diagnostics: IDiagnostics[])
 {
-	message: string;
-}
-interface Context
-{
-	warn(message: Message): void;
-	error(message: Message): void;
-}
-function printDiagnostics(context: Context, diagnostics: ts.Diagnostic[])
-{
-	diagnostics.forEach((diagnostic) =>
+	_.each(diagnostics, (diagnostic) =>
 	{
-		let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-		if (diagnostic.file)
-		{
-			let { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-			context.warn({ message: `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}` });
-		}
+		if (diagnostic.fileLine)
+			context.warn(`${diagnostic.fileLine}: ${colors.yellow(diagnostic.flatMessage)}`);
 		else
-			context.warn({ message });
+			context.warn(colors.yellow(diagnostic.flatMessage));
 	});
 };
 
-export default function typescript (options: any)
+interface IOptions
 {
+	include: string;
+	exclude: string;
+	check: boolean;
+	verbosity: number;
+	clean: boolean;
+	cacheRoot: string;
+}
+
+export default function typescript (options: IOptions)
+{
 	options = { ... options };
 
-	const filter = createFilter(options.include || [ "*.ts+(|x)", "**/*.ts+(|x)" ], options.exclude || [ "*.d.ts", "**/*.d.ts" ]);
+	_.defaults(options,
+	{
+		check: true,
+		verbosity: VerbosityLevel.Info,
+		clean: false,
+		cacheRoot: `${process.cwd()}/.rts2_cache`,
+		include: [ "*.ts+(|x)", "**/*.ts+(|x)" ],
+		exclude: [ "*.d.ts", "**/*.d.ts" ],
+	});
 
-	delete options.include;
-	delete options.exclude;
+	const filter = createFilter(options.include, options.exclude);
 
 	let parsedConfig = parseTsConfig();
 
-	const servicesHost: ts.LanguageServiceHost = {
-		getScriptFileNames: () => parsedConfig.fileNames,
-		getScriptVersion: (_fileName) => "0",
-		getScriptSnapshot: (fileName) =>
-		{
-			if (!fs.existsSync(fileName))
-				return undefined;
+	const servicesHost = new LanguageServiceHost(parsedConfig);
 
-			return ts.ScriptSnapshot.fromString(ts.sys.readFile(fileName));
-		},
-		getCurrentDirectory: () => process.cwd(),
-		getCompilationSettings: () => parsedConfig.options,
-		getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
-	};
-
 	const services = ts.createLanguageService(servicesHost, ts.createDocumentRegistry());
 
+	const context = new ConsoleContext(options.verbosity, "rollup-plugin-typescript2: ");
+
+	const cache = new Cache(servicesHost, options.cacheRoot, parsedConfig.options, parsedConfig.fileNames, context);
+
+	if (options.clean)
+		cache.clean();
+
 	return {
@@ -143,2 +145,5 @@
 			{
+				if (filter(result.resolvedModule.resolvedFileName))
+					cache.setDependency(result.resolvedModule.resolvedFileName, importer);
+
 				if (_.endsWith(result.resolvedModule.resolvedFileName, ".d.ts"))
@@ -153,33 +158,66 @@ return null;
 
-		load(id: string): any
+		load(id: string): string | undefined
 		{
 			if (id === "\0" + TSLIB)
 				return tslibSource;
+
+			return undefined;
 		},
 
-		transform(this: Context, _code: string, id: string): any
+		transform(this: IRollupContext, code: string, id: string): ICode | undefined
 		{
-			if (!filter(id)) return null;
+			if (!filter(id))
+				return undefined;
 
-			let output = services.getEmitOutput(id);
+			const snapshot = servicesHost.setSnapshot(id, code);
+			let result = cache.getCompiled(id, snapshot, () =>
+			{
+				const output = services.getEmitOutput(id);
 
-			let allDiagnostics = services
-				.getCompilerOptionsDiagnostics()
-				.concat(services.getSyntacticDiagnostics(id))
-				.concat(services.getSemanticDiagnostics(id));
+				if (output.emitSkipped)
+					this.error({ message: colors.red(`failed to transpile ${id}`)});
 
-			printDiagnostics(this, allDiagnostics);
+				const transpiled = _.find(output.outputFiles, (entry: ts.OutputFile) => _.endsWith(entry.name, ".js") );
+				const map = _.find(output.outputFiles, (entry: ts.OutputFile) => _.endsWith(entry.name, ".map") );
 
-			if (output.emitSkipped)
-				this.error({ message: `failed to transpile ${id}`});
+				return {
+					code: transpiled ? transpiled.text : undefined,
+					map: map ? JSON.parse(map.text) : { mappings: "" },
+				};
+			});
 
-			const code: ts.OutputFile = _.find(output.outputFiles, (entry: ts.OutputFile) => _.endsWith(entry.name, ".js") );
-			const map: ts.OutputFile = _.find(output.outputFiles, (entry: ts.OutputFile) => _.endsWith(entry.name, ".map") );
+			return result;
+		},
 
-			return {
-				code: code ? code.text : undefined,
-				map: map ? JSON.parse(map.text) : { mappings: "" },
-			};
+		outro(): void
+		{
+			cache.compileDone();
+
+			if (options.check)
+			{
+				cache.walkTree((id: string) =>
+				{
+					const snapshot = servicesHost.getScriptSnapshot(id);
+
+					if (!snapshot)
+					{
+						context.error(colors.red(`failed lo load snapshot for ${id}`));
+						return;
+					}
+
+					const diagnostics = cache.getDiagnostics(id, snapshot, () =>
+					{
+						return services
+							.getCompilerOptionsDiagnostics()
+							.concat(services.getSyntacticDiagnostics(id))
+							.concat(services.getSemanticDiagnostics(id));
+					});
+
+					printDiagnostics(context, diagnostics);
+				});
+			}
+
+			cache.diagnosticsDone();
 		},
 	};
 }

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

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Mixed license

License

(Experimental) Package contains multiple licenses.

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

Install scripts

Supply chain risk

Install scripts are run when the package is installed. The majority of malware in npm is hidden in install scripts.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

57669

increased by200.81%

Number of package files

10

increased by66.67%

Lines of code

1384

increased by230.31%

Number of lines in readme file

51

increased by37.84%

Number of high supply chain risk alerts

0

decreased by-100%

Worsened metrics

Dependency count

9

increased by125%

Dev dependency count

11

increased by57.14%

Number of low license alerts

1

increased byInfinity%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedcolors@^1.1.2

• + Addedfs-extra@^2.0.0

• + Addedgraphlib@^2.1.1

• + Addedobject-hash@^1.1.5

• + Addedcolors@1.4.0(transitive)

• + Addedfs-extra@2.1.2(transitive)

• + Addedgraceful-fs@4.2.11(transitive)

• + Addedgraphlib@2.1.8(transitive)

• + Addedjsonfile@2.4.0(transitive)

• + Addedobject-hash@1.3.1(transitive)