/*eslint-env node*/

"use strict";

var fs = require("fs");

var path = require("path");

var os = require("os");

var child_process = require("child_process");

var crypto = require("crypto");

var zlib = require("zlib");

var readline = require("readline");

var request = require("request");

var globby = require("globby");

var gulpTap = require("gulp-tap");

var gulpUglify = require("gulp-uglify");

var open = require("open");

var rimraf = require("rimraf");

var glslStripComments = require("glsl-strip-comments");

var mkdirp = require("mkdirp");

var mergeStream = require("merge-stream");

var streamToPromise = require("stream-to-promise");

var gulp = require("gulp");

var gulpInsert = require("gulp-insert");

var gulpZip = require("gulp-zip");

var gulpRename = require("gulp-rename");

var gulpReplace = require("gulp-replace");

var Promise = require("bluebird");

var Karma = require("karma");

var yargs = require("yargs");

var AWS = require("aws-sdk");

var mime = require("mime");

var rollup = require("rollup");

var rollupPluginStripPragma = require("rollup-plugin-strip-pragma");

var rollupPluginExternalGlobals = require("rollup-plugin-external-globals");

var rollupPluginUglify = require("rollup-plugin-uglify");

var cleanCSS = require("gulp-clean-css");

var typescript = require("typescript");

var packageJson = require("./package.json");

var version = packageJson.version;

if (/\.0$/.test(version)) {

version = version.substring(0, version.length - 2);

}

var karmaConfigFile = path.join(__dirname, "Specs/karma.conf.cjs");

var travisDeployUrl =

"http://cesium-dev.s3-website-us-east-1.amazonaws.com/cesium/";

//Gulp doesn't seem to have a way to get the currently running tasks for setting

//per-task variables. We use the command line argument here to detect which task is being run.

var taskName = process.argv[2];

var noDevelopmentGallery = taskName === "release" || taskName === "makeZipFile";

var minifyShaders =

taskName === "minify" ||

taskName === "minifyRelease" ||

taskName === "release" ||

taskName === "makeZipFile" ||

taskName === "buildApps";

var verbose = yargs.argv.verbose;

var concurrency = yargs.argv.concurrency;

if (!concurrency) {

concurrency = os.cpus().length;

}

var sourceFiles = [

"Source/**/*.js",

"!Source/*.js",

"!Source/Workers/**",

"!Source/WorkersES6/**",

"Source/WorkersES6/createTaskProcessorWorker.js",

"!Source/ThirdParty/Workers/**",

"!Source/ThirdParty/google-earth-dbroot-parser.js",

"!Source/ThirdParty/pako_inflate.js",

"!Source/ThirdParty/crunch.js",

];

var watchedFiles = [

"Source/**/*.js",

"!Source/Cesium.js",

"!Source/Build/**",

"!Source/Shaders/**/*.js",

"Source/Shaders/**/*.glsl",

"!Source/ThirdParty/Shaders/*.js",

"Source/ThirdParty/Shaders/*.glsl",

"!Source/Workers/**",

"Source/Workers/cesiumWorkerBootstrapper.js",

"Source/Workers/transferTypedArrayTest.js",

"!Specs/SpecList.js",

];

var filesToClean = [

"Source/Cesium.js",

"Source/Shaders/**/*.js",

"Source/Workers/**",

"!Source/Workers/cesiumWorkerBootstrapper.js",

"!Source/Workers/transferTypedArrayTest.js",

"Source/ThirdParty/Shaders/*.js",

"Specs/SpecList.js",

"Apps/Sandcastle/jsHintOptions.js",

"Apps/Sandcastle/gallery/gallery-index.js",

"Apps/Sandcastle/templates/bucket.css",

"Cesium-*.zip",

"cesium-*.tgz",

];

