@w5s/mrm-preset 1.0.0-alpha.1

package/core/jsonFile.js

@@ -0,0 +1,65 @@
+/**
+ * @typedef {string|boolean|number|null|Array<unknown>|Record<string, unknown>} JsonValue
+ */
+
+/**
+ * @param {import('mrm-core').Json} jsonFile
+ * @param {undefined | string | string[]} path
+ */
+function getValue(jsonFile, path) {
+  if (path == null) {
+    return jsonFile.get();
+  }
+
+  return jsonFile.get(path);
+}
+
+/**
+ * @param {import('mrm-core').Json} jsonFile
+ * @param {undefined | string | string[]} path
+ * @param {unknown} pathValue
+ */
+function setValue(jsonFile, path, pathValue) {
+  if (path == null) {
+    jsonFile.set(pathValue);
+  } else {
+    jsonFile.set(path, pathValue);
+  }
+}
+
+/**
+ * Set state of a json value
+ *
+ * @template {undefined|JsonValue} T
+ * @param {import('mrm-core').Json} jsonFile
+ * @param {{
+ *   path: undefined | string | string[],
+ *   state: 'present'|'absent',
+ *   update?: T | ((previousValue: T) => T)
+ *   default?: T | (() => T)
+ * }} options
+ */
+function value(jsonFile, { state, path, default: defaultValue, update: nextValue }) {
+  if (state === 'present') {
+    if (nextValue != null) {
+      const resolvedValue = typeof nextValue === 'function' ? nextValue(getValue(jsonFile, path)) : nextValue;
+      if (resolvedValue != null) {
+        setValue(jsonFile, path, resolvedValue);
+      }
+    }
+
+    const currentValue = getValue(jsonFile, path);
+    if (currentValue == null) {
+      const resolvedValue = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+      if (resolvedValue != null) {
+        setValue(jsonFile, path, resolvedValue);
+      }
+    }
+  } else if (path) {
+    jsonFile.unset(path);
+  }
+}
+
+module.exports = {
+  value,
+};

package/core/lintStaged.js

@@ -0,0 +1,36 @@
+const pkg = require('./pkg');
+const npm = require('./npm');
+const jsonFile = require('./jsonFile');
+
+/**
+ * @typedef {Record<string, string|string[]>} LintStagedConfig
+ */
+
+/**
+ * @param {{
+ *   state: 'present'|'absent',
+ *   update?: (config: LintStagedConfig) => LintStagedConfig
+ * }} options
+ */
+function lintStaged({ state, update }) {
+  pkg.withPackageJson((packageFile) => {
+    jsonFile.value(packageFile, {
+      path: 'lint-staged',
+      state,
+      update,
+      /** @type {LintStagedConfig} */
+      default: {},
+    });
+  });
+
+  // Dependencies
+  npm.dependency({
+    dev: true,
+    name: ['lint-staged'],
+    state,
+  });
+}
+
+module.exports = {
+  lintStaged,
+};

package/core/npm.js

