@vcmap/plugin-cli 1.0.1 → 2.0.2

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@vcmap/plugin-cli",
-  "version": "1.0.1",
-  "description": "A CLI to help develop and build plugins for the virtualcityMAP",
+  "version": "2.0.2",
+  "description": "A CLI to help develop and build plugins for the VC Map",
   "main": "index.js",
+  "type": "module",
   "bin": {
     "vcmplugin": "cli.js"
   },
@@ -10,9 +11,14 @@
     "lint": "eslint . --env node",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/virtualcitySYSTEMS/map-plugin-cli.git"
+  },
   "author": "Ben Kuster <bkuster@virtualcitysystems.de>",
   "license": "MIT",
   "files": [
+    "assets/",
     "src/",
     "cli.js",
     "README.md",
@@ -20,35 +26,54 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@babel/core": "^7.10.2",
-    "@babel/runtime": "^7.13.10",
+    "@vcmap/rollup-plugin-vcs-ol": "^1.0.1",
     "@vcsuite/cli-logger": "^1.0.0",
-    "@vue/babel-preset-app": "^4.5.4",
     "archiver": "^5.0.0",
-    "autoprefixer": "^9.8.6",
-    "babel-loader": "^8.1.0",
     "commander": "^6.0.0",
-    "css-loader": "^3.6.0",
-    "postcss-loader": "^3.0.0",
+    "express": "^4.17.3",
     "prompts": "^2.4.1",
+    "sass": "1.32.13",
     "semver": "^7.3.5",
-    "terser-webpack-plugin": "^5.1.1",
-    "url-loader": "^4.1.0",
+    "unplugin-vue-components": "^0.17.21",
     "vinyl-fs": "^3.0.3",
-    "vue": "^2.6.12",
-    "vue-loader": "^15.9.6",
-    "vue-template-compiler": "^2.6.12",
-    "webpack": "^5.36.2",
-    "webpack-dev-server": "^3.11.2"
+    "vite": "^2.9.1",
+    "vite-plugin-vue2": "^1.7.3",
+    "vue-template-compiler": "^2.6.14"
+  },
+  "peerDependencies": {
+    "@vcmap/ui": "^5.0.0-rc.6"
+  },
+  "peerDependenciesMeta": {
+    "@vcmap/ui": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@vcsuite/eslint-config": "^1.0.0",
-    "eslint": "^7.25.0"
+    "@vcsuite/eslint-config": "^2.1.1",
+    "eslint": "^8.9.0"
   },
   "eslintIgnore": [
-    "node_modules"
+    "node_modules",
+    "assets/helloWorld"
   ],
   "eslintConfig": {
-    "extends": "@vcsuite/eslint-config/node"
+    "extends": "@vcsuite/eslint-config/node",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "rules": {
+      "import/no-unresolved": [
+        2,
+        {
+          "ignore": [
+            "^@vcmap/ui"
+          ]
+        }
+      ]
+    }
+  },
+  "engines": {
+    "node": "^16.14.0",
+    "npm": "^8.3.0"
   }
 }

package/src/build.js

@@ -1,32 +1,94 @@
-const webpack = require('webpack');
-const { logger } = require('@vcsuite/cli-logger');
-const { getPluginName } = require('./packageJsonHelpers');
-const { getProdWebpackConfig } = require('./getWebpackConfig');
+import path from 'path';
+import fs from 'fs/promises';
+import { createVuePlugin } from 'vite-plugin-vue2';
+import vcsOl from '@vcmap/rollup-plugin-vcs-ol';
+import { logger } from '@vcsuite/cli-logger';
+import { VuetifyResolver } from 'unplugin-vue-components/dist/resolvers.js';
+import Components from 'unplugin-vue-components/dist/vite.js';
+import { getPluginEntry, getPluginName } from './packageJsonHelpers.js';
+import { getContext } from './context.js';
 
