error: (error: TypeScriptError) => {
if (error.tsFile) {
console.error('[' + gutil.colors.gray('gulp-typescript') + '] ' + gutil.colors.red(error.fullFilename + '(' + error.startPosition.line + ',' + error.startPosition.character + '): ') + 'error TS' + error.diagnostic.code + ' ' + flattenDiagnosticsVerbose(error.diagnostic.messageText));
} else {
console.error(error.message);
}
},
fileDownload.init().then((files) => {
if (files === null) {
gutil.log(gutil.colors.yellow("No files found on the specified startFolder path"));
} else {
gutil.log(gutil.colors.green("Retrieved all files from the folder."));
// Start retrieving the file content
let proms = [];
files.forEach(file => {
proms.push(fileDownload.download(file).then((uFile: IFileDownload) => {
var vinylFile: any = new gutil.File({
cwd: "",
base: "",
path: uFile.name,
contents: ((uFile.content instanceof Buffer) ? uFile.content : new Buffer(uFile.content))
});
stream.write(vinylFile);
}));
});
Promise.all(proms).then(data => {
if (options.verbose) {
gutil.log("And we're done...");
}
// End the file stream
stream.end();
});
}
}).catch(err => {
function log(): void {
const errors = _.flatten(allErrors);
const seen = new Set<string>();
errors.map(err => {
if (!seen.has(err)) {
seen.add(err);
util.log(`${util.colors.red('Error')}: ${err}`);
}
});
const regex = /^([^(]+)\((\d+),(\d+)\): (.*)$/;
const messages = errors
.map(err => regex.exec(err))
.filter(match => !!match)
.map(x => x as string[])
.map(([, path, line, column, message]) => ({ path, line: parseInt(line), column: parseInt(column), message }));
try {
fs.writeFileSync(buildLogPath, JSON.stringify(messages));
} catch (err) {
//noop
}
util.log(`Finished ${util.colors.green('compilation')} with ${errors.length} errors after ${util.colors.magenta((new Date().getTime() - startTime!) + ' ms')}`);
}
action: function (packageDescriptor: PackageDescriptor, packagePath: string, callback: (error?: Error) => void): void {
let packageTypingsFilePath = path.join(packagePath, "typings.json");
let packageTypingsPath = path.join(packagePath, targetPath);
if (!fs.existsSync(packageTypingsPath)) {
fs.mkdirSync(packageTypingsPath);
}
else {
rimraf.sync(packageTypingsPath + "/**/*");
}
Logger.verbose(`Linking typings for workspace package '${util.colors.cyan(packageDescriptor.name)}'`);
let typingFilePaths = getTypingFileReferences(require(packageTypingsFilePath));
for (let typingFilePathEntry in typingFilePaths) {
let typingFilePath = path.resolve(packagePath, typingFilePaths[typingFilePathEntry]);
let targetTypingFilePath = path.join(packageTypingsPath, typingFilePathEntry);
fs.mkdirSync(targetTypingFilePath);
fs.symlinkSync(typingFilePath, path.join(targetTypingFilePath, `${typingFilePathEntry}.d.ts`));
Logger.verbose(`Linked typing '${util.colors.cyan(typingFilePathEntry)}' (-> '${util.colors.blue(typingFilePath)}')`);
}
callback();
}
/**
* Creates a symbolic link between a package and a mapped path where the mapped path is external to the workspace.
*/
function linkExternalPackage(pluginBinding: NpmPluginBinding<NpmInstallOptions & NpmWorkspacePluginOptions>, packageName: string, packagePath: string, mappedPath: string) {
if (pluginBinding.options.registryMap[packageName]) {
Logger.warn(util.colors.yellow(`Package '${packageName}' has an entry in options.registryMap. Ignoring.`));
}
if (!path.isAbsolute(mappedPath)) {
mappedPath = path.normalize(path.join(pluginBinding.options.cwd, mappedPath));
}
if (mappedPath.indexOf(pluginBinding.options.cwd) >= 0) {
Logger.warn(util.colors.yellow(`externalWorkspacePackageMap['${packageName}'] is linking to a path inside the current workspace. Ignoring, but it should be removed.`));
}
let packageDescriptorPath = path.join(mappedPath, "package.json");
if (!fs.existsSync(packageDescriptorPath)) {
throw new Error(`externalWorkspacePackageMap['${packageName}'] is linking to a path that is not a packge. No 'package.json' could be found at '${mappedPath}'.`);
}
let packageDescriptor: PackageDescriptor = require(packageDescriptorPath);
if (packageDescriptor.name !== packageName) {
throw new Error(`externalWorkspacePackageMap['${packageName}'] is linking to a package that is named differently ('${packageDescriptor.name}').`);
}
pluginBinding.createPackageSymLink(packagePath, packageName, mappedPath);
Logger.verbose(`Linked '${util.colors.cyan(packageName)}' (-> '${util.colors.blue(mappedPath)}') - (${util.colors.bold("external")})`);
}
}).catch(err => {
if (typeof err.message !== "undefined") {
gutil.log(gutil.colors.red(`ERROR: ${err.message}`));
} else {
gutil.log(gutil.colors.red(`ERROR: ${JSON.stringify(err)}`));
}
});
error: (error: TypeScriptError, typescript: typeof ts) => {
console.error('[' + gutil.colors.gray('gulp-typescript') + '] '
+ gutil.colors.bgRed(error.diagnostic.code + '')
+ ' ' + gutil.colors.red(flattenDiagnosticsVerbose(error.diagnostic.messageText))
);
if (error.tsFile) {
console.error('> ' + gutil.colors.gray('file: ') + (fullFilename ? error.fullFilename : error.relativeFilename) + gutil.colors.gray(':'));
const lines = error.tsFile.text.split(/(\r\n|\r|\n)/);
const logLine = (lineIndex: number, errorStart: number, errorEnd?: number) => {
const line = lines[lineIndex];
if (errorEnd === undefined) errorEnd = line.length;
console.error('> ' + gutil.colors.gray('[' + lineIndex + '] ')
+ line.substring(0, errorStart)
+ gutil.colors.red(line.substring(errorStart, errorEnd))
+ line.substring(errorEnd)
);
}
for (let i = error.startPosition.line; i <= error.endPosition.line; i++) {
logLine(i,
i === error.startPosition.line ? error.startPosition.character - 1 : 0,
i === error.endPosition.line ? error.endPosition.character - 1 : undefined
);
}
}
},
return new Promise<void>((resolve, reject) => {
Logger.info(util.colors.bold(`Uninstalling workspace package '${util.colors.cyan(packageDescriptor.name)}'`));
try {
rimraf.sync(path.resolve(packagePath, "node_modules"));
let postUninstallActions: ConditionableAction<AsyncAction>[]
= _.union(pluginBinding.options.postUninstallActions, file["getWorkspace"]()["postUninstall"]);
if (postUninstallActions) {
Logger.verbose(`Running post-uninstall actions for workspace package '${util.colors.cyan(packageDescriptor.name)}'`);
executeAsynchronousActions(postUninstallActions, packageDescriptor, packagePath)
.then(resolve)
.catch((error) => {
handleError(error, packageDescriptor.name, pluginBinding.options.continueOnError, reject);
});
}
else {
resolve();
}
}
catch (error) {
handleError(error, packageDescriptor.name, pluginBinding.options.continueOnError, reject);
}
});
}).catch(error => {
if (typeof error === "string") {
gutil.log(gutil.colors.red(`ERROR: ${error}`));
} else {
gutil.log(gutil.colors.red('ERROR:'), JSON.stringify(error));
}
resolve(null);
});
export = (done: any) => {
util.log(util.colors.yellow(`
Warning!
Please use ${util.colors.green('npm run build.prod')}
Instead of ${util.colors.red('npm run build.prod.aot')} or ${util.colors.red('npm run build.prod.aot')}
They will be deleted soon!`));
done();
};
