603 lines
No EOL
26 KiB
TypeScript
603 lines
No EOL
26 KiB
TypeScript
/// <reference path="scripts/types/ambient.d.ts" />
|
|
// @ts-check
|
|
const path = require("path");
|
|
const log = require("fancy-log"); // was `require("gulp-util").log (see https://github.com/gulpjs/gulp-util)
|
|
const fs = require("fs");
|
|
const child_process = require("child_process");
|
|
const runSequence = require("run-sequence");
|
|
const newer = require("gulp-newer");
|
|
const insert = require("gulp-insert");
|
|
const { append } = require("gulp-insert");
|
|
const sourcemaps = require("gulp-sourcemaps");
|
|
const del = require("del");
|
|
const fold = require("travis-fold");
|
|
const rename = require("gulp-rename");
|
|
const mkdirp = require("./scripts/build/mkdirp");
|
|
const gulp = require("./scripts/build/gulp");
|
|
const getDirSize = require("./scripts/build/getDirSize");
|
|
const project = require("./scripts/build/project");
|
|
const replace = require("./scripts/build/replace");
|
|
const convertConstEnums = require("./scripts/build/convertConstEnum");
|
|
const needsUpdate = require("./scripts/build/needsUpdate");
|
|
const getDiffTool = require("./scripts/build/getDiffTool");
|
|
const baselineAccept = require("./scripts/build/baselineAccept");
|
|
const cmdLineOptions = require("./scripts/build/options");
|
|
const exec = require("./scripts/build/exec");
|
|
const browserify = require("./scripts/build/browserify");
|
|
const debounce = require("./scripts/build/debounce");
|
|
const prepend = require("./scripts/build/prepend");
|
|
const { removeSourceMaps } = require("./scripts/build/sourcemaps");
|
|
const { CancelSource, CancelError } = require("./scripts/build/cancellation");
|
|
const { libraryTargets, generateLibs } = require("./scripts/build/lib");
|
|
const { runConsoleTests, cleanTestDirs, writeTestConfigFile, refBaseline, localBaseline, refRwcBaseline, localRwcBaseline } = require("./scripts/build/tests");
|
|
|
|
Error.stackTraceLimit = 1000;
|
|
|
|
// Constants
|
|
const host = cmdLineOptions.host;
|
|
const copyright = "CopyrightNotice.txt";
|
|
|
|
project.addTypeScript("lkg", "./lib/typescript.js");
|
|
project.addTypeScript("built", "./built/local/typescriptServices.js");
|
|
project.addTypeScript("default", "lkg"); // Compile using the LKG compiler by default
|
|
|
|
const scriptsProject = "scripts/tsconfig.json";
|
|
const configurePrereleaseJs = "scripts/configurePrerelease.js";
|
|
const processDiagnosticMessagesJs = "scripts/processDiagnosticMessages.js";
|
|
const generateLocalizedDiagnosticMessagesJs = "scripts/generateLocalizedDiagnosticMessages.js";
|
|
const buildProtocolJs = "scripts/buildProtocol.js";
|
|
const produceLKGJs = "scripts/produceLKG.js";
|
|
const word2mdJs = "scripts/word2md.js";
|
|
const scriptsTaskAliases = [configurePrereleaseJs, processDiagnosticMessagesJs, generateLocalizedDiagnosticMessagesJs, produceLKGJs, buildProtocolJs, word2mdJs];
|
|
gulp.task("scripts", /*help*/ false, () => project.compile(scriptsProject), { aliases: scriptsTaskAliases });
|
|
gulp.task("clean:scripts", /*help*/ false, () => project.clean(scriptsProject), { aliases: scriptsTaskAliases.map(alias => `clean:${alias}`)});
|
|
|
|
// Nightly management tasks
|
|
gulp.task(
|
|
"configure-nightly",
|
|
"Runs scripts/configurePrerelease.ts to prepare a build for nightly publishing",
|
|
[configurePrereleaseJs],
|
|
() => exec(host, [configurePrereleaseJs, "dev", "package.json", "src/compiler/core.ts"]));
|
|
|
|
gulp.task(
|
|
"publish-nightly",
|
|
"Runs `npm publish --tag next` to create a new nightly build on npm",
|
|
["LKG"],
|
|
() => runSequence("clean", "runtests-parallel",
|
|
() => exec("npm", ["publish", "--tag", "next"])));
|
|
|
|
const importDefinitelyTypedTestsProject = "scripts/importDefinitelyTypedTests/tsconfig.json";
|
|
const importDefinitelyTypedTestsJs = "scripts/importDefinitelyTypedTests/importDefinitelyTypedTests.js";
|
|
gulp.task(importDefinitelyTypedTestsJs, /*help*/ false, () => project.compile(importDefinitelyTypedTestsProject));
|
|
gulp.task(`clean:${importDefinitelyTypedTestsJs}`, /*help*/ false, () => project.clean(importDefinitelyTypedTestsProject));
|
|
|
|
gulp.task(
|
|
"importDefinitelyTypedTests",
|
|
"Runs scripts/importDefinitelyTypedTests/importDefinitelyTypedTests.ts to copy DT's tests to the TS-internal RWC tests",
|
|
[importDefinitelyTypedTestsJs],
|
|
() => exec(host, [importDefinitelyTypedTestsJs, "./", "../DefinitelyTyped"]));
|
|
|
|
gulp.task(
|
|
"lib",
|
|
"Builds the library targets",
|
|
() => generateLibs([copyright]));
|
|
|
|
// The generated diagnostics map; built for the compiler and for the "generate-diagnostics" task
|
|
const diagnosticInformationMapTs = "src/compiler/diagnosticInformationMap.generated.ts";
|
|
const diagnosticMessagesJson = "src/compiler/diagnosticMessages.json";
|
|
const diagnosticMessagesGeneratedJson = "src/compiler/diagnosticMessages.generated.json";
|
|
gulp.task(diagnosticInformationMapTs, /*help*/ false, [processDiagnosticMessagesJs], () => {
|
|
if (needsUpdate(diagnosticMessagesJson, [diagnosticMessagesGeneratedJson, diagnosticInformationMapTs])) {
|
|
return exec(host, [processDiagnosticMessagesJs, diagnosticMessagesJson]);
|
|
}
|
|
});
|
|
gulp.task(`clean:${diagnosticInformationMapTs}`, /*help*/ false, () => del([diagnosticInformationMapTs, diagnosticMessagesGeneratedJson]));
|
|
|
|
const builtGeneratedDiagnosticMessagesJson = "built/local/diagnosticMessages.generated.json";
|
|
gulp.task(builtGeneratedDiagnosticMessagesJson, /*help*/ false, [diagnosticInformationMapTs], () =>
|
|
gulp.src([diagnosticMessagesGeneratedJson], { base: "src/compiler" })
|
|
.pipe(newer(builtGeneratedDiagnosticMessagesJson))
|
|
.pipe(gulp.dest("built/local")));
|
|
|
|
gulp.task(
|
|
"generate-diagnostics",
|
|
"Generates a diagnostic file in TypeScript based on an input JSON file",
|
|
[diagnosticInformationMapTs]);
|
|
|
|
// Localize diagnostics
|
|
/**
|
|
* .lcg file is what localization team uses to know what messages to localize.
|
|
* The file is always generated in 'enu/diagnosticMessages.generated.json.lcg'
|
|
*/
|
|
const generatedLCGFile = "built/local/enu/diagnosticMessages.generated.json.lcg";
|
|
|
|
/**
|
|
* The localization target produces the two following transformations:
|
|
* 1. 'src\loc\lcl\<locale>\diagnosticMessages.generated.json.lcl' => 'built\local\<locale>\diagnosticMessages.generated.json'
|
|
* convert localized resources into a .json file the compiler can understand
|
|
* 2. 'src\compiler\diagnosticMessages.generated.json' => 'built\local\ENU\diagnosticMessages.generated.json.lcg'
|
|
* generate the lcg file (source of messages to localize) from the diagnosticMessages.generated.json
|
|
*/
|
|
const localizationTargets = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-BR", "ru", "tr", "zh-CN", "zh-TW"]
|
|
.map(f => `built/local/${f}/diagnosticMessages.generated.json`)
|
|
.concat(generatedLCGFile);
|
|
|
|
gulp.task(generatedLCGFile, /*help*/ false, [generateLocalizedDiagnosticMessagesJs, diagnosticInformationMapTs], (done) => {
|
|
if (needsUpdate(diagnosticMessagesGeneratedJson, generatedLCGFile)) {
|
|
return exec(host, [generateLocalizedDiagnosticMessagesJs, "src/loc/lcl", "built/local", diagnosticMessagesGeneratedJson], { ignoreExitCode: true });
|
|
}
|
|
});
|
|
|
|
gulp.task("localize", /*help*/ false, [generatedLCGFile]);
|
|
|
|
const servicesProject = "src/services/tsconfig.json";
|
|
const typescriptServicesProject = "built/local/typescriptServices.tsconfig.json";
|
|
gulp.task(typescriptServicesProject, /*help*/ false, () => {
|
|
// NOTE: flatten services so that we can properly strip @internal
|
|
project.flatten(servicesProject, typescriptServicesProject, {
|
|
compilerOptions: {
|
|
"removeComments": false,
|
|
"stripInternal": true,
|
|
"declarationMap": false,
|
|
"outFile": "typescriptServices.out.js" // must align with same task in jakefile. We fix this name below.
|
|
}
|
|
});
|
|
});
|
|
|
|
const typescriptServicesJs = "built/local/typescriptServices.js";
|
|
const typescriptServicesDts = "built/local/typescriptServices.d.ts";
|
|
gulp.task(typescriptServicesJs, /*help*/ false, ["lib", "generate-diagnostics", typescriptServicesProject], () =>
|
|
project.compile(typescriptServicesProject, {
|
|
js: files => files
|
|
.pipe(prepend.file(copyright))
|
|
.pipe(rename("typescriptServices.js")),
|
|
dts: files => files
|
|
.pipe(removeSourceMaps())
|
|
.pipe(prepend.file(copyright))
|
|
.pipe(convertConstEnums())
|
|
.pipe(rename("typescriptServices.d.ts"))
|
|
}),
|
|
{ aliases: [typescriptServicesDts] });
|
|
|
|
const typescriptJs = "built/local/typescript.js";
|
|
gulp.task(typescriptJs, /*help*/ false, [typescriptServicesJs], () =>
|
|
gulp.src([typescriptServicesJs], { base: "built/local" })
|
|
.pipe(newer(typescriptJs))
|
|
.pipe(rename("typescript.js"))
|
|
.pipe(gulp.dest("built/local")))
|
|
|
|
const typescriptDts = "built/local/typescript.d.ts";
|
|
gulp.task(typescriptDts, /*help*/ false, [typescriptServicesDts], () =>
|
|
gulp.src([typescriptServicesDts], { base: "built/local" })
|
|
.pipe(newer(typescriptDts))
|
|
.pipe(append("\nexport = ts;"))
|
|
.pipe(rename("typescript.d.ts"))
|
|
.pipe(gulp.dest("built/local")));
|
|
|
|
const typescriptStandaloneDts = "built/local/typescript_standalone.d.ts";
|
|
gulp.task(typescriptStandaloneDts, /*help*/ false, [typescriptServicesDts], () =>
|
|
gulp.src([typescriptServicesDts], { base: "built/local" })
|
|
.pipe(newer(typescriptStandaloneDts))
|
|
.pipe(replace(/declare (namespace|module) ts/g, 'declare module "typescript"'))
|
|
.pipe(rename("typescript_standalone.d.ts"))
|
|
.pipe(gulp.dest("built/local")));
|
|
|
|
// build all 'typescriptServices'-related outputs
|
|
gulp.task("services", /*help*/ false, [typescriptServicesJs, typescriptServicesDts, typescriptJs, typescriptDts, typescriptStandaloneDts]);
|
|
|
|
const useCompiler = cmdLineOptions.lkg ? "lkg" : "built";
|
|
const useCompilerDeps = cmdLineOptions.lkg ? ["lib", "generate-diagnostics"] : [typescriptServicesJs];
|
|
|
|
const tscProject = "src/tsc/tsconfig.json";
|
|
const tscJs = "built/local/tsc.js";
|
|
gulp.task(tscJs, /*help*/ false, useCompilerDeps, () =>
|
|
project.compile(tscProject, {
|
|
typescript: useCompiler,
|
|
js: files => files.pipe(prepend.file(copyright))
|
|
}));
|
|
|
|
const tscReleaseProject = "src/tsc/tsconfig.release.json";
|
|
const tscReleaseJs = "built/local/tsc.release.js";
|
|
gulp.task(tscReleaseJs, /*help*/ false, () =>
|
|
project.compile(tscReleaseProject, {
|
|
js: files => files.pipe(prepend.file(copyright))
|
|
}));
|
|
|
|
const cancellationTokenProject = "src/cancellationToken/tsconfig.json";
|
|
const cancellationTokenJs = "built/local/cancellationToken.js";
|
|
gulp.task(cancellationTokenJs, /*help*/ false, useCompilerDeps, () => project.compile(cancellationTokenProject, { typescript: useCompiler }));
|
|
|
|
const typingsInstallerProject = "src/typingsInstaller/tsconfig.json";
|
|
const typingsInstallerJs = "built/local/typingsInstaller.js";
|
|
gulp.task(typingsInstallerJs, /*help*/ false, useCompilerDeps, () => project.compile(typingsInstallerProject, { typescript: useCompiler }));
|
|
|
|
const tsserverProject = "src/tsserver/tsconfig.json";
|
|
const tsserverJs = "built/local/tsserver.js";
|
|
gulp.task(tsserverJs, /*help*/ false, useCompilerDeps, () => project.compile(tsserverProject, { typescript: useCompiler }));
|
|
|
|
const watchGuardProject = "src/watchGuard/tsconfig.json";
|
|
const watchGuardJs = "built/local/watchGuard.js";
|
|
gulp.task(watchGuardJs, /*help*/ false, useCompilerDeps, () => project.compile(watchGuardProject, { typescript: useCompiler }));
|
|
|
|
const typesMapJson = "built/local/typesMap.json";
|
|
gulp.task(typesMapJson, /*help*/ false, [], () =>
|
|
gulp.src("src/server/typesMap.json")
|
|
.pipe(newer(typesMapJson))
|
|
.pipe(insert.transform(contents => (JSON.parse(contents), contents)))
|
|
.pipe(gulp.dest("built/local")));
|
|
|
|
const tsserverlibraryProject = "built/local/tsserverlibrary.tsconfig.json";
|
|
gulp.task(tsserverlibraryProject, /*help*/ false, () => {
|
|
// NOTE: flatten tsserverlibrary so that we can properly strip @internal
|
|
project.flatten("src/tsserver/tsconfig.json", tsserverlibraryProject, {
|
|
exclude: ["src/tsserver/server.ts"],
|
|
compilerOptions: {
|
|
"removeComments": false,
|
|
"stripInternal": true,
|
|
"declarationMap": false,
|
|
"outFile": "tsserverlibrary.out.js" // must align with same task in jakefile. We fix this name below.
|
|
}
|
|
});
|
|
});
|
|
|
|
const tsserverlibraryJs = "built/local/tsserverlibrary.js";
|
|
const tsserverlibraryDts = "built/local/tsserverlibrary.d.ts";
|
|
gulp.task(tsserverlibraryJs, /*help*/ false, useCompilerDeps.concat([tsserverlibraryProject]), () =>
|
|
project.compile(tsserverlibraryProject, {
|
|
js: files => files
|
|
.pipe(prepend.file(copyright))
|
|
.pipe(rename("tsserverlibrary.js")),
|
|
dts: files => files
|
|
.pipe(removeSourceMaps())
|
|
.pipe(prepend.file(copyright))
|
|
.pipe(convertConstEnums())
|
|
.pipe(append("\nexport = ts;\nexport as namespace ts;"))
|
|
.pipe(rename("tsserverlibrary.d.ts")),
|
|
typescript: useCompiler
|
|
}), { aliases: [tsserverlibraryDts] });
|
|
|
|
gulp.task(
|
|
"lssl",
|
|
"Builds language service server library",
|
|
[tsserverlibraryDts]);
|
|
|
|
gulp.task(
|
|
"local",
|
|
"Builds the full compiler and services",
|
|
[tscJs, "services", tsserverJs, builtGeneratedDiagnosticMessagesJson, tsserverlibraryDts, "localize"]);
|
|
|
|
gulp.task(
|
|
"tsc",
|
|
"Builds only the compiler",
|
|
[tscJs]);
|
|
|
|
// Generate Markdown spec
|
|
const specMd = "doc/spec.md";
|
|
gulp.task(specMd, /*help*/ false, [word2mdJs], () =>
|
|
exec("cscript", ["//nologo", word2mdJs, path.resolve(specMd), path.resolve("doc/TypeScript Language Specification.docx")]));
|
|
|
|
gulp.task(
|
|
"generate-spec",
|
|
"Generates a Markdown version of the Language Specification",
|
|
[specMd]);
|
|
|
|
gulp.task("produce-LKG", /*help*/ false, ["scripts", "local", cancellationTokenJs, typingsInstallerJs, watchGuardJs, tscReleaseJs], () => {
|
|
const expectedFiles = [
|
|
tscReleaseJs,
|
|
typescriptServicesJs,
|
|
tsserverJs,
|
|
typescriptJs,
|
|
typescriptDts,
|
|
typescriptServicesDts,
|
|
tsserverlibraryDts,
|
|
tsserverlibraryDts,
|
|
typingsInstallerJs,
|
|
cancellationTokenJs
|
|
].concat(libraryTargets);
|
|
const missingFiles = expectedFiles
|
|
.concat(localizationTargets)
|
|
.filter(f => !fs.existsSync(f));
|
|
if (missingFiles.length > 0) {
|
|
throw new Error("Cannot replace the LKG unless all built targets are present in directory 'built/local/'. The following files are missing:\n" + missingFiles.join("\n"));
|
|
}
|
|
const sizeBefore = getDirSize("lib");
|
|
return exec(host, [produceLKGJs]).then(() => {
|
|
const sizeAfter = getDirSize("lib");
|
|
if (sizeAfter > (sizeBefore * 1.10)) {
|
|
throw new Error("The lib folder increased by 10% or more. This likely indicates a bug.");
|
|
}
|
|
});
|
|
});
|
|
|
|
gulp.task(
|
|
"LKG",
|
|
"Makes a new LKG out of the built js files",
|
|
() => runSequence("clean-built", "produce-LKG"));
|
|
|
|
// Task to build the tests infrastructure using the built compiler
|
|
const testRunnerProject = "src/testRunner/tsconfig.json";
|
|
const runJs = "built/local/run.js";
|
|
gulp.task(runJs, /*help*/ false, useCompilerDeps, () => project.compile(testRunnerProject, { typescript: useCompiler }));
|
|
|
|
gulp.task(
|
|
"tests",
|
|
"Builds the test infrastructure using the built compiler",
|
|
[runJs, tsserverlibraryDts]);
|
|
|
|
gulp.task(
|
|
"runtests-parallel",
|
|
"Runs all the tests in parallel using the built run.js file. Optional arguments are: --t[ests]=category1|category2|... --d[ebug]=true.",
|
|
["build-rules", "tests", "services", tsserverlibraryDts],
|
|
() => runConsoleTests(runJs, "min", /*runInParallel*/ true, /*watchMode*/ false));
|
|
|
|
gulp.task(
|
|
"runtests",
|
|
"Runs the tests using the built run.js file. Optional arguments are: --t[ests]=regex --r[eporter]=[list|spec|json|<more>] --d[ebug]=true --color[s]=false --lint=true.",
|
|
["build-rules", "tests", "services", tsserverlibraryDts],
|
|
() => runConsoleTests(runJs, "mocha-fivemat-progress-reporter", /*runInParallel*/ false, /*watchMode*/ false));
|
|
|
|
const webTestServerProject = "tests/webTestServer.tsconfig.json";
|
|
const webTestServerJs = "tests/webTestServer.js";
|
|
gulp.task(webTestServerJs, /*help*/ false, useCompilerDeps, () => project.compile(webTestServerProject, { typescript: useCompiler }));
|
|
gulp.task(`clean:${webTestServerJs}`, /*help*/ false, () => project.clean(webTestServerProject));
|
|
|
|
const bundlePath = path.resolve("built/local/bundle.js");
|
|
|
|
gulp.task(
|
|
"browserify",
|
|
"Runs browserify on run.js to produce a file suitable for running tests in the browser",
|
|
[runJs],
|
|
() => gulp.src([runJs], { base: "built/local" })
|
|
.pipe(newer(bundlePath))
|
|
.pipe(sourcemaps.init({ loadMaps: true }))
|
|
.pipe(browserify())
|
|
.pipe(rename("bundle.js"))
|
|
.pipe(sourcemaps.write(".", /**@type {*}*/({ includeContent: false, destPath: "built/local" })))
|
|
.pipe(gulp.dest("built/local")));
|
|
|
|
gulp.task(
|
|
"runtests-browser",
|
|
"Runs the tests using the built run.js file like 'gulp runtests'. Syntax is gulp runtests-browser. Additional optional parameters --tests=[regex], --browser=[chrome|IE]",
|
|
["browserify", webTestServerJs],
|
|
() => cleanTestDirs().then(() => {
|
|
const tests = cmdLineOptions.tests;
|
|
const runners = cmdLineOptions.runners;
|
|
const light = cmdLineOptions.light;
|
|
const testConfigFile = "test.config";
|
|
if (fs.existsSync(testConfigFile)) {
|
|
fs.unlinkSync(testConfigFile);
|
|
}
|
|
if (tests || runners || light) {
|
|
writeTestConfigFile(tests, runners, light);
|
|
}
|
|
const args = [webTestServerJs];
|
|
if (cmdLineOptions.browser) {
|
|
args.push(cmdLineOptions.browser);
|
|
}
|
|
if (tests) {
|
|
args.push(JSON.stringify(tests));
|
|
}
|
|
return exec("node", args);
|
|
}));
|
|
|
|
gulp.task(
|
|
"generate-code-coverage",
|
|
"Generates code coverage data via istanbul",
|
|
["tests"],
|
|
() => exec("istanbul", ["cover", "node_modules/mocha/bin/_mocha", "--", "-R", "min", "-t", "" + cmdLineOptions.testTimeout, runJs]));
|
|
|
|
|
|
gulp.task(
|
|
"diff",
|
|
"Diffs the compiler baselines using the diff tool specified by the 'DIFF' environment variable",
|
|
() => exec(getDiffTool(), [refBaseline, localBaseline], { ignoreExitCode: true }));
|
|
|
|
gulp.task(
|
|
"diff-rwc",
|
|
"Diffs the RWC baselines using the diff tool specified by the 'DIFF' environment variable",
|
|
() => exec(getDiffTool(), [refRwcBaseline, localRwcBaseline], { ignoreExitCode: true }));
|
|
|
|
gulp.task(
|
|
"baseline-accept",
|
|
"Makes the most recent test results the new baseline, overwriting the old baseline",
|
|
() => baselineAccept());
|
|
|
|
gulp.task(
|
|
"baseline-accept-rwc",
|
|
"Makes the most recent rwc test results the new baseline, overwriting the old baseline",
|
|
() => baselineAccept("rwc"));
|
|
|
|
gulp.task(
|
|
"baseline-accept-test262",
|
|
"Makes the most recent test262 test results the new baseline, overwriting the old baseline",
|
|
() => baselineAccept("test262"));
|
|
|
|
// Webhost
|
|
const webtscProject = "tests/webhost/webtsc.tsconfig.json";
|
|
const webtscJs = "tests/webhost/webtsc.js";
|
|
gulp.task(webtscJs, /*help*/ false, useCompilerDeps, () => project.compile(webtscProject, { typescript: useCompiler }));
|
|
gulp.task(`clean:${webtscJs}`, /*help*/ false, () => project.clean(webtscProject));
|
|
|
|
gulp.task("webhost", "Builds the tsc web host", [webtscJs], () =>
|
|
gulp.src("built/local/lib.d.ts")
|
|
.pipe(gulp.dest("tests/webhost/")));
|
|
|
|
// Perf compiler
|
|
const perftscProject = "tests/perftsc.tsconfig.json";
|
|
const perftscJs = "built/local/perftsc.js";
|
|
gulp.task(perftscJs, /*help*/ false, useCompilerDeps, () => project.compile(perftscProject, { typescript: useCompiler }));
|
|
gulp.task(`clean:${perftscJs}`, /*help*/ false, () => project.clean(perftscProject));
|
|
|
|
gulp.task(
|
|
"perftsc",
|
|
"Builds augmented version of the compiler for perf tests",
|
|
[perftscJs]);
|
|
|
|
// Instrumented compiler
|
|
const loggedIOTs = "src/harness/loggedIO.ts";
|
|
const loggedIOJs = "built/local/loggedIO.js";
|
|
gulp.task(loggedIOJs, /*help*/ false, [], (done) => {
|
|
return mkdirp("built/local/temp")
|
|
.then(() => exec(host, ["lib/tsc.js", "--types", "--target es5", "--lib es5", "--outdir", "built/local/temp", loggedIOTs]))
|
|
.then(() => { fs.renameSync(path.join("built/local/temp", "/harness/loggedIO.js"), loggedIOJs); })
|
|
.then(() => del("built/local/temp"));
|
|
});
|
|
|
|
const instrumenterProject = "src/instrumenter/tsconfig.json";
|
|
const instrumenterJs = "built/local/instrumenter.js";
|
|
gulp.task(instrumenterJs, /*help*/ false, () => project.compile(instrumenterProject));
|
|
gulp.task(`clean:${instrumenterJs}`, /*help*/ false, () => project.clean(instrumenterProject));
|
|
|
|
gulp.task(
|
|
"tsc-instrumented",
|
|
"Builds an instrumented tsc.js - run with --test=[testname]",
|
|
["local", loggedIOJs, instrumenterJs, typescriptServicesJs],
|
|
() => exec(host, [instrumenterJs, "record", cmdLineOptions.tests || "iocapture", "built/local"]));
|
|
|
|
gulp.task(
|
|
"update-sublime",
|
|
"Updates the sublime plugin's tsserver",
|
|
["local", tsserverJs],
|
|
() =>
|
|
gulp.src([tsserverJs, tsserverJs + ".map"])
|
|
.pipe(gulp.dest("../TypeScript-Sublime-Plugin/tsserver/")));
|
|
|
|
gulp.task(
|
|
"build-rules",
|
|
"Compiles tslint rules to js",
|
|
() => project.compile("scripts/tslint/tsconfig.json"));
|
|
|
|
gulp.task("clean-rules", /*help*/ false, () => project.clean("scripts/tslint/tsconfig.json"));
|
|
|
|
gulp.task(
|
|
"lint",
|
|
"Runs tslint on the compiler sources. Optional arguments are: --f[iles]=regex",
|
|
["build-rules"],
|
|
() => {
|
|
if (fold.isTravis()) console.log(fold.start("lint"));
|
|
for (const project of ["scripts/tslint/tsconfig.json", "src/tsconfig-base.json"]) {
|
|
const cmd = `node node_modules/tslint/bin/tslint --project ${project} --formatters-dir ./built/local/tslint/formatters --format autolinkableStylish${cmdLineOptions.fix ? " --fix" : ""}`;
|
|
log("Linting: " + cmd);
|
|
child_process.execSync(cmd, { stdio: [0, 1, 2] });
|
|
}
|
|
if (fold.isTravis()) console.log(fold.end("lint"));
|
|
});
|
|
|
|
gulp.task(
|
|
"default",
|
|
"Runs 'local'",
|
|
["local"]);
|
|
|
|
gulp.task(
|
|
"watch-diagnostics",
|
|
/*help*/ false,
|
|
[processDiagnosticMessagesJs],
|
|
() => gulp.watch([diagnosticMessagesJson], [diagnosticInformationMapTs, builtGeneratedDiagnosticMessagesJson]));
|
|
|
|
gulp.task(
|
|
"watch-lib",
|
|
/*help*/ false,
|
|
() => gulp.watch(["src/lib/**/*"], ["lib"]));
|
|
|
|
gulp.task(
|
|
"watch-tsc",
|
|
/*help*/ false,
|
|
["watch-diagnostics", "watch-lib"].concat(useCompilerDeps),
|
|
() => project.watch(tscProject, { typescript: useCompiler }));
|
|
|
|
const watchServicesPatterns = [
|
|
"src/compiler/**/*",
|
|
"src/jsTypings/**/*",
|
|
"src/services/**/*"
|
|
];
|
|
|
|
gulp.task(
|
|
"watch-services",
|
|
/*help*/ false,
|
|
["watch-diagnostics", "watch-lib"],
|
|
() => gulp.watch(watchServicesPatterns, ["services"]));
|
|
|
|
const watchLsslPatterns = [
|
|
...watchServicesPatterns,
|
|
"src/server/**/*",
|
|
"src/tsserver/tsconfig.json"
|
|
];
|
|
|
|
gulp.task(
|
|
"watch-lssl",
|
|
/*help*/ false,
|
|
() => gulp.watch(watchLsslPatterns, ["lssl"]));
|
|
|
|
gulp.task(
|
|
"watch-server",
|
|
/*help*/ false,
|
|
["watch-diagnostics", "watch-lib"].concat(useCompilerDeps),
|
|
() => project.watch(tsserverProject, { typescript: useCompiler }));
|
|
|
|
gulp.task(
|
|
"watch-local",
|
|
/*help*/ false,
|
|
["watch-lib", "watch-tsc", "watch-services", "watch-server"]);
|
|
|
|
gulp.task(
|
|
"watch-runner",
|
|
/*help*/ false,
|
|
useCompilerDeps,
|
|
() => project.watch(testRunnerProject, { typescript: useCompiler }));
|
|
|
|
const watchPatterns = [
|
|
runJs,
|
|
typescriptDts,
|
|
tsserverlibraryDts
|
|
];
|
|
|
|
gulp.task(
|
|
"watch",
|
|
"Watches for changes to the build inputs for built/local/run.js, then executes runtests-parallel.",
|
|
["build-rules", "watch-runner", "watch-services", "watch-lssl"],
|
|
() => {
|
|
/** @type {CancelSource | undefined} */
|
|
let runTestsSource;
|
|
|
|
const fn = debounce(() => {
|
|
runTests().catch(error => {
|
|
if (error instanceof CancelError) {
|
|
log.warn("Operation was canceled");
|
|
}
|
|
else {
|
|
log.error(error);
|
|
}
|
|
});
|
|
}, /*timeout*/ 100, { max: 500 });
|
|
|
|
gulp.watch(watchPatterns, () => project.wait().then(fn));
|
|
|
|
// NOTE: gulp.watch is far too slow when watching tests/cases/**/* as it first enumerates *every* file
|
|
const testFilePattern = /(\.ts|[\\/]tsconfig\.json)$/;
|
|
fs.watch("tests/cases", { recursive: true }, (_, file) => {
|
|
if (testFilePattern.test(file)) project.wait().then(fn);
|
|
});
|
|
|
|
function runTests() {
|
|
if (runTestsSource) runTestsSource.cancel();
|
|
runTestsSource = new CancelSource();
|
|
return cmdLineOptions.tests || cmdLineOptions.failed
|
|
? runConsoleTests(runJs, "mocha-fivemat-progress-reporter", /*runInParallel*/ false, /*watchMode*/ true, runTestsSource.token)
|
|
: runConsoleTests(runJs, "min", /*runInParallel*/ true, /*watchMode*/ true, runTestsSource.token);
|
|
}
|
|
});
|
|
|
|
gulp.task("clean-built", /*help*/ false, [`clean:${diagnosticInformationMapTs}`], () => del(["built"]));
|
|
gulp.task(
|
|
"clean",
|
|
"Cleans the compiler output, declare files, and tests",
|
|
[
|
|
`clean:${importDefinitelyTypedTestsJs}`,
|
|
`clean:${webtscJs}`,
|
|
`clean:${perftscJs}`,
|
|
`clean:${instrumenterJs}`,
|
|
`clean:${webTestServerJs}`,
|
|
"clean:scripts",
|
|
"clean-rules",
|
|
"clean-built"
|
|
]); |