@@ -0,0 +1,271 @@
+/* eslint-disable import/no-extraneous-dependencies */
+/* cSpell: disable */
+// @ts-check
+// @ts-ignore
+const fs = require('fs-extra');
+// @ts-ignore
+const _ = require('lodash');
+// @ts-ignore
+const semver = require('semver');
+// @ts-ignore
+const listify = require('listify');
+// @ts-ignore
+const validateNpmPackageName = require('validate-npm-package-name');
+// @ts-ignore
+const log = require('mrm-core/src/util/log');
+// @ts-ignore
+const execCommand = require('mrm-core/src/util/execCommand');
+// @ts-ignore
+const json = require('mrm-core/src/formats/json');
+// @ts-ignore
+const packageJson = require('mrm-core/src/files/packageJson');
+// @ts-ignore
+const MrmError = require('mrm-core/src/error');
+
+/**
+ * @typedef Options
+ * @property {boolean} [dev]
+ * @property {boolean} [yarn]
+ * @property {Record<string, string>} [versions]
+ */
+
+/**
+ * @typedef RunOptions
+ * @property {boolean} [dev]
+ * @property {boolean} [remove]
+ * @property {boolean} [stdio]
+ * @property {string} [cwd]
+ */
+
+/**
+ * Install or update given npm packages if needed
+ *
+ * @param {Record<string, string> | string[] | string} deps
+ * @param {Options} [options]
+ * @param {Function=} exec
+ */
+function install(deps, options = {}, exec) {
+  const dev = options.dev !== false;
+  const run = options.yarn || isUsingYarn() ? runYarn : runNpm;
+
+  // options.versions is a min versions mapping,
+  // the list of packages to install will be taken from deps
+  let versions = options.versions || {};
+
+  /** @type string[] */
+  let dependencies = [];
+
+  if (typeof deps === 'string') {
+    dependencies = [deps];
+  } else if (Array.isArray(deps)) {
+    dependencies = deps;
+  } else if (typeof deps === 'object' && deps !== null) {
+    // deps is an object with required versions
+    // prettier-ignore
+    versions = deps;
+    dependencies = Object.keys(deps);
+  }
+
+  const newDeps = getUnsatisfiedDeps(dependencies, versions, { dev });
+  if (newDeps.length === 0) {
+    return;
+  }
+
+  log.info(`Installing ${listify(newDeps)}...`);
+  const versionedDeps = newDeps.map((dep) => {
+    return getVersionedDep(dep, versions);
+  });
+
+  // eslint-disable-next-line consistent-return
+  return run(versionedDeps, { dev }, exec);
+}
+
+/**
+ * Uninstall given npm packages
+ *
+ * @param {string[] | string} deps
+ * @param {Options} [options]
+ * @param {Function=} exec
+ */
+function uninstall(deps, options = {}, exec) {
+  // eslint-disable-next-line no-param-reassign
+  deps = _.castArray(deps);
+  const dev = options.dev !== false;
+  const run = options.yarn || isUsingYarn() ? runYarn : runNpm;
+
+  const installed = getOwnDependencies({ dev });
+
+  // @ts-ignore
+  const newDeps = deps.filter((dep) => {
+    return installed[dep];
+  });
+
+  if (newDeps.length === 0) {
+    return;
+  }
+
+  log.info(`Uninstalling ${listify(newDeps)}...`);
+
+  // eslint-disable-next-line consistent-return
+  return run(newDeps, { dev, remove: true }, exec);
+}
+
+/**
+ * Install given npm packages
+ *
+ * @param {string[]} deps
+ * @param {RunOptions} [options]
+ * @param {Function} [exec]
+ */
+function runNpm(deps, options = {}, exec) {
+  const args = [options.remove ? 'uninstall' : 'install', options.dev ? '--save-dev' : '--save'].concat(deps);
+
+  return execCommand(exec, 'npm', args, {
+    cwd: options.cwd,
+    stdio: options.stdio === undefined ? 'inherit' : options.stdio,
+  });
+}
+
+/**
+ * Install given Yarn packages
+ *
+ * @param {string[]} deps
+ * @param {RunOptions} [options]
+ * @param {Function} [exec]
+ */
+function runYarn(deps, options = {}, exec) {
+  const add = options.dev ? ['add', '--dev'] : ['add'];
+  const remove = ['remove'];
+  const args = (options.remove ? remove : add).concat(isUsingWorkspaces() ? ['-W'] : []).concat(deps);
+
+  return execCommand(exec, 'yarn', args, {
+    cwd: options.cwd,
+    stdio: options.stdio === undefined ? 'inherit' : options.stdio,
+  });
+}
+
+/**
+ * Add version or latest to package name
+ *
+ * @param {string} dep
+ * @param {Record<string, string>} versions
+ */
+function getVersionedDep(dep, versions) {
+  // Handle non-registry packages (Github, bitbucket, etc.)
+  if (!validateNpmPackageName(dep).validForNewPackages) {
+    // If we were explicitly passed a version, attempt to
+    // load it via the `#semver:<semver>` syntax.
+    if (versions[dep]) {
+      return `${dep}#semver:${versions[dep]}`;
+    }
+
+    return dep;
+  }
+  const version = versions[dep] || 'latest';
+
+  return `${dep}@${version}`;
+}
+
+/**
+ *
+ * @param {Options} options
+ * @returns {Record<string, string>}
+ */
+function getOwnDependencies(options) {
+  const pkg = packageJson({
+    dependencies: {},
+    devDependencies: {},
+  });
+
+  return pkg.get(options.dev ? 'devDependencies' : 'dependencies') || {};
+}
+
+/**
+ * Return version of installed npm package
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+function getInstalledVersion(name) {
+  return json(`./node_modules/${name}/package.json`).get('version');
+}
+
+/**
+ * Return only not installed dependencies, or dependencies which installed
+ * version doesn't satisfy range.
+ *
+ * @param {string[]} deps
+ * @param {Record<string, string>} versions
+ * @param {Options} options
+ * @returns {string[]}
+ */
+function getUnsatisfiedDeps(deps, versions, options) {
+  const ownDependencies = getOwnDependencies(options);
+
+  return deps.filter((dep) => {
+    const required = versions[dep];
+
+    // Handle non-registry packages (github, bitbucket, etc.)
+    // Because these packages can shift contents without updating version
+    // numbers, always attempt an install
+    if (!validateNpmPackageName(dep).validForNewPackages) {
+      return true;
+    }
+
+    if (required && !semver.validRange(required)) {
+      throw new MrmError(`Invalid npm version: ${required}. Use proper semver range syntax.`);
+    }
+
+    const installed = getInstalledVersion(dep);
+
+    // Package isn’t installed yet
+    if (!installed) {
+      return true;
+    }
+
+    // Module is installed but not in package.json dependencies
+    if (!ownDependencies[dep]) {
+      return true;
+    }
+
+    // No required version specified
+    if (!required) {
+      // Install if the pacakge isn’t installed
+      return !installed;
+    }
+
+    // Install if installed version doesn't satisfy range
+    return !semver.satisfies(installed, required);
+  });
+}
+
+/*
+ * Is project using Yarn?
+ */
+function isUsingYarn() {
+  return fs.existsSync('yarn.lock');
+}
+
+function isUsingWorkspaces() {
+  return Boolean(packageJson().get('workspaces'));
+}
+
+/**
+ * @param {{
+ *   name: string|string[]|Record<string, string>,
+ *   state: 'present'|'absent',
+ *   dev?: boolean,
+ *   yarn?: boolean,
+ * }} options
+ */
+function dependency({ name, state, ...options }) {
+  if (state === 'present') {
+    install(name, options);
+  } else {
+    uninstall(typeof name === 'string' || Array.isArray(name) ? name : Object.keys(name));
+  }
+}
+
+module.exports = {
+  dependency,
+};

