229 lines
9.0 KiB
JavaScript
229 lines
9.0 KiB
JavaScript
"use strict";
|
|
const path = require("path");
|
|
const loaderUtils = require("loader-utils");
|
|
const fs = require("fs");
|
|
const AddWorkerEntryPointPlugin_1 = require("./plugins/AddWorkerEntryPointPlugin");
|
|
const INCLUDE_LOADER_PATH = require.resolve('./loaders/include');
|
|
const EDITOR_MODULE = {
|
|
label: 'editorWorkerService',
|
|
entry: undefined,
|
|
worker: {
|
|
id: 'vs/editor/editor',
|
|
entry: 'vs/editor/editor.worker'
|
|
}
|
|
};
|
|
/**
|
|
* Return a resolved path for a given Monaco file.
|
|
*/
|
|
function resolveMonacoPath(filePath, monacoEditorPath) {
|
|
if (monacoEditorPath) {
|
|
return require.resolve(path.join(monacoEditorPath, 'esm', filePath));
|
|
}
|
|
try {
|
|
return require.resolve(path.join('monaco-editor/esm', filePath));
|
|
}
|
|
catch (err) { }
|
|
try {
|
|
return require.resolve(path.join(process.cwd(), 'node_modules/monaco-editor/esm', filePath));
|
|
}
|
|
catch (err) { }
|
|
return require.resolve(filePath);
|
|
}
|
|
/**
|
|
* Return the interpolated final filename for a worker, respecting the file name template.
|
|
*/
|
|
function getWorkerFilename(filename, entry, monacoEditorPath) {
|
|
return loaderUtils.interpolateName({ resourcePath: entry }, filename, {
|
|
content: fs.readFileSync(resolveMonacoPath(entry, monacoEditorPath))
|
|
});
|
|
}
|
|
function getEditorMetadata(monacoEditorPath) {
|
|
const metadataPath = resolveMonacoPath('metadata.js', monacoEditorPath);
|
|
return require(metadataPath);
|
|
}
|
|
function resolveDesiredFeatures(metadata, userFeatures) {
|
|
const featuresById = {};
|
|
metadata.features.forEach((feature) => (featuresById[feature.label] = feature));
|
|
function notContainedIn(arr) {
|
|
return (element) => arr.indexOf(element) === -1;
|
|
}
|
|
let featuresIds;
|
|
if (userFeatures && userFeatures.length) {
|
|
const excludedFeatures = userFeatures.filter((f) => f[0] === '!').map((f) => f.slice(1));
|
|
if (excludedFeatures.length) {
|
|
featuresIds = Object.keys(featuresById).filter(notContainedIn(excludedFeatures));
|
|
}
|
|
else {
|
|
featuresIds = userFeatures;
|
|
}
|
|
}
|
|
else {
|
|
featuresIds = Object.keys(featuresById);
|
|
}
|
|
return coalesce(featuresIds.map((id) => featuresById[id]));
|
|
}
|
|
function resolveDesiredLanguages(metadata, userLanguages, userCustomLanguages) {
|
|
const languagesById = {};
|
|
metadata.languages.forEach((language) => (languagesById[language.label] = language));
|
|
const languages = userLanguages || Object.keys(languagesById);
|
|
return coalesce(languages.map((id) => languagesById[id])).concat(userCustomLanguages || []);
|
|
}
|
|
class MonacoEditorWebpackPlugin {
|
|
constructor(options = {}) {
|
|
const monacoEditorPath = options.monacoEditorPath;
|
|
const metadata = getEditorMetadata(monacoEditorPath);
|
|
const languages = resolveDesiredLanguages(metadata, options.languages, options.customLanguages);
|
|
const features = resolveDesiredFeatures(metadata, options.features);
|
|
this.options = {
|
|
languages,
|
|
features,
|
|
filename: options.filename || '[name].worker.js',
|
|
monacoEditorPath,
|
|
publicPath: options.publicPath || '',
|
|
globalAPI: options.globalAPI || false
|
|
};
|
|
}
|
|
apply(compiler) {
|
|
const { languages, features, filename, monacoEditorPath, publicPath, globalAPI } = this.options;
|
|
const compilationPublicPath = getCompilationPublicPath(compiler);
|
|
const modules = [EDITOR_MODULE].concat(languages).concat(features);
|
|
const workers = [];
|
|
modules.forEach((module) => {
|
|
if (module.worker) {
|
|
workers.push({
|
|
label: module.label,
|
|
id: module.worker.id,
|
|
entry: module.worker.entry
|
|
});
|
|
}
|
|
});
|
|
const rules = createLoaderRules(languages, features, workers, filename, monacoEditorPath, publicPath, compilationPublicPath, globalAPI);
|
|
const plugins = createPlugins(compiler, workers, filename, monacoEditorPath);
|
|
addCompilerRules(compiler, rules);
|
|
addCompilerPlugins(compiler, plugins);
|
|
}
|
|
}
|
|
function addCompilerRules(compiler, rules) {
|
|
const compilerOptions = compiler.options;
|
|
if (!compilerOptions.module) {
|
|
compilerOptions.module = { rules: rules };
|
|
}
|
|
else {
|
|
const moduleOptions = compilerOptions.module;
|
|
moduleOptions.rules = (moduleOptions.rules || []).concat(rules);
|
|
}
|
|
}
|
|
function addCompilerPlugins(compiler, plugins) {
|
|
plugins.forEach((plugin) => plugin.apply(compiler));
|
|
}
|
|
function getCompilationPublicPath(compiler) {
|
|
if (compiler.options.output && compiler.options.output.publicPath) {
|
|
if (typeof compiler.options.output.publicPath === 'string') {
|
|
return compiler.options.output.publicPath;
|
|
}
|
|
else {
|
|
console.warn(`Cannot handle options.publicPath (expected a string)`);
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
function createLoaderRules(languages, features, workers, filename, monacoEditorPath, pluginPublicPath, compilationPublicPath, globalAPI) {
|
|
if (!languages.length && !features.length) {
|
|
return [];
|
|
}
|
|
const languagePaths = flatArr(coalesce(languages.map((language) => language.entry)));
|
|
const featurePaths = flatArr(coalesce(features.map((feature) => feature.entry)));
|
|
const workerPaths = fromPairs(workers.map(({ label, entry }) => [label, getWorkerFilename(filename, entry, monacoEditorPath)]));
|
|
if (workerPaths['typescript']) {
|
|
// javascript shares the same worker
|
|
workerPaths['javascript'] = workerPaths['typescript'];
|
|
}
|
|
if (workerPaths['css']) {
|
|
// scss and less share the same worker
|
|
workerPaths['less'] = workerPaths['css'];
|
|
workerPaths['scss'] = workerPaths['css'];
|
|
}
|
|
if (workerPaths['html']) {
|
|
// handlebars, razor and html share the same worker
|
|
workerPaths['handlebars'] = workerPaths['html'];
|
|
workerPaths['razor'] = workerPaths['html'];
|
|
}
|
|
// Determine the public path from which to load worker JS files. In order of precedence:
|
|
// 1. Plugin-specific public path.
|
|
// 2. Dynamic runtime public path.
|
|
// 3. Compilation public path.
|
|
const pathPrefix = Boolean(pluginPublicPath)
|
|
? JSON.stringify(pluginPublicPath)
|
|
: `typeof __webpack_public_path__ === 'string' ` +
|
|
`? __webpack_public_path__ ` +
|
|
`: ${JSON.stringify(compilationPublicPath)}`;
|
|
const globals = {
|
|
MonacoEnvironment: `(function (paths) {
|
|
function stripTrailingSlash(str) {
|
|
return str.replace(/\\/$/, '');
|
|
}
|
|
return {
|
|
globalAPI: ${globalAPI},
|
|
getWorkerUrl: function (moduleId, label) {
|
|
var pathPrefix = ${pathPrefix};
|
|
var result = (pathPrefix ? stripTrailingSlash(pathPrefix) + '/' : '') + paths[label];
|
|
if (/^((http:)|(https:)|(file:)|(\\/\\/))/.test(result)) {
|
|
var currentUrl = String(window.location);
|
|
var currentOrigin = currentUrl.substr(0, currentUrl.length - window.location.hash.length - window.location.search.length - window.location.pathname.length);
|
|
if (result.substring(0, currentOrigin.length) !== currentOrigin) {
|
|
if(/^(\\/\\/)/.test(result)) {
|
|
result = window.location.protocol + result
|
|
}
|
|
var js = '/*' + label + '*/importScripts("' + result + '");';
|
|
var blob = new Blob([js], { type: 'application/javascript' });
|
|
return URL.createObjectURL(blob);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
})(${JSON.stringify(workerPaths, null, 2)})`
|
|
};
|
|
const options = {
|
|
globals,
|
|
pre: featurePaths.map((importPath) => resolveMonacoPath(importPath, monacoEditorPath)),
|
|
post: languagePaths.map((importPath) => resolveMonacoPath(importPath, monacoEditorPath))
|
|
};
|
|
return [
|
|
{
|
|
test: /esm[/\\]vs[/\\]editor[/\\]editor.(api|main).js/,
|
|
use: [
|
|
{
|
|
loader: INCLUDE_LOADER_PATH,
|
|
options
|
|
}
|
|
]
|
|
}
|
|
];
|
|
}
|
|
function createPlugins(compiler, workers, filename, monacoEditorPath) {
|
|
var _a;
|
|
const webpack = (_a = compiler.webpack) !== null && _a !== void 0 ? _a : require('webpack');
|
|
return [].concat(workers.map(({ id, entry }) => new AddWorkerEntryPointPlugin_1.AddWorkerEntryPointPlugin({
|
|
id,
|
|
entry: resolveMonacoPath(entry, monacoEditorPath),
|
|
filename: getWorkerFilename(filename, entry, monacoEditorPath),
|
|
plugins: [new webpack.optimize.LimitChunkCountPlugin({ maxChunks: 1 })]
|
|
})));
|
|
}
|
|
function flatArr(items) {
|
|
return items.reduce((acc, item) => {
|
|
if (Array.isArray(item)) {
|
|
return [].concat(acc).concat(item);
|
|
}
|
|
return [].concat(acc).concat([item]);
|
|
}, []);
|
|
}
|
|
function fromPairs(values) {
|
|
return values.reduce((acc, [key, value]) => Object.assign(acc, { [key]: value }), {});
|
|
}
|
|
function coalesce(array) {
|
|
return array.filter(Boolean);
|
|
}
|
|
module.exports = MonacoEditorWebpackPlugin;
|