Plugins: Updated types

packages/app-cli/tests/support/plugins/codemirror_content_script/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/codemirror_content_script/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/codemirror_content_script/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/codemirror_content_script/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/codemirror_content_script/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/content_script/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/content_script/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/content_script/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/content_script/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/content_script/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/dialog/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/dialog/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/dialog/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/dialog/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/dialog/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/editor_context_menu/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/editor_context_menu/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/editor_context_menu/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/editor_context_menu/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/editor_context_menu/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/events/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/events/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/events/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/events/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/events/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/jpl_test/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/jpl_test/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/jpl_test/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/jpl_test/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/jpl_test/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/json_export/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/json_export/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/json_export/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/json_export/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/json_export/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/menu/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/menu/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/menu/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/menu/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/menu/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/multi_selection/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/multi_selection/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/multi_selection/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/multi_selection/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/multi_selection/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/register_command/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/register_command/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/register_command/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/register_command/api/types.ts

@@ -208,13 +208,6 @@ export enum MenuItemLocation {
 	 * @deprecated Do not use - same as NoteListContextMenu
 	 */
 	Context = 'context',
-
-	/**
-	 * The context menu that appears when right-clicking on the note
-	 * list, or when multiple notes are selected. Any command triggered from
-	 * this location will receive a `noteIds` array with the list of notes that
-	 * were right-clicked or selected.
-	 */
 	NoteListContextMenu = 'noteListContextMenu',
 	EditorContextMenu = 'editorContextMenu',
 }

packages/app-cli/tests/support/plugins/register_command/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/register_command/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/selected_text/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/selected_text/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/selected_text/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/selected_text/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/selected_text/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/settings/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/settings/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/settings/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/settings/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -20,4 +20,4 @@
     "webpack": "^4.43.0",
     "webpack-cli": "^3.3.11"
   }
-}
+}

packages/app-cli/tests/support/plugins/settings/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/toc/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/toc/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/toc/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/toc/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -23,4 +23,4 @@
   "dependencies": {
     "uslug": "^1.0.4"
   }
-}
+}

packages/app-cli/tests/support/plugins/toc/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/app-cli/tests/support/plugins/withExternalModules/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/app-cli/tests/support/plugins/withExternalModules/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/app-cli/tests/support/plugins/withExternalModules/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.

packages/app-cli/tests/support/plugins/withExternalModules/package.json

@@ -6,7 +6,7 @@
     "dist": "webpack",
     "postinstall": "npm run dist"
   },
-  "keywords": [],
+  "keywords": {},
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^14.0.14",
@@ -23,4 +23,4 @@
   "dependencies": {
     "left-pad": "^1.3.0"
   }
-}
+}

packages/app-cli/tests/support/plugins/withExternalModules/webpack.config.js

@@ -16,6 +16,13 @@ function createPluginArchive(sourceDir, destPath) {
 	const distFiles = glob.sync(`${sourceDir}/**/*`)
 		.map(f => f.substr(sourceDir.length + 1));
 
+	if (!distFiles.length) {
+		// Usually means there's an error, which is going to be printed by
+		// webpack
+		console.info('Plugin archive was not created because the "dist" directory is empty');
+		return;
+	}
+
 	fs.removeSync(destPath);
 
 	tar.create(
@@ -38,6 +45,8 @@ const manifestPath = `${srcDir}/manifest.json`;
 const manifest = readManifest(manifestPath);
 const archiveFilePath = path.resolve(__dirname, `${manifest.id}.jpl`);
 
+fs.removeSync(distDir);
+
 module.exports = {
 	mode: 'production',
 	entry: './src/index.ts',

packages/generator-joplin/generators/app/templates/api/Global.d.ts

@@ -1,13 +1,12 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
-import Logger from '../../../Logger';
 /**
  * @ignore
  */
 export default class Global {
     private joplin_;
     private requireWhiteList_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get joplin(): Joplin;
     private requireWhiteList;
     require(filePath: string): any;

packages/generator-joplin/generators/app/templates/api/Joplin.d.ts

@@ -7,7 +7,6 @@ import JoplinCommands from './JoplinCommands';
 import JoplinViews from './JoplinViews';
 import JoplinInterop from './JoplinInterop';
 import JoplinSettings from './JoplinSettings';
-import Logger from '../../../Logger';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -32,7 +31,7 @@ export default class Joplin {
     private views_;
     private interop_;
     private settings_;
-    constructor(logger: Logger, implementation: any, plugin: Plugin, store: any);
+    constructor(implementation: any, plugin: Plugin, store: any);
     get data(): JoplinData;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;

packages/generator-joplin/generators/app/templates/api/JoplinPlugins.d.ts

@@ -1,13 +1,11 @@
 import Plugin from '../Plugin';
-import Logger from '../../../Logger';
 import { ContentScriptType, Script } from './types';
 /**
  * This class provides access to plugin-related features.
  */
 export default class JoplinPlugins {
-    private logger;
     private plugin;
-    constructor(logger: Logger, plugin: Plugin);
+    constructor(plugin: Plugin);
     /**
      * Registers a new plugin. This is the entry point when creating a plugin. You should pass a simple object with an `onStart` method to it.
      * That `onStart` method will be executed as soon as the plugin is loaded.