package/core/pkg.js

@@ -0,0 +1,97 @@
+/* cSpell: disable */
+// @ts-check
+
+// @ts-ignore
+const { intersect } = require('semver-intersect');
+const { packageJson, file } = require('mrm-core');
+const jsonFile = require('./jsonFile');
+
+/**
+ * An empty placeholder for npm script
+ */
+const emptyScript = ':';
+
+/**
+ * @param {(pkg: import('mrm-core').PackageJson) => void} block
+ */
+function withPackageJson(block) {
+  const packageFile = packageJson();
+  block(packageFile);
+  packageFile.save();
+}
+
+/**
+ * @param {import('mrm-core').PackageJson} packageFile
+ * @param {{
+ *   name: string,
+ *   state: 'present'|'absent'|'default',
+ *   script: string,
+ * }} options
+ */
+function script(packageFile, { name, state, script: scriptName }) {
+  if (state === 'absent') {
+    packageFile.removeScript(name);
+  } else if (state === 'present' || (state === 'default' && !packageFile.getScript(name))) {
+    packageFile.setScript(name, scriptName);
+  }
+}
+
+const defaultManager = 'npm';
+
+/**
+ * @param {import('mrm-core').PackageJson} packageFile
+ * @returns {'yarn'|'npm'}
+ */
+function manager(packageFile) {
+  if (packageFile.get('packagerManager')) {
+    const [head, tail] = packageFile.get('packagerManager').split('@', 2);
+
+    return head ?? tail;
+  }
+  if (file('yarn.lock').exists()) {
+    return 'yarn';
+  }
+  if (file('package-json.lock').exists()) {
+    return 'npm';
+  }
+
+  return defaultManager;
+}
+
+/**
+ *
+ * @param {import('mrm-core').PackageJson} packageFile
+ * @param {Record<string, string>} engineVersionMap
+ */
+function engineMinVersion(packageFile, engineVersionMap) {
+  /**
+   * @param {string} engineName
+   */
+  const engineConstraint = (engineName) => {
+    const defaultVersion = engineVersionMap[engineName];
+    const currentVersion = packageFile.get(`engines.${engineName}`, defaultVersion);
+    try {
+      return intersect(currentVersion, defaultVersion);
+    } catch (_) {
+      return currentVersion; // leave unchanged
+    }
+  };
+
+  packageFile.merge({
+    engines: Object.keys(engineVersionMap).reduce((acc, engineName) => {
+      return {
+        ...acc,
+        [engineName]: engineConstraint(engineName),
+      };
+    }, {}),
+  });
+}
+
+module.exports = {
+  ...jsonFile,
+  emptyScript,
+  script,
+  manager,
+  engineMinVersion,
+  withPackageJson,
+};

package/core/project.js

