@w5s/mrm-preset 1.0.0-alpha.9 → 1.0.0

package/core/jest.js

@@ -1,8 +1,7 @@
-/* eslint-disable no-template-curly-in-string */
 const { packageJson } = require('mrm-core');
-const pkg = require('./pkg');
-const npm = require('./npm');
-const project = require('./project');
+const pkg = require('./pkg.js');
+const npm = require('./npm.js');
+const project = require('./project.js');
 
 /**
  * @param {{
@@ -13,57 +12,48 @@ function jest({ state }) {
   const packageFileDefault = packageJson();
   const hasJest = state === 'present';
   const hasWorkspaces = pkg.hasWorkspaces(packageFileDefault);
-  const hasTypescript = pkg.hasDependency(packageFileDefault, 'typescript', 'dev');
 
   pkg.withPackageJson((packageFile) => {
-    if (hasJest) {
-      if (hasWorkspaces) {
-        pkg.value(packageFile, {
-          path: 'jest',
-          state: 'present',
-          update: () => ({
+    const ignorePatterns = ['/node_modules/', '/docs/', '/lib/', '/build/', '/.cache/', '/public/'];
+
+    pkg.value(packageFile, {
+      path: 'jest',
+      state: hasJest ? 'present' : 'absent',
+      update: hasWorkspaces
+        ? () => ({
             preset: 'es-jest',
             projects: packageFile
               .get('workspaces.packages', packageFile.get('workspaces', []))
               .map((/** @type {string} */ workspace) => `<rootDir>/${workspace}`),
-          }),
-        });
-      } else {
-        const ignorePatterns = ['/node_modules/', '/docs/', '/lib/', '/build/', '/.cache/', '/public/'];
-        packageFile.merge({
-          jest: {
+          })
+        : (config) => ({
+            ...config,
             preset: 'es-jest',
             coveragePathIgnorePatterns: ignorePatterns,
             testPathIgnorePatterns: ignorePatterns,
-          },
-        });
-      }
-    } else {
-      packageFile.unset('jest');
-    }
-
+          }),
+      default: {},
+    });
     pkg.script(packageFile, {
-      name: project.coverage,
-      script: hasWorkspaces ? pkg.emptyScript : 'jest --coverage',
-      state: !hasJest || hasWorkspaces ? 'default' : 'present',
+      name: `${project.coverage}:root`,
+      update: (/** @type {string|undefined} */ _) => (hasWorkspaces ? _ : 'jest --coverage'),
+      state: 'present',
+      default: undefined, // pkg.emptyScript,
     });
     pkg.script(packageFile, {
-      name: project.test,
-      script: hasWorkspaces ? pkg.emptyScript : 'jest',
-      state: !hasJest || hasWorkspaces ? 'default' : 'present',
+      name: `${project.test}:root`,
+      update: (/** @type {string|undefined} */ _) => (hasWorkspaces ? _ : 'jest'),
+      state: 'present',
+      default: undefined, // pkg.emptyScript,
     });
   });
+
   // Dependencies
   npm.dependency({
     dev: true,
-    name: ['jest', 'es-jest'],
+    name: ['jest', 'es-jest', '@jest/globals'],
     state: hasJest ? 'present' : 'absent',
   });
-  npm.dependency({
-    dev: true,
-    name: ['@types/jest'],
-    state: hasJest && hasTypescript ? 'present' : 'absent',
-  });
 
   // vscodeSnippets({
   //   name: 'jest',

package/core/jsonFile.js

@@ -41,16 +41,17 @@ function setValue(jsonFile, path, pathValue) {
  */
 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);
+    let currentValue = getValue(jsonFile, path);
+
+    if (currentValue == null) {
+      currentValue = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+      if (currentValue != null) {
+        setValue(jsonFile, path, currentValue);
       }
     }
 