var filesToConvertES6 = [

"Source/**/*.js",

"Specs/**/*.js",

"!Source/ThirdParty/**",

"!Source/Cesium.js",

"!Source/copyrightHeader.js",

"!Source/Shaders/**",

"!Source/Workers/cesiumWorkerBootstrapper.js",

"!Source/Workers/transferTypedArrayTest.js",

"!Specs/karma-main.js",

"!Specs/karma.conf.cjs",

"!Specs/spec-main.js",

"!Specs/SpecList.js",

"!Specs/TestWorkers/**",

];

function rollupWarning(message) {

}

var copyrightHeader = fs.readFileSync(

path.join("Source", "copyrightHeader.js"),

"utf8"

);

function createWorkers() {

}

gulp.task("build", function () {

mkdirp.sync("Build");

fs.writeFileSync(

"Build/package.json",

JSON.stringify({

type: "commonjs",

}),

"utf8"

);

glslToJavaScript(minifyShaders, "Build/minifyShaders.state");

createCesiumJs();

createSpecList();

createJsHintOptions();

return Promise.join(createWorkers(), createGalleryList());

});

gulp.task("build-watch", function () {

return gulp.watch(watchedFiles, gulp.series("build"));

});

gulp.task("build-ts", function () {

createTypeScriptDefinitions();

return Promise.resolve();

});

gulp.task("buildApps", function () {

return Promise.join(buildCesiumViewer(), buildSandcastle());

});

gulp.task("build-specs", function buildSpecs() {

});

gulp.task("clean", function (done) {

rimraf.sync("Build");

globby.sync(filesToClean).forEach(function (file) {

rimraf.sync(file);

});

done();

});

function cloc() {

}

gulp.task("cloc", gulp.series("clean", cloc));

function combine() {

}

gulp.task("combine", gulp.series("build", combine));

gulp.task("default", gulp.series("combine"));

function combineRelease() {

}

gulp.task("combineRelease", gulp.series("build", combineRelease));

//Builds the documentation

function generateDocumentation() {

}

gulp.task("generateDocumentation", generateDocumentation);

gulp.task("generateDocumentation-watch", function () {

return generateDocumentation().done(function () {

console.log("Listening for changes in documentation...");

return gulp.watch(sourceFiles, gulp.series("generateDocumentation"));

});

});

gulp.task(

"release",

gulp.series(

"build",

"build-ts",

combine,

minifyRelease,

generateDocumentation

)

);

gulp.task(

"makeZipFile",

gulp.series("release", function () {

//For now we regenerate the JS glsl to force it to be unminified in the release zip

//See https://github.com/CesiumGS/cesium/pull/3106#discussion_r42793558 for discussion.

glslToJavaScript(false, "Build/minifyShaders.state");

var builtSrc = gulp.src(

[

"Build/Cesium/**",

"Build/CesiumUnminified/**",

"Build/Documentation/**",

],

{

base: ".",

}

);

var staticSrc = gulp.src(

[

"Apps/**",

"!Apps/Sandcastle/gallery/development/**",

"Source/**",

"Specs/**",

"ThirdParty/**",

"favicon.ico",

"gulpfile.cjs",

"server.cjs",

"package.json",

"LICENSE.md",

"CHANGES.md",

"README.md",

"web.config",

],

{

base: ".",

}

);

var indexSrc = gulp

.src("index.release.html")

.pipe(gulpRename("index.html"));

return mergeStream(builtSrc, staticSrc, indexSrc)

.pipe(

gulpTap(function (file) {

// Work around an issue with gulp-zip where archives generated on Windows do

// not properly have their directory executable mode set.

// see https://github.com/sindresorhus/gulp-zip/issues/64#issuecomment-205324031

if (file.isDirectory()) {

file.stat.mode = parseInt("40777", 8);

}

})

)

.pipe(gulpZip("Cesium-" + version + ".zip"))

.pipe(gulp.dest("."));

})

);

gulp.task(

"minify",

gulp.series("build", function () {

return combineJavaScript({

removePragmas: false,

optimizer: "uglify2",

outputDirectory: path.join("Build", "Cesium"),

});

})

);

function minifyRelease() {

}

gulp.task("minifyRelease", gulp.series("build", minifyRelease));