@@ -0,0 +1,58 @@
+/** @type {'install'} */
+const install = 'install';
+/** @type {'prepare'} */
+const prepare = 'prepare';
+/** @type {'build'} */
+const build = 'build';
+/** @type {'develop'} */
+const develop = 'develop';
+/** @type {'code-analysis'} */
+const codeAnalysis = 'code-analysis';
+/** @type {'format'} */
+const format = 'format';
+/** @type {'lint'} */
+const lint = 'lint';
+/** @type {'test'} */
+const test = 'test';
+/** @type {'coverage'} */
+const coverage = 'coverage';
+/** @type {'clean'} */
+const clean = 'clean';
+/** @type {'validate'} */
+const validate = 'validate';
+/** @type {'release'} */
+const release = 'release';
+/** @type {'rescue'} */
+const rescue = 'rescue';
+
+/**
+ * @param {string} taskName
+ */
+function pre(taskName) {
+  return `pre${taskName}`;
+}
+
+/**
+ * @param {string} taskName
+ */
+function post(taskName) {
+  return `post${taskName}`;
+}
+
+module.exports = {
+  build,
+  prepare,
+  develop,
+  clean,
+  codeAnalysis,
+  coverage,
+  format,
+  install,
+  lint,
+  post,
+  pre,
+  release,
+  rescue,
+  test,
+  validate,
+};

package/core/semanticRelease.js

@@ -0,0 +1,43 @@
+const npm = require('./npm');
+const pkg = require('./pkg');
+const jsonFile = require('./jsonFile');
+
+/**
+ * @typedef {{
+ *  extends: string|string[]
+ * }} SemanticReleaseConfig
+ */
+
+/**
+ * @param {{
+ *   state: 'present'|'absent',
+ *   preset?: string,
+ *   update?: (config: SemanticReleaseConfig) => SemanticReleaseConfig
+ * }} options
+ */
+function semanticRelease({ state, update, preset }) {
+  npm.dependency({
+    dev: true,
+    name: ['semantic-release', ...(preset ? [preset] : [])],
+    state,
+  });
+
+  pkg.withPackageJson((packageFile) => {
+    jsonFile.value(packageFile, {
+      path: 'release',
+      state,
+      update,
+      /** @type {SemanticReleaseConfig} */
+      default: {
+        extends: preset ? [preset] : [],
+      },
+    });
+  });
+}
+semanticRelease.command = function () {
+  return 'semantic-release';
+};
+
+module.exports = {
+  semanticRelease,
+};

package/core/typedoc.js

@@ -0,0 +1,82 @@
+const { packageJson, json } = require('mrm-core');
+const pkg = require('./pkg');
+const npm = require('./npm');
+const jsonFile = require('./jsonFile');
+
+/**
+ * @typedef {{
+ *  out?: string,
+ *  tsconfig?: string,
+ *  exclude?: Array<string>,
+ *  excludePrivate?: boolean,
+ *  excludeExternals?: boolean,
+ *  readme?: string,
+ *  theme?: string,
+ * }} TypeDocConfig
+ */
+
+/**
+ * @param {{
+ *   state: 'present'|'absent',
+ *   update: (config: TypeDocConfig) => TypeDocConfig
+ * }} options
+ */
+function typedoc({ state, update }) {
+  const packageFileDefault = packageJson();
+  const hasWorkspaces = Boolean(packageFileDefault.get('workspaces'));
+  const hasTypedoc = state === 'present';
+
+  pkg.withPackageJson((packageFile) => {
+    pkg.script(packageFile, {
+      name: 'typedoc',
+      script: 'typedoc',
+      state: !hasTypedoc || hasWorkspaces ? 'absent' : 'present',
+    });
+  });
+
+  const typedocFile = json('typedoc.json');
+
+  if (hasTypedoc) {
+    jsonFile.value(typedocFile, {
+      path: undefined,
+      state,
+      update: (config) => ({
+        ...update(config),
+        ...(hasWorkspaces
+          ? {
+              'external-modulemap': '.*packages/([^/]+)/.*',
+              entryPoints: ['packages/'],
+            }
+          : {
+              'external-modulemap': undefined,
+              entryPoints: ['src/index.ts'],
+            }),
+      }),
+      /** @type {TypeDocConfig} */
+      default: {},
+    });
+
+    /**
+     * Otherwise save the file with content
+     */
+    typedocFile.save();
+  } else {
+    typedocFile.delete();
+  }
+
+  // Dependencies
+  npm.dependency({
+    dev: true,
+    name: ['typedoc'],
+    state: hasTypedoc ? 'present' : 'absent',
+  });
+  npm.dependency({
+    dev: true,
+    name: ['@strictsoftware/typedoc-plugin-monorepo'],
+    state: hasTypedoc && hasWorkspaces ? 'present' : 'absent',
+  });
+}
+
+module.exports = {
+  typedoc,
+};