-    const currentValue = getValue(jsonFile, path);
-    if (currentValue == null) {
-      const resolvedValue = typeof defaultValue === 'function' ? defaultValue() : defaultValue;
+    if (nextValue != null) {
+      const resolvedValue = typeof nextValue === 'function' ? nextValue(getValue(jsonFile, path)) : nextValue;
       if (resolvedValue != null) {
         setValue(jsonFile, path, resolvedValue);
       }

package/core/lintStaged.js

@@ -1,6 +1,6 @@
-const pkg = require('./pkg');
-const npm = require('./npm');
-const jsonFile = require('./jsonFile');
+const pkg = require('./pkg.js');
+const npm = require('./npm.js');
+const jsonFile = require('./jsonFile.js');
 
 /**
  * @typedef {Record<string, string|string[]>} LintStagedConfig

package/core/npm.js

@@ -1,5 +1,5 @@
 /* eslint-disable default-param-last */
-/* eslint-disable no-use-before-define */
+
 /* eslint-disable import/no-extraneous-dependencies */
 /* cSpell: disable */
 // @ts-check
@@ -24,18 +24,20 @@ const MrmError = require('mrm-core/src/error');
 const { yaml, json } = require('mrm-core');
 
 /**
- * @typedef Options
- * @property {boolean} [dev]
- * @property {boolean} [yarn]
- * @property {Record<string, string>} [versions]
+ * @typedef {{
+ *   dev?: boolean,
+ *   yarn?: boolean,
+ *   versions?: Record<string, string>,
+ * }} Options
  */
 
 /**
- * @typedef RunOptions
- * @property {boolean} [dev]
- * @property {boolean} [remove]
- * @property {boolean} [stdio]
- * @property {string} [cwd]
+ * @typedef {{
+ *  dev?: boolean,
+ *  remove?: boolean,
+ *  stdio?: boolean,
+ *  cwd?: string,
+ * }} RunOptions
  */
 
 /**
@@ -166,7 +168,7 @@ function getVersionedDep(dep, versions) {
 /**
  *
  * @param {Options} options
- * @returns {Record<string, string>}
+ * @returns {Record<string, string>} - map of package names to versions
  */
 function getOwnDependencies(options) {
   const pkg = packageJson({
@@ -181,7 +183,7 @@ function getOwnDependencies(options) {
  * Return version of installed npm package
  *
  * @param {string} name
- * @returns {string}
+ * @returns {string} - version
  */
 function getInstalledVersion(name) {
   return json(`./node_modules/${name}/package.json`).get('version');
@@ -194,7 +196,7 @@ function getInstalledVersion(name) {
  * @param {string[]} deps
  * @param {Record<string, string>} versions
  * @param {Options} options
- * @returns {string[]}
+ * @returns {string[]} - list of not installed dependencies
  */
 function getUnsatisfiedDeps(deps, versions, options) {
   const ownDependencies = getOwnDependencies(options);

package/core/pkg.js

@@ -1,16 +1,37 @@
 /* cSpell: disable */
 // @ts-check
 
+/**
+ * @typedef {string|boolean|number|null|Array<unknown>|Record<string, unknown>} JsonValue
+ */
+
 // @ts-ignore
 const { intersect } = require('semver-intersect');
-const { packageJson, file } = require('mrm-core');
-const jsonFile = require('./jsonFile');
+const { packageJson, file, json } = require('mrm-core');
+const glob = require('glob');
+const path = require('node:path');
+const jsonFile = require('./jsonFile.js');
 
 /**
  * An empty placeholder for npm script
  */
 const emptyScript = ':';
 
+/**
+ * @param {import('mrm-core').Json} packageFile
+ * @returns {'application'|'library'|'workspace'} the archetype value
+ */
+function archetype(packageFile) {
+  if (hasWorkspaces(packageFile)) {
+    return 'workspace';
+  }
+  if (packageFile.get('private') === true || (packageFile.get('main') == null && packageFile.get('exports'))) {
+    return 'application';
+  }
+
+  return 'library';
+}
+
 /**
  * @param {(pkg: import('mrm-core').PackageJson) => void} block
  */
@@ -21,26 +42,58 @@ function withPackageJson(block) {
 }
 
 /**
- * @param {import('mrm-core').PackageJson} packageFile
+ * @param {import("mrm-core").Json} packageFile
+ * @returns {string[]} - The list of workspace matchers
+ */
+function listWorkspaceMatchers(packageFile) {
+  return packageFile.get('workspaces.packages', packageFile.get('workspaces', []));
+}
+
+/**
+ * @param {(workspace: {
+ *   projectDir: string;
+ *   packageFile: import("mrm-core").Json;
+ * }) => void} fn
+ */
+function forEachWorkspace(fn) {
+  const packageRoot = packageJson();
+  const workspacesMatchers = listWorkspaceMatchers(packageRoot);
+
+  for (const workspaceMatcher of workspacesMatchers) {
+    const directories = glob.sync(workspaceMatcher);
+    directories.forEach((directory) => {
+      const packageFile = json(path.join(directory, 'package.json'));
+      fn({
+        projectDir: directory,
+        packageFile,
+      });
+      packageFile.save();
+    });
+  }
+}
+
+/**
+ * @template {undefined|JsonValue} T
+ * @param {import('mrm-core').Json} packageFile
  * @param {{
  *   name: string,
- *   state: 'present'|'absent'|'default',
- *   script: string,
+ *   state: 'present'|'absent',
+ *   update?: T | ((previousValue: T) => T)
+ *   default?: T | (() => T)
  * }} 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);
-  }
+function script(packageFile, options) {
+  jsonFile.value(packageFile, {
+    ...options,
+    path: ['scripts', options.name],
+  });
 }
 
 const defaultManager = 'npm';
 
 /**
  * @param {import('mrm-core').PackageJson} packageFile
- * @returns {'yarn'|'npm'}
+ * @returns {'yarn'|'npm'} - The manager used by the package
  */
 function manager(packageFile) {
   if (packageFile.get('packagerManager')) {
@@ -60,7 +113,7 @@ function manager(packageFile) {
 
 /**
  *
- * @param {import('mrm-core').PackageJson} packageFile
+ * @param {import('mrm-core').Json} packageFile
  */
 function hasWorkspaces(packageFile) {
   return Boolean(packageFile.get('workspaces'));
@@ -88,7 +141,7 @@ function hasDependency(packageFile, packageName, dependencyType) {
 
 /**
  *
- * @param {import('mrm-core').PackageJson} packageFile
+ * @param {import('mrm-core').Json} packageFile
  * @param {Record<string, string>} engineVersionMap
  */
 function engineMinVersion(packageFile, engineVersionMap) {
@@ -110,15 +163,19 @@ function engineMinVersion(packageFile, engineVersionMap) {
       Object.keys(engineVersionMap).map((engineName) => [engineName, engineConstraint(engineName)])
     ),
   });
+  return packageFile.get('engines');
 }
 
 module.exports = {
   ...jsonFile,
   emptyScript,
+  archetype,
   script,
   manager,
   engineMinVersion,
   hasDependency,
   hasWorkspaces,
   withPackageJson,
+  forEachWorkspace,
+  listWorkspaceMatchers,
 };

package/core/project.js

@@ -1,3 +1,5 @@
+/** @type {'docs'} */
+const docs = 'docs';
 /** @type {'install'} */
 const install = 'install';
 /** @type {'prepare'} */
@@ -24,6 +26,8 @@ const validate = 'validate';
 const release = 'release';
 /** @type {'rescue'} */
 const rescue = 'rescue';
+/** @type {'spellcheck'} */
+const spellcheck = 'spellcheck';
 
 /**
  * @param {string} taskName
@@ -41,6 +45,7 @@ function post(taskName) {
 
 module.exports = {
   build,
+  docs,
   prepare,
   develop,
   clean,
@@ -55,4 +60,5 @@ module.exports = {
   rescue,
   test,
   validate,
+  spellcheck,
 };

package/core/semanticRelease.js

@@ -1,6 +1,6 @@
-const npm = require('./npm');
-const pkg = require('./pkg');
-const jsonFile = require('./jsonFile');
+const npm = require('./npm.js');
+const pkg = require('./pkg.js');
+const jsonFile = require('./jsonFile.js');
 
 /**
  * @typedef {{

package/core/turbo.js

@@ -0,0 +1,52 @@
+const { json } = require('mrm-core');
+const npm = require('./npm.js');
+const jsonFile = require('./jsonFile.js');
+
+/**
+ * @typedef {{
+ *   $schema: string,
+ *   pipeline?: Record<string, unknown>,
+ *   globalDependencies?: Array<string>,
+ * }} TurboConfig
+ */
+
+/**
+ * @param {{
+ *   state: 'present'|'absent',
+ *   update: (config: TurboConfig) => TurboConfig
+ * }} options
+ */
+function turbo({ state, update }) {
+  const hasTurbo = state === 'present';
+  const turboFile = json('turbo.json');
+
+  if (hasTurbo) {
+    jsonFile.value(turboFile, {
+      path: undefined,
+      state,
+      update,
+      /** @type {TurboConfig} */
+      default: {
+        $schema: 'https://turborepo.org/schema.json',
+      },
+    });
+
+    /**
+     * Otherwise save the file with content
+     */
+    turboFile.save();
+  } else {
+    turboFile.delete();
+  }
+
+  // Dependencies
+  npm.dependency({
+    dev: true,
+    name: ['turbo'],
+    state: hasTurbo ? 'present' : 'absent',
+  });
+}
+
+module.exports = {
+  turbo,
+};

package/core/typedoc.js

@@ -1,7 +1,7 @@
 const { packageJson, json } = require('mrm-core');
-const pkg = require('./pkg');
-const npm = require('./npm');
-const jsonFile = require('./jsonFile');
+const pkg = require('./pkg.js');
+const npm = require('./npm.js');
+const jsonFile = require('./jsonFile.js');
 
 /**
  * @typedef {{

package/core/vitest.js

@@ -0,0 +1,77 @@
+const { file, packageJson } = require('mrm-core');
+const fs = require('node:fs');
+const pkg = require('./pkg.js');
+const npm = require('./npm.js');
+const project = require('./project.js');
+
+/**
+ * @param {{
+ *   state: 'present'|'absent'
+ * }} options
+ */
+function vitest({ state }) {
+  const hasVitest = state === 'present';
+  const hasWorkspace = pkg.hasWorkspaces(packageJson());
+  const vitestScript = 'vitest run';
+  const update = (/** @type {string|undefined} */ _) =>
+    hasVitest ? vitestScript : _ === vitestScript ? pkg.emptyScript : _;
+
+  // Dependencies
+  npm.dependency({
+    dev: true,
+    name: ['vite', 'vitest'],
+    state: hasVitest ? 'present' : 'absent',
+  });
+
+  /** @type {string|undefined} */
+  let viteVersion;
+  /** @type {string|undefined} */
+  let vitestVersion;
+  pkg.withPackageJson((packageFile) => {
+    viteVersion = packageFile.get('devDependencies.vite');
+    vitestVersion = packageFile.get('devDependencies.vitest');
+    pkg.script(packageFile, {
+      name: `${project.test}:root`,
+      update,
+      state: hasWorkspace ? 'absent' : 'present',
+    });
+  });
+
+  pkg.forEachWorkspace(({ projectDir, packageFile }) => {
+    const hasSrc = fs.existsSync(`${projectDir}/src`);
+    const packageState = hasVitest && hasSrc ? 'present' : 'absent';
+    pkg.value(packageFile, {
+      path: 'devDependencies.vite',
+      state: packageState,
+      update: (_) => _ ?? viteVersion,
+    });
+    pkg.value(packageFile, {
+      path: 'devDependencies.vitest',
+      state: packageState,
+      update: (_) => _ ?? vitestVersion,
+    });
+    pkg.script(packageFile, {
+      name: `${project.test}:src`,
+      update,
+      state: packageState,
+    });
+    const viteConfig = file(`${projectDir}/vite.config.ts`);
+    if (packageState === 'absent') {
+      viteConfig.delete();
+    } else if (!viteConfig.exists()) {
+      viteConfig.save(
+        `/// <reference types="vitest" />
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  test: {},
+});
+`
+      );
+    }
+  });
+}
+
+module.exports = {
+  vitest,
+};

package/core/vscode.js

@@ -1,13 +1,23 @@
 const { json } = require('mrm-core');
 
 /**
- * @param {Array<string>} recommendations
+ * @param {{
+ *   name: string,
+ *   state: 'present'|'absent',
+ * }} recommendation
  */
-function vscodeRecommendedExtension(recommendations) {
+function vscodeRecommendedExtension(recommendation) {
   const packageFile = json('.vscode/extensions.json');
-  packageFile.merge({
-    recommendations,
-  });
+  if (recommendation.state === 'present') {
+    packageFile.merge({
+      recommendations: [recommendation.name],
+    });
+  } else {
+    packageFile.set(
+      'recommendations',
+      packageFile.get('recommendations', []).filter((/** @type {string} */ _) => _ !== recommendation.name)
+    );
+  }
   packageFile.save();
 }
 exports.vscodeRecommendedExtension = vscodeRecommendedExtension;

package/cspell/index.js

@@ -1,25 +1,46 @@
-const { cspell } = require('../core/cspell');
+const { cspell } = require('../core/cspell.js');
+const project = require('../core/project.js');
+const pkg = require('../core/pkg.js');
+const npm = require('../core/npm.js');
 
 function task() {
+  const preset = '@w5s/cspell-config';
   cspell({
     state: 'present',
     update: (_) => ({
       ..._,
-      ignorePaths: Array.from(
-        new Set([
-          '**/build/**',
-          '**/lib/**',
-          '**/node_modules/**',
-          '**/package.json',
-          '**/package-lock.json',
-          '**/yarn.lock',
-          '**/*.log',
-          '**/CHANGELOG.md',
-          ...(_.ignorePaths || []),
-        ])
-      ),
+      import: [preset],
     }),
   });
+  npm.dependency({
+    dev: true,
+    name: [preset],
+    state: 'present',
+  });
+
+  pkg.withPackageJson((packageFile) => {
+    const hasWorkspaces = pkg.hasWorkspaces(packageFile);
+    const workspaceMatchers = pkg.listWorkspaceMatchers(packageFile);
+    pkg.script(packageFile, {
+      name: project.spellcheck,
+      update: `turbo run spellcheck`,
+      state: 'present',
+    });
+    pkg.script(packageFile, {
+      name: `${project.spellcheck}:root`,
+      update: `cspell --no-progress '**' ${
+        hasWorkspaces ? `${workspaceMatchers.map((_) => `--exclude='${_}/**'`).join(' ')}` : ''
+      }`,
+      state: 'present',
+    });
+  });
+  pkg.forEachWorkspace(({ packageFile }) => {
+    pkg.script(packageFile, {
+      name: project.spellcheck,
+      update: `cspell --no-progress '**'`,
+      state: 'present',
+    });
+  });
 }
 
 task.description = 'Adds CSpell support';

package/editorconfig/index.js

@@ -1,6 +1,6 @@
 const { ini } = require('mrm-core');
 const createDebug = require('debug');
-const { vscodeRecommendedExtension } = require('../core/vscode');
+const { vscodeRecommendedExtension } = require('../core/vscode.js');
 
 /**
  *
@@ -26,7 +26,7 @@ function createEditorConfig(defaults) {
 
   /**
    * @param {string} section
-   * @param existing
+   * @param {defaults} existing
    */
   function mergeSection(section, existing = {}) {
     return Object.assign(existing, defaults[section] || {});
@@ -43,7 +43,10 @@ function createEditorConfig(defaults) {
 
     editorConfigFile.save();
 
-    vscodeRecommendedExtension(['editorconfig.editorconfig']);
+    vscodeRecommendedExtension({
+      name: 'editorconfig.editorconfig',
+      state: 'present',
+    });
   }
 
   task.description = 'Adds EditorConfig file';
@@ -66,31 +69,38 @@ module.exports = createEditorConfig({
     spaces_around_operators: true,
     trim_trailing_whitespace: true,
   },
-  '*.json': {
+  '*.{json,json5,webmanifest}': {
     indent_size: 2,
     indent_style: 'space',
     insert_final_newline: 'ignore',
   },
-  '*.yml': {
+  '*.{yml,yaml}': {
     indent_size: 2,
     indent_style: 'space',
   },
-  '*.{bat,reg,ps1,vbs,cs,,fs,ahk}': {
+  '*.{bat,reg,ps1,vbs,cs,cmd,fs,ahk}': {
     end_of_line: 'crlf',
   },
-  '*.{css,scss,less}': {
+  '*.{sh,zsh}': {
+    end_of_line: 'lf',
+  },
+  '*.{css,sass,scss,less,pcss}': {
     indent_size: 2,
     indent_style: 'space',
     max_line_length: 120,
     quote_type: 'single',
   },
-  '*.{js,jsx,ts,tsx,js.hbs}': {
+  '*.{js,jsx,jsm,ts,tsx,cjs,cjs,cjsx,cts,ctsx,mjs,mts,mtsx,js.hbs}': {
     indent_size: 2,
     indent_style: 'space',
     max_line_length: 120,
     quote_type: 'single',
   },
-  '*.{md,mdwn,mdown,markdown,apib}': {
+  '*.{htm,html,svg,vue}': {
+    indent_size: 2,
+    indent_style: 'space',
+  },
+  '*.{md,mdwn,mdown,markdown,mdx,apib}': {
     indent_size: 4,
     indent_style: 'space',
     insert_final_newline: true,