-async function build(options) {
-  function webpackHandler(err, stats) {
-    if (err) {
-      logger.error(err);
-    } else if (stats.hasErrors()) {
-      logger.error(stats.compilation.errors);
-    } else {
-      logger.success(`built ${options.pluginName}`);
-    }
-    logger.stopSpinner();
-  }
+/**
+ * @typedef {Object} BuildOptions
+ * @property {boolean} [development]
+ * @property {boolean} [watch]
+ */
 
-  options.pluginName = options.pluginName || await getPluginName();
-  logger.spin(`compiling ${options.pluginName}`);
-  options.mode = options.development ? 'development' : 'production';
+export function getDefaultConfig() {
+  return {
+    publicDir: false,
+    plugins: [
+      createVuePlugin(),
+      Components({
+        resolvers: [
+          VuetifyResolver(),
+        ],
+        dirs: ['./src'],
+        include: [],
+        exclude: [],
+      }),
+      vcsOl(),
+    ],
+  };
+}
 
-  const config = await getProdWebpackConfig(options);
-  const compiler = webpack(config);
+/**
+ * @param {string} pluginName
+ * @returns {Object<string, string>}
+ */
+export async function getLibraryPaths(pluginName) {
+  const { libraries } = await import('@vcmap/ui/build/buildHelpers.js');
+  const pluginPath = path.join('plugins', ...pluginName.split('/'));
+  const libraryPaths = {};
+  Object.entries(libraries).forEach(([library, assetName]) => {
+    const assetPath = path.join('assets', `${assetName}.js`);
 
-  if (options.watch) {
-    compiler.watch({}, webpackHandler);
-  } else {
-    compiler.run(webpackHandler);
-  }
+    libraryPaths[library] = path.relative(pluginPath, assetPath);
+  });
+  return libraryPaths;
 }
 
-module.exports = build;
+/**
+ * @param {BuildOptions} options
+ * @returns {Promise<void>}
+ */
+export default async function buildModule(options) {
+  const entry = await getPluginEntry();
+  if (path.relative('src', entry).startsWith('.')) {
+    logger.warning(`detected irregular entry ${entry}`);
+    logger.warning('vuetify component resolution expects source files to be within "src"');
+  }
+
+  const pluginName = await getPluginName();
+  const libraryPaths = await getLibraryPaths(pluginName);
+  const distPath = path.join(getContext(), 'dist');
+  await fs.rm(distPath, { recursive: true, force: true });
+  await fs.mkdir(distPath);
+  const external = Object.keys(libraryPaths);
+  const config = {
+    ...getDefaultConfig(),
+    esbuild: {
+      minify: !options.development,
+    },
+    build: {
+      write: false,
+      emptyOutDir: false,
+      lib: {
+        entry,
+        formats: ['es'],
+        fileName: () => 'index.js',
+      },
+      rollupOptions: {
+        external,
+        output: {
+          paths: libraryPaths,
+        },
+      },
+      watch: options.watch ? {
+        skipWrite: true,
+      } : null,
+    },
+  };
+  const { buildLibrary } = await import('@vcmap/ui/build/buildHelpers.js');
+  await buildLibrary(config, '', 'index', '', true);
+}

package/src/context.js

@@ -1,25 +1,22 @@
-const path = require('path');
+import path from 'path';
+import fs from 'fs';
 
 let context = null;
 
-function setContext(c) {
+export function setContext(c) {
   if (context) {
     throw new Error('cannot set context twice');
   }
-  context = c;
+  if (!fs.existsSync(c) || !fs.statSync(c).isDirectory()) {
+    throw new Error('context must be an existing directory');
+  }
+  context = path.resolve(c);
 }
 
-function getContext() {
+export function getContext() {
   return context || process.cwd();
 }
 
-function resolveContext(...dir) {
+export function resolveContext(...dir) {
   return path.join(getContext(), ...dir);
 }
-
-
-module.exports = {
-  getContext,
-  resolveContext,
-  setContext,
-};

package/src/create.js

@@ -1,11 +1,14 @@
-const fs = require('fs');
-const path = require('path');
-const prompts = require('prompts');
-const semver = require('semver');
-const util = require('util');
-const childProcess = require('child_process');
-const { logger } = require('@vcsuite/cli-logger');
-const { version, name } = require('../package.json');
+import fs from 'fs';
+import path from 'path';
+import prompts from 'prompts';
+import semver from 'semver';
+import util from 'util';
+import childProcess from 'child_process';
+import { logger } from '@vcsuite/cli-logger';
+import { LicenseType, writeLicense } from './licenses.js';
+import { getDirname } from './hostingHelpers.js';
+
+export const { version, name } = JSON.parse(fs.readFileSync(path.join(getDirname(), '..', 'package.json')).toString());
 
 /**
  * @typedef {Object} PluginTemplateOptions
@@ -14,9 +17,11 @@ const { version, name } = require('../package.json');
  * @property {string} description
  * @property {Array<Object>} scripts
  * @property {string} author
+ * @property {string} repository
  * @property {string} license
- * @property {string} mapVersion
- * @property {boolean} addDevDep
+ * @property {string} registry
+ * @property {boolean} addCiCd
+ * @property {Array<string>} peerDeps
  */
 
 /**
@@ -36,23 +41,49 @@ async function createPluginTemplate(options) {
   }
 
   await fs.promises.mkdir(pluginPath);
+  await fs.promises.mkdir(path.join(pluginPath, 'plugin-assets'));
   logger.debug('created plugin directory');
-
   const packageJson = {
     name: options.name,
     version: options.version,
     description: options.description,
     main: 'src/index.js',
-    scripts: Object.assign({}, ...options.scripts),
+    scripts: Object.assign({ prepublishOnly: 'vcmplugin build' }, ...options.scripts),
     author: options.author,
     license: options.license,
-    engines: {
-      vcm: options.mapVersion,
-    },
     dependencies: {},
-    devDependencies: options.addDevDep ? { [name]: `^${version}` } : {},
+    keywords: [
+      'vcmap',
+      'plugin',
+    ],
+    files: [
+      'src/',
+      'dist/',
+      'plugin-assets/',
+      'LICENSE.md',
+      'README.md',
+    ],
+    exports: {
+      '.': './src/index.js',
+      './dist': './dist/index.js',
+    },
   };
 
+  if (options.repository) {
+    packageJson.repository = {
+      url: options.repository,
+    };
+  }
+
+  const installEsLint = options.scripts.find(script => script.lint);
+  if (installEsLint) {
+    packageJson.eslintIgnore = ['node_modules'];
+    packageJson.eslintConfig = {
+      root: true,
+      extends: '@vcsuite/eslint-config/vue',
+    };
+  }
+
   const writePackagePromise = fs.promises.writeFile(
     path.join(pluginPath, 'package.json'),
     JSON.stringify(packageJson, null, 2),
@@ -60,7 +91,6 @@ async function createPluginTemplate(options) {
 
   const configJson = {
     name: options.name,
-    version: options.version,
   };
 
   const writeConfigPromise = fs.promises.writeFile(
@@ -68,6 +98,11 @@ async function createPluginTemplate(options) {
     JSON.stringify(configJson, null, 2),
   );
 
+  const writeNpmrcPromise = fs.promises.writeFile(
+    path.join(pluginPath, '.npmrc'),
+    `registry=${options.registry}\n`,
+  );
+
   const writeReadmePromise = fs.promises.writeFile(
     path.join(pluginPath, 'README.md'),
     [
@@ -76,30 +111,47 @@ async function createPluginTemplate(options) {
     ].join('\n'),
   );
 
+  const writeChangesPromise = fs.promises.writeFile(
+    path.join(pluginPath, 'CHANGES.md'),
+    `# v${options.version}\nDocument features and fixes`,
+  );
+
   await fs.promises.mkdir(path.join(pluginPath, 'src'));
   logger.debug('created src directory');
 
-  const writeIndexPromise = fs.promises.writeFile(
-    path.join(pluginPath, 'src', 'index.js'),
-    ['import { version } from \'../package.json\';',
-      '',
-      'export default {',
-      '  version,',
-      '  // preInitialize',
-      '  // postInitialize',
-      '  // registerUiPlugin',
-      '  // postUiInitialize',
-      '};'].join('\n'),
+  const copyTemplatePromise = fs.promises.cp(
+    path.join(getDirname(), '..', 'assets', 'helloWorld'),
+    pluginPath,
+    { recursive: true },
   );
 
-  await Promise.all([writePackagePromise, writeConfigPromise, writeReadmePromise, writeIndexPromise]);
+  await Promise.all([
+    writePackagePromise,
+    writeConfigPromise,
+    writeNpmrcPromise,
+    writeReadmePromise,
+    writeChangesPromise,
+    copyTemplatePromise,
+    writeLicense(options.author, options.license, pluginPath),
+  ]);
+
 
-  logger.spin('installing dependencies...');
+  logger.spin('installing dependencies... (this may take a while)');
   const exec = util.promisify(childProcess.exec);
   try {
-    const { stdout, stderr } = await exec('npm i', { cwd: pluginPath });
+    options.peerDeps.push('@vcmap/ui');
+    const installCmd = `npm i --save-peer ${options.peerDeps.join(' ')}`;
+    const { stdout, stderr } = await exec(installCmd, { cwd: pluginPath });
     logger.log(stdout);
     logger.error(stderr);
+    const devDeps = [`${name}@${version}`];
+    if (installEsLint) {
+      devDeps.push('@vcsuite/eslint-config');
+    }
+    const installDevCmd = `npm i --save-dev ${devDeps.join(' ')}`;
+    const { stdout: stdoutDev, stderr: stderrDev } = await exec(installDevCmd, { cwd: pluginPath });
+    logger.log(stdoutDev);
+    logger.error(stderrDev);
     logger.success('installed dependencies');
   } catch (e) {
     logger.error(e);
@@ -112,11 +164,21 @@ async function createPluginTemplate(options) {
 /**
  * @returns {Promise<void>}
  */
-async function create() {
+export default async function create() {
   const scriptChoices = [
-    { title: 'build', value: { build: 'vcmplugin build' } },
-    { title: 'pack', value: { pack: 'vcmplugin pack' } },
-    { title: 'test', value: { test: 'echo "Error: no test specified" && exit 1' } },
+    { title: 'build', value: { build: 'vcmplugin build' }, selected: true },
+    { title: 'pack', value: { pack: 'vcmplugin pack' }, selected: true },
+    { title: 'start', value: { start: 'vcmplugin serve' }, selected: true },
+    { title: 'preview', value: { preview: 'vcmplugin preview' }, selected: true },
+    { title: 'lint', value: { lint: 'eslint "{src,tests}/**/*.{js,vue}"' }, selected: true },
+  ];
+
+  const peerDependencyChoices = [
+    { title: '@vcsuite/ui-components', value: '@vcsuite/ui-components', selected: true },
+    { title: '@vcmap/core', value: '@vcmap/core' },
+    { title: '@vcmap/cesium', value: '@vcmap/cesium' },
+    { title: 'ol', value: 'ol@~6.13.0' },
+    { title: '@vue/composition-api', value: '@vue/composition-api@~1.4.5' },
   ];
 
   const questions = [
@@ -163,21 +225,39 @@ async function create() {
     },
     {
       type: 'text',
+      name: 'repository',
+      message: 'Repository url',
+      // initial: (prev, values) => `https://github.com/virtualcitySYSTEMS/${values.name}.git`,
+    },
+    {
+      type: 'select',
       name: 'license',
       message: 'License',
-      initial: 'ISC',
+      initial: 0,
+      choices: Object.values(LicenseType)
+        .map(type => ({
+          title: type,
+          value: type,
+        })),
     },
     {
       type: 'text',
-      name: 'mapVersion',
-      message: 'Map version',
-      initial: '>=4.0',
+      name: 'registry',
+      message: 'Set default npm registry',
+      initial: 'https://registry.npmjs.org',
+    },
+    {
+      name: 'peerDeps',
+      type: 'multiselect',
+      message: 'Add the following peer dependencies to the package.json.',
+      choices: peerDependencyChoices,
+      hint: '- Space to select. Enter to submit',
     },
     {
       type: 'toggle',
-      name: 'addDevDep',
-      message: 'Add vcmplugin-cli as dev dependency?',
-      initial: true,
+      name: 'addCiCd',
+      message: 'Add default VCS gitlab ci/cd?',
+      initial: false,
       active: 'yes',
       inactive: 'no',
     },
@@ -187,5 +267,3 @@ async function create() {
 
   await createPluginTemplate(answers);
 }
-
-module.exports = create;

package/src/defaultCommand.js

@@ -1,19 +1,37 @@
-const { Command } = require('commander');
+import { Command } from 'commander';
+import { logger } from '@vcsuite/cli-logger';
+import { setContext } from './context.js';
 
 Command.prototype.defaultOptions = function defaultOptions() {
   this
-    .option('-n, --plugin-name [name]', 'a name override to use. extracts the name from the package.json by default')
-    .option('--no-condense-whitespace', 'do not condense white space')
-    .option('-e, --entry <entry>', 'entrypoint override');
+    .option('--context [path]', 'an optional context, default is cwd', (value) => {
+      setContext(value);
+      return value;
+    });
 
   return this;
 };
 
-Command.prototype.defaultBuildOptions = function defaultBuildOptions() {
+Command.prototype.defaultServeOptions = function defaultServeOptions() {
   this
-    .defaultOptions()
-    .option('-l, --library [name]', 'whether to create a library with [name] or not')
-    .option('--library-target [target]', 'library target', 'commonjs2');
+    .option('-p, --port [port]', 'the port to listen on', /\d+/)
+    .option('--auth <user:password>', 'an optional auth to append to proxy requests')
+    .option('-c, --config <config>', 'a config override to not use the default plugin config')
+    .option('--https', 'use https for serving');
 
   return this;
 };
+
+Command.prototype.safeAction = function safeAction(action) {
+  this.action(async (options) => {
+    try {
+      await action(options);
+    } catch (e) {
+      if (e) {
+        logger.error(e);
+      }
+      logger.stopSpinner();
+      process.exit(1);
+    }
+  });
+};