function isTravisPullRequest() {

}

gulp.task("deploy-s3", function (done) {

if (isTravisPullRequest()) {

console.log("Skipping deployment for non-pull request.");

done();

return;

}

var argv = yargs

.usage("Usage: deploy-s3 -b [Bucket Name] -d [Upload Directory]")

.demand(["b", "d"]).argv;

var uploadDirectory = argv.d;

var bucketName = argv.b;

var cacheControl = argv.c ? argv.c : "max-age=3600";

if (argv.confirm) {

// skip prompt for travis

deployCesium(bucketName, uploadDirectory, cacheControl, done);

return;

}

var iface = readline.createInterface({

input: process.stdin,

output: process.stdout,

});

// prompt for confirmation

iface.question(

"Files from your computer will be published to the " +

bucketName +

" bucket. Continue? [y/n] ",

function (answer) {

iface.close();

if (answer === "y") {

deployCesium(bucketName, uploadDirectory, cacheControl, done);

} else {

console.log("Deploy aborted by user.");

done();

}

}

);

});

// Deploy cesium to s3

function deployCesium(bucketName, uploadDirectory, cacheControl, done) {

}

function getMimeType(filename) {

}

// get all files currently in bucket asynchronously

function listAll(s3, bucketName, prefix, files, marker) {

}

