2016-02-09 14:59:11 +01:00
|
|
|
/*---------------------------------------------------------------------------------------------
|
|
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
|
*--------------------------------------------------------------------------------------------*/
|
2016-09-19 10:22:57 +02:00
|
|
|
'use strict';
|
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
const perf = require('./vs/base/common/performance');
|
2017-11-06 18:50:57 +01:00
|
|
|
perf.mark('main:started');
|
|
|
|
|
2016-02-09 14:59:11 +01:00
|
|
|
// Perf measurements
|
2016-11-16 12:25:30 +01:00
|
|
|
global.perfStartTime = Date.now();
|
2016-02-09 14:59:11 +01:00
|
|
|
|
2018-03-13 07:39:38 +01:00
|
|
|
Error.stackTraceLimit = 100; // increase number of stack frames (from 10, https://github.com/v8/v8/wiki/Stack-Trace-API)
|
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
const fs = require('fs');
|
|
|
|
const path = require('path');
|
|
|
|
const product = require('../product.json');
|
|
|
|
const appRoot = path.dirname(__dirname);
|
|
|
|
|
|
|
|
function getApplicationPath() {
|
|
|
|
if (process.env['VSCODE_DEV']) {
|
|
|
|
return appRoot;
|
|
|
|
} else if (process.platform === 'darwin') {
|
|
|
|
return path.dirname(path.dirname(path.dirname(appRoot)));
|
|
|
|
} else {
|
|
|
|
return path.dirname(path.dirname(appRoot));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-18 10:09:50 +02:00
|
|
|
const portableDataName = product.portable || `${product.applicationName}-portable-data`;
|
|
|
|
const portableDataPath = process.env['VSCODE_PORTABLE'] || path.join(path.dirname(getApplicationPath()), portableDataName);
|
|
|
|
const isPortable = fs.existsSync(portableDataPath);
|
|
|
|
const portableTempPath = path.join(portableDataPath, 'tmp');
|
|
|
|
const isTempPortable = isPortable && fs.existsSync(portableTempPath);
|
|
|
|
|
|
|
|
if (isPortable) {
|
|
|
|
process.env['VSCODE_PORTABLE'] = portableDataPath;
|
|
|
|
} else {
|
|
|
|
delete process.env['VSCODE_PORTABLE'];
|
2018-06-13 17:13:55 +02:00
|
|
|
}
|
|
|
|
|
2018-06-18 10:09:50 +02:00
|
|
|
if (isTempPortable) {
|
|
|
|
process.env[process.platform === 'win32' ? 'TEMP' : 'TMPDIR'] = portableTempPath;
|
2018-06-13 17:13:55 +02:00
|
|
|
}
|
|
|
|
|
2018-01-09 17:04:02 +01:00
|
|
|
//#region Add support for using node_modules.asar
|
|
|
|
(function () {
|
|
|
|
const path = require('path');
|
|
|
|
const Module = require('module');
|
|
|
|
const NODE_MODULES_PATH = path.join(__dirname, '../node_modules');
|
|
|
|
const NODE_MODULES_ASAR_PATH = NODE_MODULES_PATH + '.asar';
|
|
|
|
|
|
|
|
const originalResolveLookupPaths = Module._resolveLookupPaths;
|
2018-03-19 12:59:32 +01:00
|
|
|
Module._resolveLookupPaths = function (request, parent, newReturn) {
|
|
|
|
const result = originalResolveLookupPaths(request, parent, newReturn);
|
2018-01-09 17:04:02 +01:00
|
|
|
|
2018-03-19 12:59:32 +01:00
|
|
|
const paths = newReturn ? result : result[1];
|
2018-01-09 17:04:02 +01:00
|
|
|
for (let i = 0, len = paths.length; i < len; i++) {
|
|
|
|
if (paths[i] === NODE_MODULES_PATH) {
|
|
|
|
paths.splice(i, 0, NODE_MODULES_ASAR_PATH);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
};
|
|
|
|
})();
|
|
|
|
//#endregion
|
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
const app = require('electron').app;
|
2018-06-08 18:32:49 +02:00
|
|
|
|
|
|
|
// TODO@Ben Electron 2.0.x: prevent localStorage migration from SQLite to LevelDB due to issues
|
|
|
|
app.commandLine.appendSwitch('disable-mojo-local-storage');
|
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
const minimist = require('minimist');
|
|
|
|
const paths = require('./paths');
|
2016-02-09 14:59:11 +01:00
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
const args = minimist(process.argv, {
|
2018-06-13 15:53:26 +02:00
|
|
|
string: [
|
|
|
|
'user-data-dir',
|
|
|
|
'locale',
|
|
|
|
'js-flags',
|
|
|
|
'max-memory'
|
|
|
|
]
|
2016-08-26 16:47:57 +02:00
|
|
|
});
|
|
|
|
|
2018-06-13 15:53:26 +02:00
|
|
|
//#region NLS
|
2016-03-15 16:14:59 +01:00
|
|
|
function stripComments(content) {
|
2018-01-25 21:13:24 +01:00
|
|
|
let regexp = /("(?:[^\\\"]*(?:\\.)?)*")|('(?:[^\\\']*(?:\\.)?)*')|(\/\*(?:\r?\n|.)*?\*\/)|(\/{2,}.*?(?:(?:\r?\n)|$))/g;
|
|
|
|
let result = content.replace(regexp, function (match, m1, m2, m3, m4) {
|
2016-03-15 16:14:59 +01:00
|
|
|
// Only one of m1, m2, m3, m4 matches
|
|
|
|
if (m3) {
|
|
|
|
// A block comment. Replace with nothing
|
|
|
|
return '';
|
2018-01-25 21:13:24 +01:00
|
|
|
} else if (m4) {
|
2016-03-15 16:14:59 +01:00
|
|
|
// A line comment. If it ends in \r?\n then keep it.
|
2018-01-25 21:13:24 +01:00
|
|
|
let length_1 = m4.length;
|
2016-03-15 16:14:59 +01:00
|
|
|
if (length_1 > 2 && m4[length_1 - 1] === '\n') {
|
|
|
|
return m4[length_1 - 2] === '\r' ? '\r\n' : '\n';
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return '';
|
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
} else {
|
2016-03-15 16:14:59 +01:00
|
|
|
// We match a string
|
|
|
|
return match;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
return result;
|
2016-07-27 09:31:07 +02:00
|
|
|
}
|
2016-03-15 16:14:59 +01:00
|
|
|
|
2018-06-13 15:53:26 +02:00
|
|
|
const mkdir = dir => new Promise((c, e) => fs.mkdir(dir, err => (err && err.code !== 'EEXIST') ? e(err) : c()));
|
|
|
|
const exists = file => new Promise(c => fs.exists(file, c));
|
|
|
|
const readFile = file => new Promise((c, e) => fs.readFile(file, 'utf8', (err, data) => err ? e(err) : c(data)));
|
|
|
|
const writeFile = (file, content) => new Promise((c, e) => fs.writeFile(file, content, 'utf8', err => err ? e(err) : c()));
|
|
|
|
const touch = file => new Promise((c, e) => { const d = new Date(); fs.utimes(file, d, d, err => err ? e(err) : c()); });
|
2018-01-25 21:13:24 +01:00
|
|
|
|
|
|
|
function mkdirp(dir) {
|
2018-06-13 15:53:26 +02:00
|
|
|
return mkdir(dir).then(null, err => {
|
|
|
|
if (err && err.code === 'ENOENT') {
|
|
|
|
const parent = path.dirname(dir);
|
2018-01-25 21:13:24 +01:00
|
|
|
|
2018-06-13 15:53:26 +02:00
|
|
|
if (parent !== dir) { // if not arrived at root
|
|
|
|
return mkdirp(parent).then(() => mkdir(dir));
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-06-13 15:53:26 +02:00
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
|
2018-06-13 15:53:26 +02:00
|
|
|
throw err;
|
2018-01-25 21:13:24 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-02-06 02:22:26 +01:00
|
|
|
function resolveJSFlags() {
|
2018-06-13 15:53:26 +02:00
|
|
|
const jsFlags = [];
|
|
|
|
|
2018-02-06 02:22:26 +01:00
|
|
|
if (args['js-flags']) {
|
2018-02-14 00:12:07 +01:00
|
|
|
jsFlags.push(args['js-flags']);
|
2018-02-06 02:22:26 +01:00
|
|
|
}
|
2018-06-13 15:53:26 +02:00
|
|
|
|
2018-02-14 00:12:07 +01:00
|
|
|
if (args['max-memory'] && !/max_old_space_size=(\d+)/g.exec(args['js-flags'])) {
|
|
|
|
jsFlags.push(`--max_old_space_size=${args['max-memory']}`);
|
2018-02-06 02:22:26 +01:00
|
|
|
}
|
2018-06-13 15:53:26 +02:00
|
|
|
|
|
|
|
return jsFlags.length > 0 ? jsFlags.join(' ') : null;
|
2018-02-06 02:22:26 +01:00
|
|
|
}
|
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
// Language tags are case insensitve however an amd loader is case sensitive
|
|
|
|
// To make this work on case preserving & insensitive FS we do the following:
|
|
|
|
// the language bundles have lower case language tags and we always lower case
|
|
|
|
// the locale we receive from the user or OS.
|
|
|
|
|
|
|
|
function getUserDefinedLocale() {
|
|
|
|
let locale = args['locale'];
|
|
|
|
if (locale) {
|
|
|
|
return Promise.resolve(locale.toLowerCase());
|
|
|
|
}
|
|
|
|
|
|
|
|
let userData = app.getPath('userData');
|
|
|
|
let localeConfig = path.join(userData, 'User', 'locale.json');
|
|
|
|
return exists(localeConfig).then((result) => {
|
|
|
|
if (result) {
|
|
|
|
return readFile(localeConfig).then((content) => {
|
|
|
|
content = stripComments(content);
|
|
|
|
try {
|
|
|
|
let value = JSON.parse(content).locale;
|
|
|
|
return value && typeof value === 'string' ? value.toLowerCase() : undefined;
|
|
|
|
} catch (e) {
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} else {
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
function getLanguagePackConfigurations() {
|
|
|
|
let userData = app.getPath('userData');
|
|
|
|
let configFile = path.join(userData, 'languagepacks.json');
|
|
|
|
try {
|
|
|
|
return require(configFile);
|
|
|
|
} catch (err) {
|
|
|
|
// Do nothing. If we can't read the file we have no
|
|
|
|
// language pack config.
|
|
|
|
}
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
|
|
|
|
function resolveLanguagePackLocale(config, locale) {
|
|
|
|
try {
|
|
|
|
while (locale) {
|
|
|
|
if (config[locale]) {
|
|
|
|
return locale;
|
|
|
|
} else {
|
|
|
|
let index = locale.lastIndexOf('-');
|
|
|
|
if (index > 0) {
|
|
|
|
locale = locale.substring(0, index);
|
|
|
|
} else {
|
|
|
|
return undefined;
|
2016-03-15 16:14:59 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
} catch (err) {
|
|
|
|
console.error('Resolving language pack configuration failed.', err);
|
2016-03-15 16:14:59 +01:00
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
return undefined;
|
|
|
|
}
|
2016-03-15 16:14:59 +01:00
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
function getNLSConfiguration(locale) {
|
2016-02-09 15:23:19 +01:00
|
|
|
if (locale === 'pseudo') {
|
2018-01-25 21:13:24 +01:00
|
|
|
return Promise.resolve({ locale: locale, availableLanguages: {}, pseudo: true });
|
2016-02-09 15:23:19 +01:00
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
|
2016-05-02 18:53:46 +02:00
|
|
|
if (process.env['VSCODE_DEV']) {
|
2018-01-25 21:13:24 +01:00
|
|
|
return Promise.resolve({ locale: locale, availableLanguages: {} });
|
2016-02-09 15:23:19 +01:00
|
|
|
}
|
2016-05-20 15:22:59 +02:00
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
let userData = app.getPath('userData');
|
|
|
|
|
2016-02-09 15:23:19 +01:00
|
|
|
// We have a built version so we have extracted nls file. Try to find
|
|
|
|
// the right file to use.
|
2016-05-20 15:22:59 +02:00
|
|
|
|
|
|
|
// Check if we have an English locale. If so fall to default since that is our
|
|
|
|
// English translation (we don't ship *.nls.en.json files)
|
|
|
|
if (locale && (locale == 'en' || locale.startsWith('en-'))) {
|
2018-01-25 21:13:24 +01:00
|
|
|
return Promise.resolve({ locale: locale, availableLanguages: {} });
|
2016-05-20 15:22:59 +02:00
|
|
|
}
|
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
let initialLocale = locale;
|
|
|
|
|
2016-05-20 15:22:59 +02:00
|
|
|
function resolveLocale(locale) {
|
|
|
|
while (locale) {
|
2018-01-25 21:13:24 +01:00
|
|
|
let candidate = path.join(__dirname, 'vs', 'code', 'electron-main', 'main.nls.') + locale + '.js';
|
2016-05-20 15:22:59 +02:00
|
|
|
if (fs.existsSync(candidate)) {
|
|
|
|
return { locale: initialLocale, availableLanguages: { '*': locale } };
|
2016-02-09 15:23:19 +01:00
|
|
|
} else {
|
2018-01-25 21:13:24 +01:00
|
|
|
let index = locale.lastIndexOf('-');
|
2016-05-20 15:22:59 +02:00
|
|
|
if (index > 0) {
|
|
|
|
locale = locale.substring(0, index);
|
|
|
|
} else {
|
2018-01-25 21:13:24 +01:00
|
|
|
locale = undefined;
|
2016-05-20 15:22:59 +02:00
|
|
|
}
|
2016-02-09 15:23:19 +01:00
|
|
|
}
|
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
return undefined;
|
2016-02-09 15:23:19 +01:00
|
|
|
}
|
|
|
|
|
2018-04-23 16:53:57 +02:00
|
|
|
perf.mark('nlsGeneration:start');
|
2018-06-13 15:53:26 +02:00
|
|
|
let defaultResult = function (locale) {
|
2018-04-23 16:53:57 +02:00
|
|
|
let isCoreLanguage = true;
|
|
|
|
if (locale) {
|
|
|
|
isCoreLanguage = ['de', 'es', 'fr', 'it', 'ja', 'ko', 'ru', 'zh-cn', 'zh-tw'].some((language) => {
|
|
|
|
return locale === language || locale.startsWith(language + '-');
|
|
|
|
});
|
|
|
|
}
|
|
|
|
if (isCoreLanguage) {
|
|
|
|
let result = resolveLocale(locale);
|
|
|
|
perf.mark('nlsGeneration:end');
|
|
|
|
return Promise.resolve(result);
|
2018-06-13 15:53:26 +02:00
|
|
|
} else {
|
2018-01-25 21:13:24 +01:00
|
|
|
perf.mark('nlsGeneration:end');
|
|
|
|
return Promise.resolve({ locale: locale, availableLanguages: {} });
|
2018-04-23 16:53:57 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
try {
|
2018-06-13 15:53:26 +02:00
|
|
|
let commit = product.commit;
|
2018-04-23 16:53:57 +02:00
|
|
|
if (!commit) {
|
|
|
|
return defaultResult(locale);
|
|
|
|
}
|
|
|
|
let configs = getLanguagePackConfigurations();
|
|
|
|
if (!configs) {
|
|
|
|
return defaultResult(locale);
|
|
|
|
}
|
|
|
|
let initialLocale = locale;
|
|
|
|
locale = resolveLanguagePackLocale(configs, locale);
|
|
|
|
if (!locale) {
|
|
|
|
return defaultResult(initialLocale);
|
|
|
|
}
|
|
|
|
let packConfig = configs[locale];
|
|
|
|
let mainPack;
|
|
|
|
if (!packConfig || typeof packConfig.hash !== 'string' || !packConfig.translations || typeof (mainPack = packConfig.translations['vscode']) !== 'string') {
|
|
|
|
return defaultResult(locale);
|
|
|
|
}
|
|
|
|
return exists(mainPack).then((fileExists) => {
|
|
|
|
if (!fileExists) {
|
|
|
|
return defaultResult(locale);
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
let packId = packConfig.hash + '.' + locale;
|
|
|
|
let cacheRoot = path.join(userData, 'clp', packId);
|
|
|
|
let coreLocation = path.join(cacheRoot, commit);
|
|
|
|
let translationsConfigFile = path.join(cacheRoot, 'tcf.json');
|
|
|
|
let result = {
|
|
|
|
locale: initialLocale,
|
|
|
|
availableLanguages: { '*': locale },
|
|
|
|
_languagePackId: packId,
|
|
|
|
_translationsConfigFile: translationsConfigFile,
|
|
|
|
_cacheRoot: cacheRoot,
|
|
|
|
_resolvedLanguagePackCoreLocation: coreLocation
|
|
|
|
};
|
|
|
|
return exists(coreLocation).then((fileExists) => {
|
|
|
|
if (fileExists) {
|
|
|
|
// We don't wait for this. No big harm if we can't touch
|
2018-06-13 15:53:26 +02:00
|
|
|
touch(coreLocation).catch(() => { });
|
2018-04-23 16:53:57 +02:00
|
|
|
perf.mark('nlsGeneration:end');
|
|
|
|
return result;
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
return mkdirp(coreLocation).then(() => {
|
|
|
|
return Promise.all([readFile(path.join(__dirname, 'nls.metadata.json')), readFile(mainPack)]);
|
|
|
|
}).then((values) => {
|
|
|
|
let metadata = JSON.parse(values[0]);
|
|
|
|
let packData = JSON.parse(values[1]).contents;
|
|
|
|
let bundles = Object.keys(metadata.bundles);
|
|
|
|
let writes = [];
|
|
|
|
for (let bundle of bundles) {
|
|
|
|
let modules = metadata.bundles[bundle];
|
|
|
|
let target = Object.create(null);
|
|
|
|
for (let module of modules) {
|
|
|
|
let keys = metadata.keys[module];
|
|
|
|
let defaultMessages = metadata.messages[module];
|
|
|
|
let translations = packData[module];
|
|
|
|
let targetStrings;
|
|
|
|
if (translations) {
|
|
|
|
targetStrings = [];
|
|
|
|
for (let i = 0; i < keys.length; i++) {
|
|
|
|
let elem = keys[i];
|
|
|
|
let key = typeof elem === 'string' ? elem : elem.key;
|
|
|
|
let translatedMessage = translations[key];
|
|
|
|
if (translatedMessage === undefined) {
|
|
|
|
translatedMessage = defaultMessages[i];
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
targetStrings.push(translatedMessage);
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
} else {
|
|
|
|
targetStrings = defaultMessages;
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
target[module] = targetStrings;
|
2018-01-25 21:13:24 +01:00
|
|
|
}
|
2018-04-23 16:53:57 +02:00
|
|
|
writes.push(writeFile(path.join(coreLocation, bundle.replace(/\//g, '!') + '.nls.json'), JSON.stringify(target)));
|
|
|
|
}
|
|
|
|
writes.push(writeFile(translationsConfigFile, JSON.stringify(packConfig.translations)));
|
|
|
|
return Promise.all(writes);
|
|
|
|
}).then(() => {
|
|
|
|
perf.mark('nlsGeneration:end');
|
|
|
|
return result;
|
|
|
|
}).catch((err) => {
|
|
|
|
console.error('Generating translation files failed.', err);
|
|
|
|
return defaultResult(locale);
|
2018-01-25 21:13:24 +01:00
|
|
|
});
|
|
|
|
});
|
2018-04-23 16:53:57 +02:00
|
|
|
});
|
|
|
|
} catch (err) {
|
|
|
|
console.error('Generating translation files failed.', err);
|
|
|
|
return defaultResult(locale);
|
2016-05-20 15:22:59 +02:00
|
|
|
}
|
2016-02-09 15:23:19 +01:00
|
|
|
}
|
2018-06-13 15:53:26 +02:00
|
|
|
//#endregion
|
2016-02-09 15:23:19 +01:00
|
|
|
|
2018-06-13 15:53:26 +02:00
|
|
|
//#region Cached Data Dir
|
2016-12-21 11:42:46 +01:00
|
|
|
function getNodeCachedDataDir() {
|
2017-11-23 10:53:25 +01:00
|
|
|
// flag to disable cached data support
|
|
|
|
if (process.argv.indexOf('--no-cached-data') > 0) {
|
|
|
|
return Promise.resolve(undefined);
|
|
|
|
}
|
2016-12-21 11:42:46 +01:00
|
|
|
|
|
|
|
// IEnvironmentService.isBuilt
|
|
|
|
if (process.env['VSCODE_DEV']) {
|
2016-12-21 14:26:10 +01:00
|
|
|
return Promise.resolve(undefined);
|
2016-12-21 11:42:46 +01:00
|
|
|
}
|
|
|
|
|
2017-04-05 09:21:02 +02:00
|
|
|
// find commit id
|
2018-06-13 15:53:26 +02:00
|
|
|
let commit = product.commit;
|
2018-01-25 21:13:24 +01:00
|
|
|
if (!commit) {
|
2017-04-05 09:21:02 +02:00
|
|
|
return Promise.resolve(undefined);
|
|
|
|
}
|
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
let dir = path.join(app.getPath('userData'), 'CachedData', commit);
|
2016-12-21 11:42:46 +01:00
|
|
|
|
2017-06-20 16:21:44 +02:00
|
|
|
return mkdirp(dir).then(undefined, function () { /*ignore*/ });
|
2017-01-27 20:44:00 +01:00
|
|
|
}
|
2018-06-13 15:53:26 +02:00
|
|
|
//#endregion
|
2017-01-27 20:44:00 +01:00
|
|
|
|
2018-06-13 17:13:55 +02:00
|
|
|
function getUserDataPath() {
|
2018-06-18 10:09:50 +02:00
|
|
|
if (isPortable) {
|
|
|
|
return path.join(portableDataPath, 'user-data');
|
2018-06-13 17:13:55 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return path.resolve(args['user-data-dir'] || paths.getDefaultUserDataPath(process.platform));
|
|
|
|
}
|
|
|
|
|
2016-10-22 12:41:35 +02:00
|
|
|
// Set userData path before app 'ready' event and call to process.chdir
|
2018-06-13 17:13:55 +02:00
|
|
|
app.setPath('userData', getUserDataPath());
|
2016-10-22 12:41:35 +02:00
|
|
|
|
2016-04-07 09:23:27 +02:00
|
|
|
// Update cwd based on environment and platform
|
2016-02-09 14:59:11 +01:00
|
|
|
try {
|
2016-04-07 09:23:27 +02:00
|
|
|
if (process.platform === 'win32') {
|
2018-01-25 21:13:24 +01:00
|
|
|
process.env['VSCODE_CWD'] = process.cwd(); // remember as environment letiable
|
2016-04-07 09:23:27 +02:00
|
|
|
process.chdir(path.dirname(app.getPath('exe'))); // always set application folder as cwd
|
2016-05-02 18:53:46 +02:00
|
|
|
} else if (process.env['VSCODE_CWD']) {
|
|
|
|
process.chdir(process.env['VSCODE_CWD']);
|
2016-02-09 14:59:11 +01:00
|
|
|
}
|
|
|
|
} catch (err) {
|
2016-04-07 09:23:27 +02:00
|
|
|
console.error(err);
|
2016-02-09 14:59:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Mac: when someone drops a file to the not-yet running VSCode, the open-file event fires even before
|
|
|
|
// the app-ready event. We listen very early for open-file and remember this upon startup as path to open.
|
|
|
|
global.macOpenFiles = [];
|
2016-04-07 09:23:27 +02:00
|
|
|
app.on('open-file', function (event, path) {
|
2016-02-09 14:59:11 +01:00
|
|
|
global.macOpenFiles.push(path);
|
|
|
|
});
|
|
|
|
|
2018-01-25 21:13:24 +01:00
|
|
|
let openUrls = [];
|
|
|
|
let onOpenUrl = function (event, url) {
|
2016-09-16 12:21:41 +02:00
|
|
|
event.preventDefault();
|
|
|
|
openUrls.push(url);
|
|
|
|
};
|
|
|
|
|
2016-09-19 10:22:57 +02:00
|
|
|
app.on('will-finish-launching', function () {
|
|
|
|
app.on('open-url', onOpenUrl);
|
|
|
|
});
|
2016-09-16 12:21:41 +02:00
|
|
|
|
2016-09-19 10:22:57 +02:00
|
|
|
global.getOpenUrls = function () {
|
2016-09-16 12:21:41 +02:00
|
|
|
app.removeListener('open-url', onOpenUrl);
|
|
|
|
return openUrls;
|
|
|
|
};
|
|
|
|
|
2016-12-21 12:46:01 +01:00
|
|
|
// use '<UserData>/CachedData'-directory to store
|
|
|
|
// node/v8 cached data.
|
2018-01-25 21:13:24 +01:00
|
|
|
let nodeCachedDataDir = getNodeCachedDataDir().then(function (value) {
|
2016-12-21 14:26:10 +01:00
|
|
|
if (value) {
|
2017-04-21 10:42:20 +02:00
|
|
|
// store the data directory
|
2016-12-21 14:26:10 +01:00
|
|
|
process.env['VSCODE_NODE_CACHED_DATA_DIR_' + process.pid] = value;
|
2017-04-21 10:42:20 +02:00
|
|
|
|
|
|
|
// tell v8 to not be lazy when parsing JavaScript. Generally this makes startup slower
|
|
|
|
// but because we generate cached data it makes subsequent startups much faster
|
2018-02-06 02:22:26 +01:00
|
|
|
let existingJSFlags = resolveJSFlags();
|
|
|
|
app.commandLine.appendSwitch('--js-flags', existingJSFlags ? existingJSFlags + ' --nolazy' : '--nolazy');
|
2016-12-21 14:26:10 +01:00
|
|
|
}
|
2018-01-25 21:13:24 +01:00
|
|
|
return value;
|
|
|
|
});
|
|
|
|
|
|
|
|
let nlsConfiguration = undefined;
|
|
|
|
let userDefinedLocale = getUserDefinedLocale();
|
|
|
|
userDefinedLocale.then((locale) => {
|
|
|
|
if (locale && !nlsConfiguration) {
|
|
|
|
nlsConfiguration = getNLSConfiguration(locale);
|
|
|
|
}
|
2016-12-21 11:42:46 +01:00
|
|
|
});
|
|
|
|
|
2018-02-06 02:22:26 +01:00
|
|
|
let jsFlags = resolveJSFlags();
|
|
|
|
if (jsFlags) {
|
|
|
|
app.commandLine.appendSwitch('--js-flags', jsFlags);
|
|
|
|
}
|
|
|
|
|
2017-06-09 10:34:35 +02:00
|
|
|
// Load our code once ready
|
|
|
|
app.once('ready', function () {
|
2017-11-06 18:50:57 +01:00
|
|
|
perf.mark('main:appReady');
|
2018-01-25 21:13:24 +01:00
|
|
|
Promise.all([nodeCachedDataDir, userDefinedLocale]).then((values) => {
|
|
|
|
let locale = values[1];
|
|
|
|
if (locale && !nlsConfiguration) {
|
|
|
|
nlsConfiguration = getNLSConfiguration(locale);
|
|
|
|
}
|
|
|
|
if (!nlsConfiguration) {
|
|
|
|
nlsConfiguration = Promise.resolve(undefined);
|
|
|
|
}
|
|
|
|
// We first need to test a user defined locale. If it fails we try the app locale.
|
|
|
|
// If that fails we fall back to English.
|
|
|
|
nlsConfiguration.then((nlsConfig) => {
|
|
|
|
let boot = (nlsConfig) => {
|
|
|
|
process.env['VSCODE_NLS_CONFIG'] = JSON.stringify(nlsConfig);
|
|
|
|
require('./bootstrap-amd').bootstrap('vs/code/electron-main/main');
|
|
|
|
};
|
|
|
|
// We recevied a valid nlsConfig from a user defined locale
|
|
|
|
if (nlsConfig) {
|
|
|
|
boot(nlsConfig);
|
|
|
|
} else {
|
|
|
|
// Try to use the app locale. Please note that the app locale is only
|
|
|
|
// valid after we have received the app ready event. This is why the
|
|
|
|
// code is here.
|
|
|
|
let appLocale = app.getLocale();
|
|
|
|
if (!appLocale) {
|
|
|
|
boot({ locale: 'en', availableLanguages: {} });
|
|
|
|
} else {
|
|
|
|
// See above the comment about the loader and case sensitiviness
|
2018-02-02 10:37:05 +01:00
|
|
|
appLocale = appLocale.toLowerCase();
|
2018-01-25 21:13:24 +01:00
|
|
|
getNLSConfiguration(appLocale).then((nlsConfig) => {
|
|
|
|
if (!nlsConfig) {
|
|
|
|
nlsConfig = { locale: appLocale, availableLanguages: {} };
|
|
|
|
}
|
|
|
|
boot(nlsConfig);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2017-06-09 10:34:35 +02:00
|
|
|
}, console.error);
|
2016-12-21 11:42:46 +01:00
|
|
|
});
|