Initial commitmain

1 files changed, 408 insertions, 0 deletions

diff --git a/webpack.config.js b/webpack.config.js
new file mode 100644
index 0000000..430984e
--- /dev/null
+++ b/webpack.config.js
@@ -0,0 +1,408 @@
+// -----------------------------------------------------------------------------
+// This file is used to build the plugin file (.jpl) and plugin info (.json). It
+// is recommended not to edit this file as it would be overwritten when updating
+// the plugin framework. If you do make some changes, consider using an external
+// JS file and requiring it here to minimize the changes. That way when you
+// update, you can easily restore the functionality you've added.
+// -----------------------------------------------------------------------------
+
+ 
+
+const path = require('path');
+const crypto = require('crypto');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const CopyPlugin = require('copy-webpack-plugin');
+const tar = require('tar');
+const glob = require('glob');
+const execSync = require('child_process').execSync;
+
+// AUTO-GENERATED by updateCategories
+const allPossibleCategories = [{'name':'appearance'},{'name':'developer tools'},{'name':'productivity'},{'name':'themes'},{'name':'integrations'},{'name':'viewer'},{'name':'search'},{'name':'tags'},{'name':'editor'},{'name':'files'},{'name':'personal knowledge management'}];
+// AUTO-GENERATED by updateCategories
+
+const rootDir = path.resolve(__dirname);
+const userConfigFilename = './plugin.config.json';
+const userConfigPath = path.resolve(rootDir, userConfigFilename);
+const distDir = path.resolve(rootDir, 'dist');
+const srcDir = path.resolve(rootDir, 'src');
+const publishDir = path.resolve(rootDir, 'publish');
+
+const userConfig = {
+	extraScripts: [],
+	...(fs.pathExistsSync(userConfigPath) ? require(userConfigFilename) : {}),
+};
+
+const manifestPath = `${srcDir}/manifest.json`;
+const packageJsonPath = `${rootDir}/package.json`;
+const allPossibleScreenshotsType = ['jpg', 'jpeg', 'png', 'gif', 'webp'];
+const manifest = readManifest(manifestPath);
+const pluginArchiveFilePath = path.resolve(publishDir, `${manifest.id}.jpl`);
+const pluginInfoFilePath = path.resolve(publishDir, `${manifest.id}.json`);
+
+const { builtinModules } = require('node:module');
+
+// Webpack5 doesn't polyfill by default and displays a warning when attempting to require() built-in
+// node modules. Set these to false to prevent Webpack from warning about not polyfilling these modules.
+// We don't need to polyfill because the plugins run in Electron's Node environment.
+const moduleFallback = {};
+for (const moduleName of builtinModules) {
+	moduleFallback[moduleName] = false;
+}
+
+const getPackageJson = () => {
+	return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+};
+
+function validatePackageJson() {
+	const content = getPackageJson();
+	if (!content.name || content.name.indexOf('joplin-plugin-') !== 0) {
+		console.warn(chalk.yellow(`WARNING: To publish the plugin, the package name should start with "joplin-plugin-" (found "${content.name}") in ${packageJsonPath}`));
+	}
+
+	if (!content.keywords || content.keywords.indexOf('joplin-plugin') < 0) {
+		console.warn(chalk.yellow(`WARNING: To publish the plugin, the package keywords should include "joplin-plugin" (found "${JSON.stringify(content.keywords)}") in ${packageJsonPath}`));
+	}
+
+	if (content.scripts && content.scripts.postinstall) {
+		console.warn(chalk.yellow(`WARNING: package.json contains a "postinstall" script. It is recommended to use a "prepare" script instead so that it is executed before publish. In ${packageJsonPath}`));
+	}
+}
+
+function fileSha256(filePath) {
+	const content = fs.readFileSync(filePath);
+	return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+function currentGitInfo() {
+	try {
+		let branch = execSync('git rev-parse --abbrev-ref HEAD', { stdio: 'pipe' }).toString().trim();
+		const commit = execSync('git rev-parse HEAD', { stdio: 'pipe' }).toString().trim();
+		if (branch === 'HEAD') branch = 'master';
+		return `${branch}:${commit}`;
+	} catch (error) {
+		const messages = error.message ? error.message.split('\n') : [''];
+		console.info(chalk.cyan('Could not get git commit (not a git repo?):', messages[0].trim()));
+		console.info(chalk.cyan('Git information will not be stored in plugin info file'));
+		return '';
+	}
+}
+
+function validateCategories(categories) {
+	if (!categories) return null;
+	if ((categories.length !== new Set(categories).size)) throw new Error('Repeated categories are not allowed');
+	// eslint-disable-next-line github/array-foreach -- Old code before rule was applied
+	categories.forEach(category => {
+		if (!allPossibleCategories.map(category => { return category.name; }).includes(category)) throw new Error(`${category} is not a valid category. Please make sure that the category name is lowercase. Valid categories are: \n${allPossibleCategories.map(category => { return category.name; })}\n`);
+	});
+}
+
+function validateScreenshots(screenshots) {
+	if (!screenshots) return null;
+	for (const screenshot of screenshots) {
+		if (!screenshot.src) throw new Error('You must specify a src for each screenshot');
+
+		// Avoid attempting to download and verify URL screenshots.
+		if (screenshot.src.startsWith('https://') || screenshot.src.startsWith('http://')) {
+			continue;
+		}
+
+		const screenshotType = screenshot.src.split('.').pop();
+		if (!allPossibleScreenshotsType.includes(screenshotType)) throw new Error(`${screenshotType} is not a valid screenshot type. Valid types are: \n${allPossibleScreenshotsType}\n`);
+
+		const screenshotPath = path.resolve(rootDir, screenshot.src);
+
+		// Max file size is 1MB
+		const fileMaxSize = 1024;
+		const fileSize = fs.statSync(screenshotPath).size / 1024;
+		if (fileSize > fileMaxSize) throw new Error(`Max screenshot file size is ${fileMaxSize}KB. ${screenshotPath} is ${fileSize}KB`);
+	}
+}
+
+function readManifest(manifestPath) {
+	const content = fs.readFileSync(manifestPath, 'utf8');
+	const output = JSON.parse(content);
+	if (!output.id) throw new Error(`Manifest plugin ID is not set in ${manifestPath}`);
+	validateCategories(output.categories);
+	validateScreenshots(output.screenshots);
+	return output;
+}
+
+function createPluginArchive(sourceDir, destPath) {
+	const distFiles = glob.sync(`${sourceDir}/**/*`, { nodir: true, windowsPathsNoEscape: true })
+		.map(f => f.substr(sourceDir.length + 1));
+
+	if (!distFiles.length) throw new Error('Plugin archive was not created because the "dist" directory is empty');
+	fs.removeSync(destPath);
+
+	tar.create(
+		{
+			strict: true,
+			portable: true,
+			file: destPath,
+			cwd: sourceDir,
+			sync: true,
+		},
+		distFiles,
+	);
+
+	console.info(chalk.cyan(`Plugin archive has been created in ${destPath}`));
+}
+
+const writeManifest = (manifestPath, content) => {
+	fs.writeFileSync(manifestPath, JSON.stringify(content, null, '\t'), 'utf8');
+};
+
+function createPluginInfo(manifestPath, destPath, jplFilePath) {
+	const contentText = fs.readFileSync(manifestPath, 'utf8');
+	const content = JSON.parse(contentText);
+	content._publish_hash = `sha256:${fileSha256(jplFilePath)}`;
+	content._publish_commit = currentGitInfo();
+	writeManifest(destPath, content);
+}
+
+function onBuildCompleted() {
+	try {
+		fs.removeSync(path.resolve(publishDir, 'index.js'));
+		createPluginArchive(distDir, pluginArchiveFilePath);
+		createPluginInfo(manifestPath, pluginInfoFilePath, pluginArchiveFilePath);
+		validatePackageJson();
+	} catch (error) {
+		console.error(chalk.red(error.message));
+	}
+}
+
+const baseConfig = {
+	mode: 'production',
+	target: 'node',
+	stats: 'errors-only',
+	module: {
+		rules: [
+			{
+				test: /\.tsx?$/,
+				use: 'ts-loader',
+				exclude: /node_modules/,
+			},
+		],
+	},
+	...userConfig.webpackOverrides,
+};
+
+const pluginConfig = { ...baseConfig, entry: './src/index.ts',
+	resolve: {
+		alias: {
+			api: path.resolve(__dirname, 'api'),
+		},
+		fallback: moduleFallback,
+		// JSON files can also be required from scripts so we include this.
+		// https://github.com/joplin/plugin-bibtex/pull/2
+		extensions: ['.js', '.tsx', '.ts', '.json'],
+	},
+	output: {
+		filename: 'index.js',
+		path: distDir,
+	},
+	plugins: [
+		new CopyPlugin({
+			patterns: [
+				{
+					from: '**/*',
+					context: path.resolve(__dirname, 'src'),
+					to: path.resolve(__dirname, 'dist'),
+					globOptions: {
+						ignore: [
+							// All TypeScript files are compiled to JS and
+							// already copied into /dist so we don't copy them.
+							'**/*.ts',
+							'**/*.tsx',
+						],
+					},
+				},
+			],
+		}),
+	] };
+
+
+// These libraries can be included with require(...) or
+// joplin.require(...) from content scripts.
+const externalContentScriptLibraries = [
+	'@codemirror/view',
+	'@codemirror/state',
+	'@codemirror/search',
+	'@codemirror/language',
+	'@codemirror/autocomplete',
+	'@codemirror/commands',
+	'@codemirror/highlight',
+	'@codemirror/lint',
+	'@codemirror/lang-html',
+	'@codemirror/lang-markdown',
+	'@codemirror/language-data',
+	'@lezer/common',
+	'@lezer/markdown',
+	'@lezer/highlight',
+];
+
+const extraScriptExternals = {};
+for (const library of externalContentScriptLibraries) {
+	extraScriptExternals[library] = { commonjs: library };
+}
+
+const extraScriptConfig = {
+	...baseConfig,
+	resolve: {
+		alias: {
+			api: path.resolve(__dirname, 'api'),
+		},
+		fallback: moduleFallback,
+		extensions: ['.js', '.tsx', '.ts', '.json'],
+	},
+
+	// We support requiring @codemirror/... libraries through require('@codemirror/...')
+	externalsType: 'commonjs',
+	externals: extraScriptExternals,
+};
+
+const createArchiveConfig = {
+	stats: 'errors-only',
+	entry: './dist/index.js',
+	resolve: {
+		fallback: moduleFallback,
+	},
+	output: {
+		filename: 'index.js',
+		path: publishDir,
+	},
+	plugins: [{
+		apply(compiler) {
+			compiler.hooks.done.tap('archiveOnBuildListener', onBuildCompleted);
+		},
+	}],
+};
+
+function resolveExtraScriptPath(name) {
+	const relativePath = `./src/${name}`;
+
+	const fullPath = path.resolve(`${rootDir}/${relativePath}`);
+	if (!fs.pathExistsSync(fullPath)) throw new Error(`Could not find extra script: "${name}" at "${fullPath}"`);
+
+	const s = name.split('.');
+	s.pop();
+	const nameNoExt = s.join('.');
+
+	return {
+		entry: relativePath,
+		output: {
+			filename: `${nameNoExt}.js`,
+			path: distDir,
+			library: 'default',
+			libraryTarget: 'commonjs',
+			libraryExport: 'default',
+		},
+	};
+}
+
+function buildExtraScriptConfigs(userConfig) {
+	if (!userConfig.extraScripts.length) return [];
+
+	const output = [];
+
+	for (const scriptName of userConfig.extraScripts) {
+		const scriptPaths = resolveExtraScriptPath(scriptName);
+		output.push({ ...extraScriptConfig, entry: scriptPaths.entry,
+			output: scriptPaths.output });
+	}
+
+	return output;
+}
+
+const increaseVersion = version => {
+	try {
+		const s = version.split('.');
+		const d = Number(s[s.length - 1]) + 1;
+		s[s.length - 1] = `${d}`;
+		return s.join('.');
+	} catch (error) {
+		error.message = `Could not parse version number: ${version}: ${error.message}`;
+		throw error;
+	}
+};
+
+const updateVersion = () => {
+	const packageJson = getPackageJson();
+	packageJson.version = increaseVersion(packageJson.version);
+	fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+
+	const manifest = readManifest(manifestPath);
+	manifest.version = increaseVersion(manifest.version);
+	writeManifest(manifestPath, manifest);
+
+	if (packageJson.version !== manifest.version) {
+		console.warn(chalk.yellow(`Version numbers have been updated but they do not match: package.json (${packageJson.version}), manifest.json (${manifest.version}). Set them to the required values to get them in sync.`));
+	} else {
+		console.info(packageJson.version);
+	}
+};
+
+function main(environ) {
+	const configName = environ['joplin-plugin-config'];
+	if (!configName) throw new Error('A config file must be specified via the --joplin-plugin-config flag');
+
+	// Webpack configurations run in parallel, while we need them to run in
+	// sequence, and to do that it seems the only way is to run webpack multiple
+	// times, with different config each time.
+
+	const configs = {
+		// Builds the main src/index.ts and copy the extra content from /src to
+		// /dist including scripts, CSS and any other asset.
+		buildMain: [pluginConfig],
+
+		// Builds the extra scripts as defined in plugin.config.json. When doing
+		// so, some JavaScript files that were copied in the previous might be
+		// overwritten here by the compiled version. This is by design. The
+		// result is that JS files that don't need compilation, are simply
+		// copied to /dist, while those that do need it are correctly compiled.
+		buildExtraScripts: buildExtraScriptConfigs(userConfig),
+
+		// Ths config is for creating the .jpl, which is done via the plugin, so
+		// it doesn't actually need an entry and output, however webpack won't
+		// run without this. So we give it an entry that we know is going to
+		// exist and output in the publish dir. Then the plugin will delete this
+		// temporary file before packaging the plugin.
+		createArchive: [createArchiveConfig],
+	};
+
+	// If we are running the first config step, we clean up and create the build
+	// directories.
+	if (configName === 'buildMain') {
+		fs.removeSync(distDir);
+		fs.removeSync(publishDir);
+		fs.mkdirpSync(publishDir);
+	}
+
+	if (configName === 'updateVersion') {
+		updateVersion();
+		return [];
+	}
+
+	return configs[configName];
+}
+
+
+module.exports = (env) => {
+	let exportedConfigs = [];
+
+	try {
+		exportedConfigs = main(env);
+	} catch (error) {
+		console.error(error.message);
+		process.exit(1);
+	}
+
+	if (!exportedConfigs.length) {
+		// Nothing to do - for example where there are no external scripts to
+		// compile.
+		process.exit(0);
+	}
+
+	return exportedConfigs;
+};