From cd549b8aaf7ad739e0c82963ccb1f331bc8a165d Mon Sep 17 00:00:00 2001 From: Phil Kunz Date: Sun, 1 Jul 2018 17:30:05 +0200 Subject: [PATCH] fix(ts-node): patch error --- LICENSE | 22 ++ dist/index.js | 6 +- dist/tsnode.d.ts | 99 ++++++++ dist/tsnode.js | 440 +++++++++++++++++++++++++++++++++ package-lock.json | 32 +-- package.json | 8 +- ts/index.ts | 4 +- ts/tsnode.ts | 613 ++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 1188 insertions(+), 36 deletions(-) create mode 100644 LICENSE create mode 100644 dist/tsnode.d.ts create mode 100644 dist/tsnode.js create mode 100644 ts/tsnode.ts diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..2f6d6c8 --- /dev/null +++ b/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2018 Lossless GmbH (hello@lossless.com) +Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/dist/index.js b/dist/index.js index 836c5c0..0e0a0ca 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,12 +1,12 @@ "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const tsNode = require("ts-node"); const path = require("path"); +const tsNode = require("./tsnode"); tsNode.register({ compilerOptions: { lib: ['es2016', 'es2017'] }, - ignore: ['^(.(.*\.d\.ts))*$'], + skipIgnore: true, cacheDirectory: path.join(__dirname, '../tscache') }); if (process.env.CLI_CALL_TSRUN) { @@ -17,4 +17,4 @@ if (process.env.CLI_CALL_TSRUN) { const pathToLoad = path.join(process.cwd(), pathToTsFile); Promise.resolve().then(() => require(pathToLoad)); } -//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGtDQUFrQztBQUNsQyw2QkFBNkI7QUFFN0IsTUFBTSxDQUFDLFFBQVEsQ0FBQztJQUNkLGVBQWUsRUFBRTtRQUNmLEdBQUcsRUFBRSxDQUFFLFFBQVEsRUFBRSxRQUFRLENBQUU7S0FDNUI7SUFDRCxNQUFNLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztJQUM3QixjQUFjLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsWUFBWSxDQUFDO0NBQ25ELENBQUMsQ0FBQztBQUVILElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLEVBQUU7SUFDOUIseUJBQXlCO0lBQ3pCLHFDQUFxQztJQUNyQyxzQ0FBc0M7SUFDdEMsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUVwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxZQUFZLENBQUMsQ0FBQztJQUMxRCxxQ0FBTyxVQUFVLEdBQUU7Q0FDcEIifQ== \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLDZCQUE2QjtBQUM3QixtQ0FBbUM7QUFFbkMsTUFBTSxDQUFDLFFBQVEsQ0FBQztJQUNkLGVBQWUsRUFBRTtRQUNmLEdBQUcsRUFBRSxDQUFFLFFBQVEsRUFBRSxRQUFRLENBQUU7S0FDNUI7SUFDRCxVQUFVLEVBQUUsSUFBSTtJQUNoQixjQUFjLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsWUFBWSxDQUFDO0NBQ25ELENBQUMsQ0FBQztBQUVILElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLEVBQUU7SUFDOUIseUJBQXlCO0lBQ3pCLHFDQUFxQztJQUNyQyxzQ0FBc0M7SUFDdEMsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUVwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxZQUFZLENBQUMsQ0FBQztJQUMxRCxxQ0FBTyxVQUFVLEdBQUU7Q0FDcEIifQ== \ No newline at end of file diff --git a/dist/tsnode.d.ts b/dist/tsnode.d.ts new file mode 100644 index 0000000..0afc68e --- /dev/null +++ b/dist/tsnode.d.ts @@ -0,0 +1,99 @@ +import { BaseError } from 'make-error'; +import * as _ts from 'typescript'; +/** + * @internal + */ +export declare const INSPECT_CUSTOM: string | symbol; +/** + * Common TypeScript interfaces between versions. + */ +export interface TSCommon { + version: typeof _ts.version; + sys: typeof _ts.sys; + ScriptSnapshot: typeof _ts.ScriptSnapshot; + displayPartsToString: typeof _ts.displayPartsToString; + createLanguageService: typeof _ts.createLanguageService; + getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath; + getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics; + flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText; + transpileModule: typeof _ts.transpileModule; + ModuleKind: typeof _ts.ModuleKind; + ScriptTarget: typeof _ts.ScriptTarget; + findConfigFile: typeof _ts.findConfigFile; + readConfigFile: typeof _ts.readConfigFile; + parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent; + formatDiagnostics: typeof _ts.formatDiagnostics; + formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext; +} +/** + * Export the current version. + */ +export declare const VERSION: any; +/** + * Registration options. + */ +export interface Options { + pretty?: boolean | null; + typeCheck?: boolean | null; + transpileOnly?: boolean | null; + files?: boolean | null; + cache?: boolean | null; + cacheDirectory?: string; + compiler?: string; + ignore?: string | string[]; + project?: string; + skipIgnore?: boolean | null; + skipProject?: boolean | null; + compilerOptions?: object; + ignoreDiagnostics?: number | string | Array; + readFile?: (path: string) => string | undefined; + fileExists?: (path: string) => boolean; + transformers?: _ts.CustomTransformers; +} +/** + * Information retrieved from type info check. + */ +export interface TypeInfo { + name: string; + comment: string; +} +/** + * Default register options. + */ +export declare const DEFAULTS: Options; +/** + * Split a string array of values. + */ +export declare function split(value: string | undefined): string[]; +/** + * Parse a string as JSON. + */ +export declare function parse(value: string | undefined): object | undefined; +/** + * Replace backslashes with forward slashes. + */ +export declare function normalizeSlashes(value: string): string; +/** + * TypeScript diagnostics error. + */ +export declare class TSError extends BaseError { + diagnosticText: string; + diagnosticCodes: number[]; + name: string; + constructor(diagnosticText: string, diagnosticCodes: number[]); +} +/** + * Return type for registering `ts-node`. + */ +export interface Register { + cwd: string; + extensions: string[]; + cachedir: string; + ts: TSCommon; + compile(code: string, fileName: string, lineOffset?: number): string; + getTypeInfo(code: string, fileName: string, position: number): TypeInfo; +} +/** + * Register TypeScript compiler. + */ +export declare function register(opts?: Options): Register; diff --git a/dist/tsnode.js b/dist/tsnode.js new file mode 100644 index 0000000..b749533 --- /dev/null +++ b/dist/tsnode.js @@ -0,0 +1,440 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const path_1 = require("path"); +const fs_1 = require("fs"); +const os_1 = require("os"); +const sourceMapSupport = require("source-map-support"); +const mkdirp = require("mkdirp"); +const crypto = require("crypto"); +const yn = require("yn"); +const arrify = require("arrify"); +const bufferFrom = require("buffer-from"); +const make_error_1 = require("make-error"); +const util = require("util"); +/** + * @internal + */ +exports.INSPECT_CUSTOM = util.inspect.custom || 'inspect'; +/** + * Debugging `ts-node`. + */ +const shouldDebug = yn(process.env.TS_NODE_DEBUG); +const debug = shouldDebug ? console.log.bind(console, 'ts-node') : () => undefined; +const debugFn = shouldDebug ? + (key, fn) => { + return (x) => { + debug(key, x); + return fn(x); + }; + } : + (_, fn) => fn; +/** + * Export the current version. + */ +exports.VERSION = require('../package.json').version; +/** + * Default register options. + */ +exports.DEFAULTS = { + files: yn(process.env['TS_NODE_FILES']), + cache: yn(process.env['TS_NODE_CACHE'], { default: true }), + pretty: yn(process.env['TS_NODE_PRETTY']), + cacheDirectory: process.env['TS_NODE_CACHE_DIRECTORY'], + compiler: process.env['TS_NODE_COMPILER'], + compilerOptions: parse(process.env['TS_NODE_COMPILER_OPTIONS']), + ignore: split(process.env['TS_NODE_IGNORE']), + project: process.env['TS_NODE_PROJECT'], + skipIgnore: yn(process.env['TS_NODE_SKIP_IGNORE']), + skipProject: yn(process.env['TS_NODE_SKIP_PROJECT']), + ignoreDiagnostics: split(process.env['TS_NODE_IGNORE_DIAGNOSTICS']), + typeCheck: yn(process.env['TS_NODE_TYPE_CHECK']), + transpileOnly: yn(process.env['TS_NODE_TRANSPILE_ONLY']) +}; +/** + * Default TypeScript compiler options required by `ts-node`. + */ +const DEFAULT_COMPILER_OPTIONS = { + sourceMap: true, + inlineSourceMap: false, + inlineSources: true, + declaration: false, + noEmit: false, + outDir: '$$ts-node$$' +}; +/** + * Split a string array of values. + */ +function split(value) { + return typeof value === 'string' ? value.split(/ *, */g) : undefined; +} +exports.split = split; +/** + * Parse a string as JSON. + */ +function parse(value) { + return typeof value === 'string' ? JSON.parse(value) : undefined; +} +exports.parse = parse; +/** + * Replace backslashes with forward slashes. + */ +function normalizeSlashes(value) { + return value.replace(/\\/g, '/'); +} +exports.normalizeSlashes = normalizeSlashes; +/** + * TypeScript diagnostics error. + */ +class TSError extends make_error_1.BaseError { + constructor(diagnosticText, diagnosticCodes) { + super(`⨯ Unable to compile TypeScript:\n${diagnosticText}`); + this.diagnosticText = diagnosticText; + this.diagnosticCodes = diagnosticCodes; + this.name = 'TSError'; + } + /** + * @internal + */ + [exports.INSPECT_CUSTOM]() { + return this.diagnosticText; + } +} +exports.TSError = TSError; +/** + * Return a default temp directory based on home directory of user. + */ +function getTmpDir() { + const hash = crypto.createHash('sha256').update(os_1.homedir(), 'utf8').digest('hex'); + return path_1.join(os_1.tmpdir(), `ts-node-${hash}`); +} +/** + * Register TypeScript compiler. + */ +function register(opts = {}) { + const options = Object.assign({}, exports.DEFAULTS, opts); + const cacheDirectory = options.cacheDirectory || getTmpDir(); + const originalJsHandler = require.extensions['.js']; + const ignoreDiagnostics = arrify(options.ignoreDiagnostics).concat([ + 6059, + 18002, + 18003 // "No inputs were found in config file." + ]).map(Number); + const memoryCache = { + contents: Object.create(null), + versions: Object.create(null), + outputs: Object.create(null) + }; + const ignore = options.skipIgnore ? [] : arrify(options.ignore || '/node_modules/').map(str => new RegExp(str)); + // Install source map support and read from memory cache. + sourceMapSupport.install({ + environment: 'node', + retrieveFile(path) { + return memoryCache.outputs[path]; + } + }); + // Require the TypeScript compiler and configuration. + const cwd = process.cwd(); + const { compilerOptions, project, skipProject } = options; + const compiler = options.compiler || 'typescript'; + const typeCheck = options.typeCheck === true || options.transpileOnly !== true; + const ts = require(compiler); + const transformers = options.transformers || undefined; + const readFile = options.readFile || ts.sys.readFile; + const fileExists = options.fileExists || ts.sys.fileExists; + const config = readConfig(cwd, ts, fileExists, readFile, compilerOptions, project, skipProject); + const configDiagnosticList = filterDiagnostics(config.errors, ignoreDiagnostics); + const extensions = ['.ts', '.tsx']; + const fileNames = options.files ? config.fileNames : []; + const cachedir = path_1.join(path_1.resolve(cwd, cacheDirectory), getCompilerDigest({ + version: ts.version, + options: config.options, + fileNames, + typeCheck, + ignoreDiagnostics, + compiler + })); + const diagnosticHost = { + getNewLine: () => os_1.EOL, + getCurrentDirectory: () => cwd, + getCanonicalFileName: (path) => path + }; + const formatDiagnostics = options.pretty + ? ts.formatDiagnosticsWithColorAndContext + : ts.formatDiagnostics; + function createTSError(diagnostics) { + const diagnosticText = formatDiagnostics(diagnostics, diagnosticHost); + const diagnosticCodes = diagnostics.map(x => x.code); + return new TSError(diagnosticText, diagnosticCodes); + } + // Render the configuration errors and exit the script. + if (configDiagnosticList.length) + throw createTSError(configDiagnosticList); + // Enable `allowJs` when flag is set. + if (config.options.allowJs) { + extensions.push('.js'); + extensions.push('.jsx'); + } + // Initialize files from TypeScript into project. + for (const path of fileNames) + memoryCache.versions[path] = 1; + /** + * Get the extension for a transpiled file. + */ + const getExtension = config.options.jsx === ts.JsxEmit.Preserve ? + ((path) => /\.[tj]sx$/.test(path) ? '.jsx' : '.js') : + ((_) => '.js'); + /** + * Create the basic required function using transpile mode. + */ + let getOutput = function (code, fileName, lineOffset = 0) { + const result = ts.transpileModule(code, { + fileName, + transformers, + compilerOptions: config.options, + reportDiagnostics: true + }); + const diagnosticList = result.diagnostics ? + filterDiagnostics(result.diagnostics, ignoreDiagnostics) : + []; + if (diagnosticList.length) + throw createTSError(diagnosticList); + return [result.outputText, result.sourceMapText]; + }; + let getTypeInfo = function (_code, _fileName, _position) { + throw new TypeError(`Type information is unavailable without "--type-check"`); + }; + // Use full language services when the fast option is disabled. + if (typeCheck) { + // Set the file contents into cache. + const updateMemoryCache = function (code, fileName) { + if (memoryCache.contents[fileName] !== code) { + memoryCache.contents[fileName] = code; + memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1; + } + }; + // Create the compiler host for type checking. + const serviceHost = { + getScriptFileNames: () => Object.keys(memoryCache.versions), + getScriptVersion: (fileName) => { + const version = memoryCache.versions[fileName]; + // We need to return `undefined` and not a string here because TypeScript will use + // `getScriptVersion` and compare against their own version - which can be `undefined`. + // If we don't return `undefined` it results in `undefined === "undefined"` and run + // `createProgram` again (which is very slow). Using a `string` assertion here to avoid + // TypeScript errors from the function signature (expects `(x: string) => string`). + return version === undefined ? undefined : String(version); + }, + getScriptSnapshot(fileName) { + // Read contents into TypeScript memory cache. + if (!Object.prototype.hasOwnProperty.call(memoryCache.contents, fileName)) { + memoryCache.contents[fileName] = readFile(fileName); + } + const contents = memoryCache.contents[fileName]; + if (contents === undefined) + return; + return ts.ScriptSnapshot.fromString(contents); + }, + fileExists: debugFn('fileExists', fileExists), + readFile: debugFn('readFile', readFile), + readDirectory: debugFn('readDirectory', ts.sys.readDirectory), + getDirectories: debugFn('getDirectories', ts.sys.getDirectories), + directoryExists: debugFn('directoryExists', ts.sys.directoryExists), + getNewLine: () => os_1.EOL, + getCurrentDirectory: () => cwd, + getCompilationSettings: () => config.options, + getDefaultLibFileName: () => ts.getDefaultLibFilePath(config.options), + getCustomTransformers: () => transformers + }; + const service = ts.createLanguageService(serviceHost); + getOutput = function (code, fileName, lineOffset = 0) { + // Must set memory cache before attempting to read file. + updateMemoryCache(code, fileName); + const output = service.getEmitOutput(fileName); + // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`. + const diagnostics = service.getCompilerOptionsDiagnostics() + .concat(service.getSyntacticDiagnostics(fileName)) + .concat(service.getSemanticDiagnostics(fileName)); + const diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics); + if (diagnosticList.length) + throw createTSError(diagnosticList); + if (output.emitSkipped) { + throw new TypeError(`${path_1.relative(cwd, fileName)}: Emit skipped`); + } + // Throw an error when requiring `.d.ts` files. + if (output.outputFiles.length === 0) { + return ['', '']; + } + return ['', '']; + return [output.outputFiles[1].text, output.outputFiles[0].text]; + }; + getTypeInfo = function (code, fileName, position) { + updateMemoryCache(code, fileName); + const info = service.getQuickInfoAtPosition(fileName, position); + const name = ts.displayPartsToString(info ? info.displayParts : []); + const comment = ts.displayPartsToString(info ? info.documentation : []); + return { name, comment }; + }; + } + const compile = readThrough(cachedir, options.cache === true, memoryCache, getOutput, getExtension); + const register = { cwd, compile, getTypeInfo, extensions, cachedir, ts }; + // Register the extensions. + extensions.forEach(extension => { + registerExtension(extension, ignore, register, originalJsHandler); + }); + return register; +} +exports.register = register; +/** + * Check if the filename should be ignored. + */ +function shouldIgnore(filename, ignore) { + const relname = normalizeSlashes(filename); + return ignore.some(x => x.test(relname)); +} +/** + * Register the extension for node. + */ +function registerExtension(ext, ignore, register, originalHandler) { + const old = require.extensions[ext] || originalHandler; + require.extensions[ext] = function (m, filename) { + if (shouldIgnore(filename, ignore)) { + return old(m, filename); + } + const _compile = m._compile; + m._compile = function (code, fileName) { + debug('module._compile', fileName); + return _compile.call(this, register.compile(code, fileName), fileName); + }; + return old(m, filename); + }; +} +/** + * Do post-processing on config options to support `ts-node`. + */ +function fixConfig(ts, config) { + // Delete options that *should not* be passed through. + delete config.options.out; + delete config.options.outFile; + delete config.options.declarationDir; + delete config.options.declarationMap; + delete config.options.emitDeclarationOnly; + // Target ES5 output by default (instead of ES3). + if (config.options.target === undefined) { + config.options.target = ts.ScriptTarget.ES5; + } + // Target CommonJS modules by default (instead of magically switching to ES6 when the target is ES6). + if (config.options.module === undefined) { + config.options.module = ts.ModuleKind.CommonJS; + } + return config; +} +/** + * Load TypeScript configuration. + */ +function readConfig(cwd, ts, fileExists, readFile, compilerOptions, project, noProject) { + let config = { compilerOptions: {} }; + let basePath = normalizeSlashes(cwd); + let configFileName = undefined; + // Read project configuration when available. + if (!noProject) { + configFileName = project + ? normalizeSlashes(path_1.resolve(cwd, project)) + : ts.findConfigFile(normalizeSlashes(cwd), fileExists); + if (configFileName) { + const result = ts.readConfigFile(configFileName, readFile); + // Return diagnostics. + if (result.error) { + return { errors: [result.error], fileNames: [], options: {} }; + } + config = result.config; + basePath = normalizeSlashes(path_1.dirname(configFileName)); + } + } + // Override default configuration options `ts-node` requires. + config.compilerOptions = Object.assign({}, config.compilerOptions, compilerOptions, DEFAULT_COMPILER_OPTIONS); + return fixConfig(ts, ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName)); +} +/** + * Wrap the function with caching. + */ +function readThrough(cachedir, shouldCache, memoryCache, compile, getExtension) { + if (shouldCache === false) { + return function (code, fileName, lineOffset) { + debug('readThrough', fileName); + const [value, sourceMap] = compile(code, fileName, lineOffset); + const output = updateOutput(value, fileName, sourceMap, getExtension); + memoryCache.outputs[fileName] = output; + return output; + }; + } + // Make sure the cache directory exists before continuing. + mkdirp.sync(cachedir); + return function (code, fileName, lineOffset) { + debug('readThrough', fileName); + const cachePath = path_1.join(cachedir, getCacheName(code, fileName)); + const extension = getExtension(fileName); + const outputPath = `${cachePath}${extension}`; + try { + const output = fs_1.readFileSync(outputPath, 'utf8'); + if (isValidCacheContent(output)) { + memoryCache.outputs[fileName] = output; + return output; + } + } + catch (err) { /* Ignore. */ } + const [value, sourceMap] = compile(code, fileName, lineOffset); + const output = updateOutput(value, fileName, sourceMap, getExtension); + memoryCache.outputs[fileName] = output; + fs_1.writeFileSync(outputPath, output); + return output; + }; +} +/** + * Update the output remapping the source map. + */ +function updateOutput(outputText, fileName, sourceMap, getExtension) { + const base64Map = bufferFrom(updateSourceMap(sourceMap, fileName), 'utf8').toString('base64'); + const sourceMapContent = `data:application/json;charset=utf-8;base64,${base64Map}`; + const sourceMapLength = `${path_1.basename(fileName)}.map`.length + (getExtension(fileName).length - path_1.extname(fileName).length); + return outputText.slice(0, -sourceMapLength) + sourceMapContent; +} +/** + * Update the source map contents for improved output. + */ +function updateSourceMap(sourceMapText, fileName) { + const sourceMap = JSON.parse(sourceMapText); + sourceMap.file = fileName; + sourceMap.sources = [fileName]; + delete sourceMap.sourceRoot; + return JSON.stringify(sourceMap); +} +/** + * Get the file name for the cache entry. + */ +function getCacheName(sourceCode, fileName) { + return crypto.createHash('sha256') + .update(path_1.extname(fileName), 'utf8') + .update('\x00', 'utf8') + .update(sourceCode, 'utf8') + .digest('hex'); +} +/** + * Ensure the given cached content is valid by sniffing for a base64 encoded '}' + * at the end of the content, which should exist if there is a valid sourceMap present. + */ +function isValidCacheContent(contents) { + return /(?:9|0=|Q==)$/.test(contents.slice(-3)); +} +/** + * Create a hash of the current configuration. + */ +function getCompilerDigest(obj) { + return crypto.createHash('sha256').update(JSON.stringify(obj), 'utf8').digest('hex'); +} +/** + * Filter diagnostics. + */ +function filterDiagnostics(diagnostics, ignore) { + return diagnostics.filter(x => ignore.indexOf(x.code) === -1); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tsnode.js","sourceRoot":"","sources":["../ts/tsnode.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 1e77e03..3aa275a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -101,11 +101,6 @@ "object-keys": "^1.0.8" } }, - "diff": { - "version": "3.5.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", - "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==" - }, "es-abstract": { "version": "1.12.0", "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz", @@ -278,9 +273,9 @@ } }, "minimist": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" }, "mkdirp": { "version": "0.5.1", @@ -288,13 +283,6 @@ "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", "requires": { "minimist": "0.0.8" - }, - "dependencies": { - "minimist": { - "version": "0.0.8", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", - "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" - } } }, "object-keys": { @@ -467,20 +455,6 @@ "strip-bom": "^2.0.0" } }, - "ts-node": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-6.1.0.tgz", - "integrity": "sha512-mw11Bq08RZgrU/bzcVw/Ti9wNyefpOanXgWsHg008wyVHjvFhWxNatVVrciOAu8BcWSECoNOSunRzUokKH8Mmw==", - "requires": { - "arrify": "^1.0.0", - "diff": "^3.1.0", - "make-error": "^1.1.1", - "minimist": "^1.2.0", - "mkdirp": "^0.5.1", - "source-map-support": "^0.5.6", - "yn": "^2.0.0" - } - }, "typescript": { "version": "2.9.1", "resolved": "https://registry.npmjs.org/typescript/-/typescript-2.9.1.tgz", diff --git a/package.json b/package.json index d576dfe..ab5c956 100644 --- a/package.json +++ b/package.json @@ -19,9 +19,13 @@ "@types/node": "^10.3.0" }, "dependencies": { + "arrify": "^1.0.1", + "make-error": "^1.3.4", + "mkdirp": "^0.5.1", "smartfile": "^4.2.28", - "ts-node": "^6.1.0", - "typescript": "^2.9.1" + "source-map-support": "^0.5.6", + "typescript": "^2.9.1", + "yn": "^2.0.0" }, "private": false } diff --git a/ts/index.ts b/ts/index.ts index 618b828..36301bc 100644 --- a/ts/index.ts +++ b/ts/index.ts @@ -1,11 +1,11 @@ -import * as tsNode from 'ts-node'; import * as path from 'path'; +import * as tsNode from './tsnode'; tsNode.register({ compilerOptions: { lib: [ 'es2016', 'es2017' ] }, - ignore: ['^(.(.*\.d\.ts))*$'], + skipIgnore: true, cacheDirectory: path.join(__dirname, '../tscache') }); diff --git a/ts/tsnode.ts b/ts/tsnode.ts new file mode 100644 index 0000000..2f412eb --- /dev/null +++ b/ts/tsnode.ts @@ -0,0 +1,613 @@ +import { relative, basename, extname, resolve, dirname, join } from 'path' +import { readFileSync, writeFileSync } from 'fs' +import { EOL, tmpdir, homedir } from 'os' +import sourceMapSupport = require('source-map-support') +import mkdirp = require('mkdirp') +import crypto = require('crypto') +import yn = require('yn') +import arrify = require('arrify') +import bufferFrom = require('buffer-from') +import { BaseError } from 'make-error' +import * as util from 'util' +import * as _ts from 'typescript' + +/** + * @internal + */ +export const INSPECT_CUSTOM = util.inspect.custom || 'inspect' + +/** + * Debugging `ts-node`. + */ +const shouldDebug = yn(process.env.TS_NODE_DEBUG) +const debug = shouldDebug ? console.log.bind(console, 'ts-node') : () => undefined +const debugFn = shouldDebug ? + (key: string, fn: (arg: T) => U) => { + return (x: T) => { + debug(key, x) + return fn(x) + } + } : + (_: string, fn: (arg: T) => U) => fn + +/** + * Common TypeScript interfaces between versions. + */ +export interface TSCommon { + version: typeof _ts.version + sys: typeof _ts.sys + ScriptSnapshot: typeof _ts.ScriptSnapshot + displayPartsToString: typeof _ts.displayPartsToString + createLanguageService: typeof _ts.createLanguageService + getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath + getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics + flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText + transpileModule: typeof _ts.transpileModule + ModuleKind: typeof _ts.ModuleKind + ScriptTarget: typeof _ts.ScriptTarget + findConfigFile: typeof _ts.findConfigFile + readConfigFile: typeof _ts.readConfigFile + parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent + formatDiagnostics: typeof _ts.formatDiagnostics + formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext +} + +/** + * Export the current version. + */ +export const VERSION = require('../package.json').version + +/** + * Registration options. + */ +export interface Options { + pretty?: boolean | null + typeCheck?: boolean | null + transpileOnly?: boolean | null + files?: boolean | null + cache?: boolean | null + cacheDirectory?: string + compiler?: string + ignore?: string | string[] + project?: string + skipIgnore?: boolean | null + skipProject?: boolean | null + compilerOptions?: object + ignoreDiagnostics?: number | string | Array + readFile?: (path: string) => string | undefined + fileExists?: (path: string) => boolean + transformers?: _ts.CustomTransformers +} + +/** + * Track the project information. + */ +interface MemoryCache { + contents: { [path: string]: string | undefined } + versions: { [path: string]: number | undefined } + outputs: { [path: string]: string } +} + +/** + * Information retrieved from type info check. + */ +export interface TypeInfo { + name: string + comment: string +} + +/** + * Default register options. + */ +export const DEFAULTS: Options = { + files: yn(process.env['TS_NODE_FILES']), + cache: yn(process.env['TS_NODE_CACHE'], { default: true }), + pretty: yn(process.env['TS_NODE_PRETTY']), + cacheDirectory: process.env['TS_NODE_CACHE_DIRECTORY'], + compiler: process.env['TS_NODE_COMPILER'], + compilerOptions: parse(process.env['TS_NODE_COMPILER_OPTIONS']), + ignore: split(process.env['TS_NODE_IGNORE']), + project: process.env['TS_NODE_PROJECT'], + skipIgnore: yn(process.env['TS_NODE_SKIP_IGNORE']), + skipProject: yn(process.env['TS_NODE_SKIP_PROJECT']), + ignoreDiagnostics: split(process.env['TS_NODE_IGNORE_DIAGNOSTICS']), + typeCheck: yn(process.env['TS_NODE_TYPE_CHECK']), + transpileOnly: yn(process.env['TS_NODE_TRANSPILE_ONLY']) +} + +/** + * Default TypeScript compiler options required by `ts-node`. + */ +const DEFAULT_COMPILER_OPTIONS = { + sourceMap: true, + inlineSourceMap: false, + inlineSources: true, + declaration: false, + noEmit: false, + outDir: '$$ts-node$$' +} + +/** + * Split a string array of values. + */ +export function split (value: string | undefined) { + return typeof value === 'string' ? value.split(/ *, */g) : undefined +} + +/** + * Parse a string as JSON. + */ +export function parse (value: string | undefined): object | undefined { + return typeof value === 'string' ? JSON.parse(value) : undefined +} + +/** + * Replace backslashes with forward slashes. + */ +export function normalizeSlashes (value: string): string { + return value.replace(/\\/g, '/') +} + +/** + * TypeScript diagnostics error. + */ +export class TSError extends BaseError { + name = 'TSError' + + constructor (public diagnosticText: string, public diagnosticCodes: number[]) { + super(`⨯ Unable to compile TypeScript:\n${diagnosticText}`) + } + + /** + * @internal + */ + [INSPECT_CUSTOM] () { + return this.diagnosticText + } +} + +/** + * Return type for registering `ts-node`. + */ +export interface Register { + cwd: string + extensions: string[] + cachedir: string + ts: TSCommon + compile (code: string, fileName: string, lineOffset?: number): string + getTypeInfo (code: string, fileName: string, position: number): TypeInfo +} + +/** + * Return a default temp directory based on home directory of user. + */ +function getTmpDir (): string { + const hash = crypto.createHash('sha256').update(homedir(), 'utf8').digest('hex') + + return join(tmpdir(), `ts-node-${hash}`) +} + +/** + * Register TypeScript compiler. + */ +export function register (opts: Options = {}): Register { + const options = Object.assign({}, DEFAULTS, opts) + const cacheDirectory = options.cacheDirectory || getTmpDir() + const originalJsHandler = require.extensions['.js'] + + const ignoreDiagnostics = arrify(options.ignoreDiagnostics).concat([ + 6059, // "'rootDir' is expected to contain all source files." + 18002, // "The 'files' list in config file is empty." + 18003 // "No inputs were found in config file." + ]).map(Number) + + const memoryCache: MemoryCache = { + contents: Object.create(null), + versions: Object.create(null), + outputs: Object.create(null) + } + + const ignore = options.skipIgnore ? [] : arrify( + options.ignore || '/node_modules/' + ).map(str => new RegExp(str)) + + // Install source map support and read from memory cache. + sourceMapSupport.install({ + environment: 'node', + retrieveFile (path: string) { + return memoryCache.outputs[path] + } + }) + + // Require the TypeScript compiler and configuration. + const cwd = process.cwd() + const { compilerOptions, project, skipProject } = options + const compiler = options.compiler || 'typescript' + const typeCheck = options.typeCheck === true || options.transpileOnly !== true + const ts: typeof _ts = require(compiler) + const transformers = options.transformers || undefined + const readFile = options.readFile || ts.sys.readFile + const fileExists = options.fileExists || ts.sys.fileExists + const config = readConfig(cwd, ts, fileExists, readFile, compilerOptions, project, skipProject) + const configDiagnosticList = filterDiagnostics(config.errors, ignoreDiagnostics) + const extensions = ['.ts', '.tsx'] + const fileNames = options.files ? config.fileNames : [] + + const cachedir = join( + resolve(cwd, cacheDirectory), + getCompilerDigest({ + version: ts.version, + options: config.options, + fileNames, + typeCheck, + ignoreDiagnostics, + compiler + }) + ) + + const diagnosticHost: _ts.FormatDiagnosticsHost = { + getNewLine: () => EOL, + getCurrentDirectory: () => cwd, + getCanonicalFileName: (path) => path + } + + const formatDiagnostics = options.pretty + ? ts.formatDiagnosticsWithColorAndContext + : ts.formatDiagnostics + + function createTSError (diagnostics: ReadonlyArray<_ts.Diagnostic>) { + const diagnosticText = formatDiagnostics(diagnostics, diagnosticHost) + const diagnosticCodes = diagnostics.map(x => x.code) + return new TSError(diagnosticText, diagnosticCodes) + } + + // Render the configuration errors and exit the script. + if (configDiagnosticList.length) throw createTSError(configDiagnosticList) + + // Enable `allowJs` when flag is set. + if (config.options.allowJs) { + extensions.push('.js') + extensions.push('.jsx') + } + + // Initialize files from TypeScript into project. + for (const path of fileNames) memoryCache.versions[path] = 1 + + /** + * Get the extension for a transpiled file. + */ + const getExtension = config.options.jsx === ts.JsxEmit.Preserve ? + ((path: string) => /\.[tj]sx$/.test(path) ? '.jsx' : '.js') : + ((_: string) => '.js') + + /** + * Create the basic required function using transpile mode. + */ + let getOutput = function (code: string, fileName: string, lineOffset = 0): SourceOutput { + const result = ts.transpileModule(code, { + fileName, + transformers, + compilerOptions: config.options, + reportDiagnostics: true + }) + + const diagnosticList = result.diagnostics ? + filterDiagnostics(result.diagnostics, ignoreDiagnostics) : + [] + + if (diagnosticList.length) throw createTSError(diagnosticList) + + return [result.outputText, result.sourceMapText as string] + } + + let getTypeInfo = function (_code: string, _fileName: string, _position: number): TypeInfo { + throw new TypeError(`Type information is unavailable without "--type-check"`) + } + + // Use full language services when the fast option is disabled. + if (typeCheck) { + // Set the file contents into cache. + const updateMemoryCache = function (code: string, fileName: string) { + if (memoryCache.contents[fileName] !== code) { + memoryCache.contents[fileName] = code + memoryCache.versions[fileName] = (memoryCache.versions[fileName] || 0) + 1 + } + } + + // Create the compiler host for type checking. + const serviceHost = { + getScriptFileNames: () => Object.keys(memoryCache.versions), + getScriptVersion: (fileName: string) => { + const version = memoryCache.versions[fileName] + + // We need to return `undefined` and not a string here because TypeScript will use + // `getScriptVersion` and compare against their own version - which can be `undefined`. + // If we don't return `undefined` it results in `undefined === "undefined"` and run + // `createProgram` again (which is very slow). Using a `string` assertion here to avoid + // TypeScript errors from the function signature (expects `(x: string) => string`). + return version === undefined ? undefined as any as string : String(version) + }, + getScriptSnapshot (fileName: string) { + // Read contents into TypeScript memory cache. + if (!Object.prototype.hasOwnProperty.call(memoryCache.contents, fileName)) { + memoryCache.contents[fileName] = readFile(fileName) + } + + const contents = memoryCache.contents[fileName] + if (contents === undefined) return + return ts.ScriptSnapshot.fromString(contents) + }, + fileExists: debugFn('fileExists', fileExists), + readFile: debugFn('readFile', readFile), + readDirectory: debugFn('readDirectory', ts.sys.readDirectory), + getDirectories: debugFn('getDirectories', ts.sys.getDirectories), + directoryExists: debugFn('directoryExists', ts.sys.directoryExists), + getNewLine: () => EOL, + getCurrentDirectory: () => cwd, + getCompilationSettings: () => config.options, + getDefaultLibFileName: () => ts.getDefaultLibFilePath(config.options), + getCustomTransformers: () => transformers + } + + const service = ts.createLanguageService(serviceHost) + + getOutput = function (code: string, fileName: string, lineOffset: number = 0) { + // Must set memory cache before attempting to read file. + updateMemoryCache(code, fileName) + + const output = service.getEmitOutput(fileName) + + // Get the relevant diagnostics - this is 3x faster than `getPreEmitDiagnostics`. + const diagnostics = service.getCompilerOptionsDiagnostics() + .concat(service.getSyntacticDiagnostics(fileName)) + .concat(service.getSemanticDiagnostics(fileName)) + + const diagnosticList = filterDiagnostics(diagnostics, ignoreDiagnostics) + + if (diagnosticList.length) throw createTSError(diagnosticList) + + if (output.emitSkipped) { + throw new TypeError(`${relative(cwd, fileName)}: Emit skipped`) + } + + // Throw an error when requiring `.d.ts` files. + if (output.outputFiles.length === 0) { + return ['', '']; + } + return [output.outputFiles[1].text, output.outputFiles[0].text] + } + + getTypeInfo = function (code: string, fileName: string, position: number) { + updateMemoryCache(code, fileName) + + const info = service.getQuickInfoAtPosition(fileName, position) + const name = ts.displayPartsToString(info ? info.displayParts : []) + const comment = ts.displayPartsToString(info ? info.documentation : []) + + return { name, comment } + } + } + + const compile = readThrough(cachedir, options.cache === true, memoryCache, getOutput, getExtension) + const register: Register = { cwd, compile, getTypeInfo, extensions, cachedir, ts } + + // Register the extensions. + extensions.forEach(extension => { + registerExtension(extension, ignore, register, originalJsHandler) + }) + + return register +} + +/** + * Check if the filename should be ignored. + */ +function shouldIgnore (filename: string, ignore: RegExp[]) { + const relname = normalizeSlashes(filename) + + return ignore.some(x => x.test(relname)) +} + +/** + * Register the extension for node. + */ +function registerExtension ( + ext: string, + ignore: RegExp[], + register: Register, + originalHandler: (m: NodeModule, filename: string) => any +) { + const old = require.extensions[ext] || originalHandler + + require.extensions[ext] = function (m: any, filename) { + if (shouldIgnore(filename, ignore)) { + return old(m, filename) + } + + const _compile = m._compile + + m._compile = function (code: string, fileName: string) { + debug('module._compile', fileName) + + return _compile.call(this, register.compile(code, fileName), fileName) + } + + return old(m, filename) + } +} + +/** + * Do post-processing on config options to support `ts-node`. + */ +function fixConfig (ts: TSCommon, config: _ts.ParsedCommandLine) { + // Delete options that *should not* be passed through. + delete config.options.out + delete config.options.outFile + delete config.options.declarationDir + delete config.options.declarationMap + delete config.options.emitDeclarationOnly + + // Target ES5 output by default (instead of ES3). + if (config.options.target === undefined) { + config.options.target = ts.ScriptTarget.ES5 + } + + // Target CommonJS modules by default (instead of magically switching to ES6 when the target is ES6). + if (config.options.module === undefined) { + config.options.module = ts.ModuleKind.CommonJS + } + + return config +} + +/** + * Load TypeScript configuration. + */ +function readConfig ( + cwd: string, + ts: TSCommon, + fileExists: (path: string) => boolean, + readFile: (path: string) => string | undefined, + compilerOptions?: object, + project?: string | null, + noProject?: boolean | null +): _ts.ParsedCommandLine { + let config = { compilerOptions: {} } + let basePath = normalizeSlashes(cwd) + let configFileName: string | undefined = undefined + + // Read project configuration when available. + if (!noProject) { + configFileName = project + ? normalizeSlashes(resolve(cwd, project)) + : ts.findConfigFile(normalizeSlashes(cwd), fileExists) + + if (configFileName) { + const result = ts.readConfigFile(configFileName, readFile) + + // Return diagnostics. + if (result.error) { + return { errors: [result.error], fileNames: [], options: {} } + } + + config = result.config + basePath = normalizeSlashes(dirname(configFileName)) + } + } + + // Override default configuration options `ts-node` requires. + config.compilerOptions = Object.assign({}, config.compilerOptions, compilerOptions, DEFAULT_COMPILER_OPTIONS) + + return fixConfig(ts, ts.parseJsonConfigFileContent(config, ts.sys, basePath, undefined, configFileName)) +} + +/** + * Internal source output. + */ +type SourceOutput = [string, string] + +/** + * Wrap the function with caching. + */ +function readThrough ( + cachedir: string, + shouldCache: boolean, + memoryCache: MemoryCache, + compile: (code: string, fileName: string, lineOffset?: number) => SourceOutput, + getExtension: (fileName: string) => string +) { + if (shouldCache === false) { + return function (code: string, fileName: string, lineOffset?: number) { + debug('readThrough', fileName) + + const [value, sourceMap] = compile(code, fileName, lineOffset) + const output = updateOutput(value, fileName, sourceMap, getExtension) + + memoryCache.outputs[fileName] = output + + return output + } + } + + // Make sure the cache directory exists before continuing. + mkdirp.sync(cachedir) + + return function (code: string, fileName: string, lineOffset?: number) { + debug('readThrough', fileName) + + const cachePath = join(cachedir, getCacheName(code, fileName)) + const extension = getExtension(fileName) + const outputPath = `${cachePath}${extension}` + + try { + const output = readFileSync(outputPath, 'utf8') + if (isValidCacheContent(output)) { + memoryCache.outputs[fileName] = output + return output + } + } catch (err) {/* Ignore. */} + + const [value, sourceMap] = compile(code, fileName, lineOffset) + const output = updateOutput(value, fileName, sourceMap, getExtension) + + memoryCache.outputs[fileName] = output + writeFileSync(outputPath, output) + + return output + } +} + +/** + * Update the output remapping the source map. + */ +function updateOutput (outputText: string, fileName: string, sourceMap: string, getExtension: (fileName: string) => string) { + const base64Map = bufferFrom(updateSourceMap(sourceMap, fileName), 'utf8').toString('base64') + const sourceMapContent = `data:application/json;charset=utf-8;base64,${base64Map}` + const sourceMapLength = `${basename(fileName)}.map`.length + (getExtension(fileName).length - extname(fileName).length) + + return outputText.slice(0, -sourceMapLength) + sourceMapContent +} + +/** + * Update the source map contents for improved output. + */ +function updateSourceMap (sourceMapText: string, fileName: string) { + const sourceMap = JSON.parse(sourceMapText) + sourceMap.file = fileName + sourceMap.sources = [fileName] + delete sourceMap.sourceRoot + return JSON.stringify(sourceMap) +} + +/** + * Get the file name for the cache entry. + */ +function getCacheName (sourceCode: string, fileName: string) { + return crypto.createHash('sha256') + .update(extname(fileName), 'utf8') + .update('\x00', 'utf8') + .update(sourceCode, 'utf8') + .digest('hex') +} + +/** + * Ensure the given cached content is valid by sniffing for a base64 encoded '}' + * at the end of the content, which should exist if there is a valid sourceMap present. + */ +function isValidCacheContent (contents: string) { + return /(?:9|0=|Q==)$/.test(contents.slice(-3)) +} + +/** + * Create a hash of the current configuration. + */ +function getCompilerDigest (obj: object) { + return crypto.createHash('sha256').update(JSON.stringify(obj), 'utf8').digest('hex') +} + +/** + * Filter diagnostics. + */ +function filterDiagnostics (diagnostics: _ts.Diagnostic[], ignore: number[]) { + return diagnostics.filter(x => ignore.indexOf(x.code) === -1) +}