311 lines
10 KiB
JavaScript
311 lines
10 KiB
JavaScript
|
"use strict";
|
||
|
|
/*---------------------------------------------------------------------------------------------
|
||
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||
|
|
*--------------------------------------------------------------------------------------------*/
|
||
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||
|
|
exports.incremental = incremental;
|
||
|
|
exports.debounce = debounce;
|
||
|
|
exports.fixWin32DirectoryPermissions = fixWin32DirectoryPermissions;
|
||
|
|
exports.setExecutableBit = setExecutableBit;
|
||
|
|
exports.toFileUri = toFileUri;
|
||
|
|
exports.skipDirectories = skipDirectories;
|
||
|
|
exports.cleanNodeModules = cleanNodeModules;
|
||
|
|
exports.loadSourcemaps = loadSourcemaps;
|
||
|
|
exports.stripSourceMappingURL = stripSourceMappingURL;
|
||
|
|
exports.$if = $if;
|
||
|
|
exports.appendOwnPathSourceURL = appendOwnPathSourceURL;
|
||
|
|
exports.rewriteSourceMappingURL = rewriteSourceMappingURL;
|
||
|
|
exports.rimraf = rimraf;
|
||
|
|
exports.rreddir = rreddir;
|
||
|
|
exports.ensureDir = ensureDir;
|
||
|
|
exports.rebase = rebase;
|
||
|
|
exports.filter = filter;
|
||
|
|
exports.streamToPromise = streamToPromise;
|
||
|
|
exports.getElectronVersion = getElectronVersion;
|
||
|
|
const es = require("event-stream");
|
||
|
|
const _debounce = require("debounce");
|
||
|
|
const _filter = require("gulp-filter");
|
||
|
|
const rename = require("gulp-rename");
|
||
|
|
const path = require("path");
|
||
|
|
const fs = require("fs");
|
||
|
|
const _rimraf = require("rimraf");
|
||
|
|
const url_1 = require("url");
|
||
|
|
const ternaryStream = require("ternary-stream");
|
||
|
|
const root = path.dirname(path.dirname(__dirname));
|
||
|
|
const NoCancellationToken = { isCancellationRequested: () => false };
|
||
|
|
function incremental(streamProvider, initial, supportsCancellation) {
|
||
|
|
const input = es.through();
|
||
|
|
const output = es.through();
|
||
|
|
let state = 'idle';
|
||
|
|
let buffer = Object.create(null);
|
||
|
|
const token = !supportsCancellation ? undefined : { isCancellationRequested: () => Object.keys(buffer).length > 0 };
|
||
|
|
const run = (input, isCancellable) => {
|
||
|
|
state = 'running';
|
||
|
|
const stream = !supportsCancellation ? streamProvider() : streamProvider(isCancellable ? token : NoCancellationToken);
|
||
|
|
input
|
||
|
|
.pipe(stream)
|
||
|
|
.pipe(es.through(undefined, () => {
|
||
|
|
state = 'idle';
|
||
|
|
eventuallyRun();
|
||
|
|
}))
|
||
|
|
.pipe(output);
|
||
|
|
};
|
||
|
|
if (initial) {
|
||
|
|
run(initial, false);
|
||
|
|
}
|
||
|
|
const eventuallyRun = _debounce(() => {
|
||
|
|
const paths = Object.keys(buffer);
|
||
|
|
if (paths.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const data = paths.map(path => buffer[path]);
|
||
|
|
buffer = Object.create(null);
|
||
|
|
run(es.readArray(data), true);
|
||
|
|
}, 500);
|
||
|
|
input.on('data', (f) => {
|
||
|
|
buffer[f.path] = f;
|
||
|
|
if (state === 'idle') {
|
||
|
|
eventuallyRun();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function debounce(task, duration = 500) {
|
||
|
|
const input = es.through();
|
||
|
|
const output = es.through();
|
||
|
|
let state = 'idle';
|
||
|
|
const run = () => {
|
||
|
|
state = 'running';
|
||
|
|
task()
|
||
|
|
.pipe(es.through(undefined, () => {
|
||
|
|
const shouldRunAgain = state === 'stale';
|
||
|
|
state = 'idle';
|
||
|
|
if (shouldRunAgain) {
|
||
|
|
eventuallyRun();
|
||
|
|
}
|
||
|
|
}))
|
||
|
|
.pipe(output);
|
||
|
|
};
|
||
|
|
run();
|
||
|
|
const eventuallyRun = _debounce(() => run(), duration);
|
||
|
|
input.on('data', () => {
|
||
|
|
if (state === 'idle') {
|
||
|
|
eventuallyRun();
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
state = 'stale';
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function fixWin32DirectoryPermissions() {
|
||
|
|
if (!/win32/.test(process.platform)) {
|
||
|
|
return es.through();
|
||
|
|
}
|
||
|
|
return es.mapSync(f => {
|
||
|
|
if (f.stat && f.stat.isDirectory && f.stat.isDirectory()) {
|
||
|
|
f.stat.mode = 16877;
|
||
|
|
}
|
||
|
|
return f;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function setExecutableBit(pattern) {
|
||
|
|
const setBit = es.mapSync(f => {
|
||
|
|
if (!f.stat) {
|
||
|
|
f.stat = { isFile() { return true; } };
|
||
|
|
}
|
||
|
|
f.stat.mode = /* 100755 */ 33261;
|
||
|
|
return f;
|
||
|
|
});
|
||
|
|
if (!pattern) {
|
||
|
|
return setBit;
|
||
|
|
}
|
||
|
|
const input = es.through();
|
||
|
|
const filter = _filter(pattern, { restore: true });
|
||
|
|
const output = input
|
||
|
|
.pipe(filter)
|
||
|
|
.pipe(setBit)
|
||
|
|
.pipe(filter.restore);
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function toFileUri(filePath) {
|
||
|
|
const match = filePath.match(/^([a-z])\:(.*)$/i);
|
||
|
|
if (match) {
|
||
|
|
filePath = '/' + match[1].toUpperCase() + ':' + match[2];
|
||
|
|
}
|
||
|
|
return 'file://' + filePath.replace(/\\/g, '/');
|
||
|
|
}
|
||
|
|
function skipDirectories() {
|
||
|
|
return es.mapSync(f => {
|
||
|
|
if (!f.isDirectory()) {
|
||
|
|
return f;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function cleanNodeModules(rulePath) {
|
||
|
|
const rules = fs.readFileSync(rulePath, 'utf8')
|
||
|
|
.split(/\r?\n/g)
|
||
|
|
.map(line => line.trim())
|
||
|
|
.filter(line => line && !/^#/.test(line));
|
||
|
|
const excludes = rules.filter(line => !/^!/.test(line)).map(line => `!**/node_modules/${line}`);
|
||
|
|
const includes = rules.filter(line => /^!/.test(line)).map(line => `**/node_modules/${line.substr(1)}`);
|
||
|
|
const input = es.through();
|
||
|
|
const output = es.merge(input.pipe(_filter(['**', ...excludes])), input.pipe(_filter(includes)));
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function loadSourcemaps() {
|
||
|
|
const input = es.through();
|
||
|
|
const output = input
|
||
|
|
.pipe(es.map((f, cb) => {
|
||
|
|
if (f.sourceMap) {
|
||
|
|
cb(undefined, f);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (!f.contents) {
|
||
|
|
cb(undefined, f);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const contents = f.contents.toString('utf8');
|
||
|
|
const reg = /\/\/# sourceMappingURL=(.*)$/g;
|
||
|
|
let lastMatch = null;
|
||
|
|
let match = null;
|
||
|
|
while (match = reg.exec(contents)) {
|
||
|
|
lastMatch = match;
|
||
|
|
}
|
||
|
|
if (!lastMatch) {
|
||
|
|
f.sourceMap = {
|
||
|
|
version: '3',
|
||
|
|
names: [],
|
||
|
|
mappings: '',
|
||
|
|
sources: [f.relative.replace(/\\/g, '/')],
|
||
|
|
sourcesContent: [contents]
|
||
|
|
};
|
||
|
|
cb(undefined, f);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
f.contents = Buffer.from(contents.replace(/\/\/# sourceMappingURL=(.*)$/g, ''), 'utf8');
|
||
|
|
fs.readFile(path.join(path.dirname(f.path), lastMatch[1]), 'utf8', (err, contents) => {
|
||
|
|
if (err) {
|
||
|
|
return cb(err);
|
||
|
|
}
|
||
|
|
f.sourceMap = JSON.parse(contents);
|
||
|
|
cb(undefined, f);
|
||
|
|
});
|
||
|
|
}));
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function stripSourceMappingURL() {
|
||
|
|
const input = es.through();
|
||
|
|
const output = input
|
||
|
|
.pipe(es.mapSync(f => {
|
||
|
|
const contents = f.contents.toString('utf8');
|
||
|
|
f.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, ''), 'utf8');
|
||
|
|
return f;
|
||
|
|
}));
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
/** Splits items in the stream based on the predicate, sending them to onTrue if true, or onFalse otherwise */
|
||
|
|
function $if(test, onTrue, onFalse = es.through()) {
|
||
|
|
if (typeof test === 'boolean') {
|
||
|
|
return test ? onTrue : onFalse;
|
||
|
|
}
|
||
|
|
return ternaryStream(test, onTrue, onFalse);
|
||
|
|
}
|
||
|
|
/** Operator that appends the js files' original path a sourceURL, so debug locations map */
|
||
|
|
function appendOwnPathSourceURL() {
|
||
|
|
const input = es.through();
|
||
|
|
const output = input
|
||
|
|
.pipe(es.mapSync(f => {
|
||
|
|
if (!(f.contents instanceof Buffer)) {
|
||
|
|
throw new Error(`contents of ${f.path} are not a buffer`);
|
||
|
|
}
|
||
|
|
f.contents = Buffer.concat([f.contents, Buffer.from(`\n//# sourceURL=${(0, url_1.pathToFileURL)(f.path)}`)]);
|
||
|
|
return f;
|
||
|
|
}));
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function rewriteSourceMappingURL(sourceMappingURLBase) {
|
||
|
|
const input = es.through();
|
||
|
|
const output = input
|
||
|
|
.pipe(es.mapSync(f => {
|
||
|
|
const contents = f.contents.toString('utf8');
|
||
|
|
const str = `//# sourceMappingURL=${sourceMappingURLBase}/${path.dirname(f.relative).replace(/\\/g, '/')}/$1`;
|
||
|
|
f.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, str));
|
||
|
|
return f;
|
||
|
|
}));
|
||
|
|
return es.duplex(input, output);
|
||
|
|
}
|
||
|
|
function rimraf(dir) {
|
||
|
|
const result = () => new Promise((c, e) => {
|
||
|
|
let retries = 0;
|
||
|
|
const retry = () => {
|
||
|
|
_rimraf(dir, { maxBusyTries: 1 }, (err) => {
|
||
|
|
if (!err) {
|
||
|
|
return c();
|
||
|
|
}
|
||
|
|
if (err.code === 'ENOTEMPTY' && ++retries < 5) {
|
||
|
|
return setTimeout(() => retry(), 10);
|
||
|
|
}
|
||
|
|
return e(err);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
retry();
|
||
|
|
});
|
||
|
|
result.taskName = `clean-${path.basename(dir).toLowerCase()}`;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function _rreaddir(dirPath, prepend, result) {
|
||
|
|
const entries = fs.readdirSync(dirPath, { withFileTypes: true });
|
||
|
|
for (const entry of entries) {
|
||
|
|
if (entry.isDirectory()) {
|
||
|
|
_rreaddir(path.join(dirPath, entry.name), `${prepend}/${entry.name}`, result);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result.push(`${prepend}/${entry.name}`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function rreddir(dirPath) {
|
||
|
|
const result = [];
|
||
|
|
_rreaddir(dirPath, '', result);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function ensureDir(dirPath) {
|
||
|
|
if (fs.existsSync(dirPath)) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
ensureDir(path.dirname(dirPath));
|
||
|
|
fs.mkdirSync(dirPath);
|
||
|
|
}
|
||
|
|
function rebase(count) {
|
||
|
|
return rename(f => {
|
||
|
|
const parts = f.dirname ? f.dirname.split(/[\/\\]/) : [];
|
||
|
|
f.dirname = parts.slice(count).join(path.sep);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function filter(fn) {
|
||
|
|
const result = es.through(function (data) {
|
||
|
|
if (fn(data)) {
|
||
|
|
this.emit('data', data);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
result.restore.push(data);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
result.restore = es.through();
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function streamToPromise(stream) {
|
||
|
|
return new Promise((c, e) => {
|
||
|
|
stream.on('error', err => e(err));
|
||
|
|
stream.on('end', () => c());
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function getElectronVersion() {
|
||
|
|
const npmrc = fs.readFileSync(path.join(root, '.npmrc'), 'utf8');
|
||
|
|
const electronVersion = /^target="(.*)"$/m.exec(npmrc)[1];
|
||
|
|
const msBuildId = /^ms_build_id="(.*)"$/m.exec(npmrc)[1];
|
||
|
|
return { electronVersion, msBuildId };
|
||
|
|
}
|
||
|
|
//# sourceMappingURL=util.js.map
|