gulp.task("deploy-set-version", function (done) {

var buildVersion = yargs.argv.buildVersion;

if (buildVersion) {

// NPM versions can only contain alphanumeric and hyphen characters

packageJson.version += "-" + buildVersion.replace(/[^[0-9A-Za-z-]/g, "");

fs.writeFileSync("package.json", JSON.stringify(packageJson, undefined, 2));

}

done();

});

gulp.task("deploy-status", function () {

if (isTravisPullRequest()) {

console.log("Skipping deployment status for non-pull request.");

return Promise.resolve();

}

var status = yargs.argv.status;

var message = yargs.argv.message;

var deployUrl = travisDeployUrl + process.env.TRAVIS_BRANCH + "/";

var zipUrl = deployUrl + "Cesium-" + packageJson.version + ".zip";

var npmUrl = deployUrl + "cesium-" + packageJson.version + ".tgz";

var coverageUrl =

travisDeployUrl + process.env.TRAVIS_BRANCH + "/Build/Coverage/index.html";

return Promise.join(

setStatus(status, deployUrl, message, "deployment"),

setStatus(status, zipUrl, message, "zip file"),

setStatus(status, npmUrl, message, "npm package"),

setStatus(status, coverageUrl, message, "coverage results")

);

});

function setStatus(state, targetUrl, description, context) {

}

gulp.task("coverage", function (done) {

var argv = yargs.argv;

var webglStub = argv.webglStub ? argv.webglStub : false;

var suppressPassed = argv.suppressPassed ? argv.suppressPassed : false;

var failTaskOnError = argv.failTaskOnError ? argv.failTaskOnError : false;

var folders = [];

var browsers = ["Chrome"];

if (argv.browsers) {

browsers = argv.browsers.split(",");

}

var karma = new Karma.Server(

{

configFile: karmaConfigFile,

browsers: browsers,

specReporter: {

suppressErrorSummary: false,

suppressFailed: false,

suppressPassed: suppressPassed,

suppressSkipped: true,

},

preprocessors: {

"Source/Core/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/DataSources/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/Renderer/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/Scene/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/Shaders/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/Widgets/**/*.js": ["karma-coverage-istanbul-instrumenter"],

"Source/Workers/**/*.js": ["karma-coverage-istanbul-instrumenter"],

},

coverageIstanbulInstrumenter: {

esModules: true,

},

reporters: ["spec", "coverage"],

coverageReporter: {

dir: "Build/Coverage",

subdir: function (browserName) {

folders.push(browserName);

return browserName;

},

includeAllSources: true,

},

client: {

captureConsole: verbose,

args: [undefined, undefined, undefined, webglStub, undefined],

},

},

function (e) {

var html = "<!doctype html><html><body><ul>";

folders.forEach(function (folder) {

html +=

'<li><a href="' +

encodeURIComponent(folder) +

'/index.html">' +

folder +

"</a></li>";

});

html += "</ul></body></html>";

fs.writeFileSync("Build/Coverage/index.html", html);

if (!process.env.TRAVIS) {

folders.forEach(function (dir) {

open("Build/Coverage/" + dir + "/index.html");

});

}

return done(failTaskOnError ? e : undefined);

}

);

karma.start();

});

gulp.task("test", function (done) {

var argv = yargs.argv;

var enableAllBrowsers = argv.all ? true : false;

var includeCategory = argv.include ? argv.include : "";

var excludeCategory = argv.exclude ? argv.exclude : "";

var webglValidation = argv.webglValidation ? argv.webglValidation : false;

var webglStub = argv.webglStub ? argv.webglStub : false;

var release = argv.release ? argv.release : false;

var failTaskOnError = argv.failTaskOnError ? argv.failTaskOnError : false;

var suppressPassed = argv.suppressPassed ? argv.suppressPassed : false;

var browsers = ["Chrome"];

if (argv.browsers) {

browsers = argv.browsers.split(",");

}

var files = [

{ pattern: "Specs/karma-main.js", included: true, type: "module" },

{ pattern: "Source/**", included: false, type: "module" },

{ pattern: "Specs/*.js", included: true, type: "module" },

{ pattern: "Specs/Core/**", included: true, type: "module" },

{ pattern: "Specs/Data/**", included: false },

{ pattern: "Specs/DataSources/**", included: true, type: "module" },

{ pattern: "Specs/Renderer/**", included: true, type: "module" },

{ pattern: "Specs/Scene/**", included: true, type: "module" },

{ pattern: "Specs/ThirdParty/**", included: true, type: "module" },

{ pattern: "Specs/Widgets/**", included: true, type: "module" },

{ pattern: "Specs/TestWorkers/**", included: false },

];

if (release) {

files = [

{ pattern: "Specs/Data/**", included: false },

{ pattern: "Specs/ThirdParty/**", included: true, type: "module" },

{ pattern: "Specs/TestWorkers/**", included: false },

{ pattern: "Build/Cesium/Cesium.js", included: true },

{ pattern: "Build/Cesium/**", included: false },

{ pattern: "Build/Specs/karma-main.js", included: true },

{ pattern: "Build/Specs/Specs.js", included: true },

];

}

var karma = new Karma.Server(

{

configFile: karmaConfigFile,

browsers: browsers,

specReporter: {

suppressErrorSummary: false,

suppressFailed: false,

suppressPassed: suppressPassed,

suppressSkipped: true,

},

detectBrowsers: {

enabled: enableAllBrowsers,

},

logLevel: verbose ? Karma.constants.LOG_INFO : Karma.constants.LOG_ERROR,

files: files,

client: {

captureConsole: verbose,

args: [

includeCategory,

excludeCategory,

webglValidation,

webglStub,

release,

],

},

},

function (e) {

return done(failTaskOnError ? e : undefined);

}

);

karma.start();

});

gulp.task("convertToModules", function () {

var requiresRegex = /([\s\S]*?(define|defineSuite|require)\((?:{[\s\S]*}, )?\[)([\S\s]*?)]([\s\S]*?function\s*)\(([\S\s]*?)\) {([\s\S]*)/;

var noModulesRegex = /([\s\S]*?(define|defineSuite|require)\((?:{[\s\S]*}, )?\[?)([\S\s]*?)]?([\s\S]*?function\s*)\(([\S\s]*?)\) {([\s\S]*)/;

var splitRegex = /,\s*/;

var fsReadFile = Promise.promisify(fs.readFile);

var fsWriteFile = Promise.promisify(fs.writeFile);

var files = globby.sync(filesToConvertES6);

return Promise.map(files, function (file) {

return fsReadFile(file).then(function (contents) {

contents = contents.toString();

if (contents.startsWith("import")) {

return;

}