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

package/project/index.js

@@ -1,24 +1,29 @@
+const { dirname } = require('node:path');
 const { packageJson, json, makeDirs } = require('mrm-core');
-const git = require('../core/git');
-const pkg = require('../core/pkg');
-const npm = require('../core/npm');
-const { vscodeTask } = require('../core/vscode');
-const project = require('../core/project');
+const git = require('../core/git.js');
+const pkg = require('../core/pkg.js');
+const jsonFile = require('../core/pkg.js');
+const npm = require('../core/npm.js');
+const { vscodeTask } = require('../core/vscode.js');
+const project = require('../core/project.js');
 const mrmPackageJson = require('../package.json');
+const { turbo } = require('../core/turbo.js');
 
 /**
  *
  * @param {string} script
  */
-const npmRun = (script) => {
-  switch (script) {
-    case project.install:
-    case project.test:
-      return `npm ${script}`;
-    default:
-      return `npm run ${script}`;
-  }
-};
+// const npmRun = (script) => {
+//   switch (script) {
+//     case project.install:
+//     case project.test: {
+//       return `npm ${script}`;
+//     }
+//     default: {
+//       return `npm run ${script}`;
+//     }
+//   }
+// };
 /**
  *
  * @param {string} script
@@ -28,210 +33,287 @@ const turboRun = (script) => `turbo run ${script}`;
 /**
  *
  * @param {string} script
+ * @param {boolean} allowEmpty
  */
-const npmRunAll = (script) => `npm-run-all -p "${script}:*"`;
+const npmRunAll = (script, allowEmpty) => `concurrently "npm:${script}:*" ${allowEmpty ? `"${pkg.emptyScript}"` : ''}`;
 function task() {
-  const packageFile = packageJson();
+  const rootPackageFile = packageJson();
+  const rootUseWorkspace = pkg.hasWorkspaces(rootPackageFile);
+  const rootEngineMinVersion = {
+    // @ts-ignore
+    node: '>=12.x',
+    yarn: '>=1.x',
+    npm: '>=6.x',
+    ...mrmPackageJson.engines,
+  };
   const gitSupported = git.hasGit();
-  const useWorkspace = packageFile.get('mrmConfig.packageArchetype') === 'workspace';
-  const packageManager = pkg.manager(packageFile);
+  const packageManager = pkg.manager(rootPackageFile);
+  const gitRepository = git.remoteSync();
 
   // Detect git repository
-  pkg.value(packageFile, {
-    path: 'repository',
-    state: 'present',
-    update: () => {
-      const gitRepository = git.remoteSync();
-      if (gitRepository) {
-        return {
-          type: 'git',
-          url: gitRepository,
-        };
-      }
+  if (rootUseWorkspace) {
+    const dirs = pkg.listWorkspaceMatchers(rootPackageFile).map(dirname);
+    makeDirs(dirs);
+  }
 
-      return undefined;
-    },
-  });
+  const setDefault = (/** @type {import("mrm-core").Json} */ currentPackageFile, /** @type {boolean} */ root) => {
+    jsonFile.value(currentPackageFile, {
+      path: 'type',
+      state: 'present',
+      default: 'module',
+    });
+    jsonFile.value(currentPackageFile, {
+      path: 'license',
+      state: 'present',
+      update: (_) => _ ?? (root && rootUseWorkspace ? 'UNLICENSED' : undefined),
+    });
+    jsonFile.value(currentPackageFile, {
+      path: 'version',
+      state: root && rootUseWorkspace ? 'absent' : 'present',
+      default: '1.0.0-alpha.0',
+    });
+    jsonFile.value(currentPackageFile, {
+      path: 'description',
+      state: 'present',
+      update: (_) => _ ?? (root && rootUseWorkspace ? '' : undefined),
+    });
+  };
+  const addScripts = (/** @type {import("mrm-core").Json} */ currentPackageFile, /** @type {boolean} */ root) => {
+    const useWorkspace = pkg.hasWorkspaces(currentPackageFile);
 
-  // build & clean
-  pkg.script(packageFile, {
-    name: project.build,
-    script: npmRunAll(project.build),
-    state: 'present',
-  });
-  pkg.script(packageFile, {
-    name: `${project.build}:empty`,
-    script: pkg.emptyScript,
-    state: 'present',
-  });
-  pkg.script(packageFile, {
-    name: `${project.build}:packages`,
-    script: turboRun(project.build),
-    state: useWorkspace ? 'present' : 'absent',
-  });
-  pkg.script(packageFile, {
-    name: project.clean,
-    script: useWorkspace ? turboRun(project.clean) : pkg.emptyScript,
-    state: useWorkspace ? 'present' : 'default',
-  });
+    // build
+    pkg.script(currentPackageFile, {
+      name: project.build,
+      update: useWorkspace ? turboRun(project.build) : npmRunAll(project.build, true),
+      state: 'present',
+    });
 
-  // develop & auto build & load
-  pkg.script(packageFile, {
-    name: project.develop,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // lint
+    pkg.script(currentPackageFile, {
+      name: project.lint,
+      update: useWorkspace ? turboRun(project.lint) : npmRunAll(project.lint, true),
+      state: 'present',
+    });
+    pkg.script(currentPackageFile, {
+      name: project.format,
+      update: useWorkspace ? turboRun(project.format) : npmRunAll(project.format, true),
+      state: 'present',
+    });
 
-  // lint
-  pkg.script(packageFile, {
-    name: project.lint,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: project.format,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // test
+    // pkg.script(currentPackageFile, {
+    //   name: project.coverage,
+    //   script: pkg.emptyScript,
+    //   state: 'default',
+    // });
+    pkg.script(currentPackageFile, {
+      name: project.test,
+      update: useWorkspace ? turboRun(project.test) : npmRunAll(project.test, true),
+      state: 'present',
+      default: pkg.emptyScript,
+    });
 
-  // test
-  pkg.script(packageFile, {
-    name: project.coverage,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: project.test,
-    script: npmRunAll(project.test),
-    state: 'present',
-  });
-  pkg.script(packageFile, {
-    name: `${project.prepare}:empty`,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: `${project.prepare}:packages`,
-    script: turboRun(project.test),
-    state: useWorkspace ? 'present' : 'absent',
-  });
-  pkg.script(packageFile, {
-    name: project.validate,
-    script: `${npmRun(project.build)} && ${npmRun(project.lint)} && ${npmRun(project.test)}`,
-    state: 'present',
-  });
+    // prepare
+    pkg.script(currentPackageFile, {
+      name: project.prepare,
+      update: npmRunAll(project.prepare, true),
+      state: 'present',
+    });
 
-  // code analysis
-  pkg.script(packageFile, {
-    name: project.codeAnalysis,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // clean
+    pkg.script(currentPackageFile, {
+      name: project.clean,
+      update: useWorkspace ? turboRun(project.clean) : npmRunAll(project.clean, true),
+      state: 'present',
+    });
 
-  // prepare
-  pkg.script(packageFile, {
-    name: project.prepare,
-    script: npmRunAll(project.prepare),
-    state: 'present',
-  });
-  pkg.script(packageFile, {
-    name: `${project.prepare}:empty`,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: `${project.prepare}:packages`,
-    script: 'lerna bootstrap',
-    state: useWorkspace ? 'present' : 'absent',
-  });
+    // Root
 
-  // rescue
-  pkg.script(packageFile, {
-    name: project.rescue,
-    script: `${gitSupported ? 'git clean -fdx' : ''};${packageManager} install`,
-    state: 'present',
+    // rescue
+    pkg.script(currentPackageFile, {
+      name: project.rescue,
+      update: `${gitSupported ? 'git clean -fdx' : ''};${packageManager} install`,
+      state: root ? 'present' : 'absent',
+    });
+
+    // release
+    pkg.script(currentPackageFile, {
+      name: project.release,
+      default: pkg.emptyScript,
+      state: root ? 'present' : 'absent',
+    });
+
+    // code analysis
+    pkg.script(currentPackageFile, {
+      name: project.codeAnalysis,
+      default: pkg.emptyScript,
+      state: root ? 'present' : 'absent',
+    });
+
+    // develop & auto build & load
+    pkg.script(currentPackageFile, {
+      name: project.develop,
+      default: pkg.emptyScript,
+      state: root ? 'present' : 'absent',
+    });
+
+    // TODO: remove
+    pkg.script(currentPackageFile, {
+      name: `${project.clean}:packages`,
+      state: 'absent',
+    });
+    pkg.script(currentPackageFile, {
+      name: `${project.build}:packages`,
+      state: 'absent',
+    });
+    pkg.script(currentPackageFile, {
+      name: `${project.test}:packages`,
+      state: 'absent',
+    });
+  };
+
+  pkg.withPackageJson((packageFile) => {
+    pkg.value(packageFile, {
+      path: 'repository',
+      state: 'present',
+      update: () =>
+        gitRepository
+          ? {
+              type: 'git',
+              url: gitRepository,
+            }
+          : undefined,
+    });
+
+    setDefault(packageFile, false);
+    addScripts(packageFile, true);
+
+    pkg.script(packageFile, {
+      name: project.validate,
+      update: `${turboRun([project.build, project.lint, project.test].join(' '))}`,
+      state: 'present',
+    });
+
+    // Engine
+    pkg.engineMinVersion(packageFile, rootEngineMinVersion);
   });
+  pkg.forEachWorkspace((workspace) => {
+    pkg.value(workspace.packageFile, {
+      path: 'repository',
+      state: 'present',
+      update: () =>
+        gitRepository
+          ? {
+              type: 'git',
+              url: gitRepository,
+              directory: workspace.projectDir,
+            }
+          : undefined,
+    });
+    setDefault(workspace.packageFile, false);
+    addScripts(workspace.packageFile, false);
 
-  // release
-  pkg.script(packageFile, {
-    name: project.release,
-    script: pkg.emptyScript,
-    state: 'default',
+    // Engine
+    pkg.engineMinVersion(workspace.packageFile, { node: rootEngineMinVersion.node });
   });
 
   // workspace
-  const turboConfig = json('turbo.json', {
-    $schema: 'https://turborepo.org/schema.json',
-    pipeline: {
-      [project.build]: {
-        dependsOn: ['^build'],
-        outputs: ['lib/**', 'dist/**', '.next/**'],
-      },
-      [project.test]: {},
-      [project.lint]: {},
-      [project.format]: {},
-      [project.clean]: {
-        cache: false,
-      },
-      [project.develop]: {
-        cache: false,
-      },
-    },
-    globalDependencies: ['tsconfig.settings.json'],
-  });
   const lernaConfig = json('lerna.json', {
-    version: packageFile.get('version'),
+    version: rootPackageFile.get('version'),
   });
-  if (useWorkspace) {
-    const packages = ['packages/*'];
+  if (rootUseWorkspace) {
     const versionIndependent = lernaConfig.get('version') === 'independent';
-    packageFile.merge({ workspaces: { packages } });
+    const gitmoji = true;
+
     lernaConfig.merge({
+      $schema: 'https://json.schemastore.org/lerna.json',
       command: {
         publish: {
           conventionalCommits: true,
           npmClient: 'npm',
         },
         version: {
-          message: `chore(release): publish${versionIndependent ? '' : ' %s'}`,
+          message: gitmoji
+            ? `🔖 Publish${versionIndependent ? '' : ' %s'}`
+            : `chore(release): publish${versionIndependent ? '' : ' %s'}`,
         },
       },
       npmClient: packageManager,
-      useWorkspaces: useWorkspace,
+      useWorkspaces: rootUseWorkspace,
+      changelogPreset: '@w5s/conventional-changelog',
     });
     lernaConfig.save();
-    turboConfig.save();
-    makeDirs('packages');
   } else {
-    packageFile.unset('workspaces');
     lernaConfig.delete();
-    turboConfig.delete();
   }
 
-  // Engine
-  pkg.engineMinVersion(
-    packageFile,
-    Object.assign(
-      {
-        node: '>=12.x',
-        yarn: '>=1.x',
-        npm: '>=6.x',
+  rootPackageFile.save();
+
+  // Turbo config
+  turbo({
+    state: 'present',
+    update: (_) => ({
+      ..._,
+      pipeline: {
+        [project.build]: {
+          dependsOn: [`^${project.build}`, `//#${project.build}:root`],
+          outputs: ['lib/**', 'dist/**', '.next/**'],
+        },
+        [`//#${project.build}:root`]: {},
+        [project.test]: {
+          dependsOn: [`^${project.build}`, `//#${project.test}:root`],
+        },
+        [`//#${project.test}:root`]: {},
+        [project.lint]: {
+          dependsOn: [`^${project.build}`, `//#${project.lint}:root`],
+        },
+        [`//#${project.lint}:root`]: {},
+        [project.prepare]: {},
+        [project.format]: {
+          dependsOn: [`//#${project.format}:root`],
+        },
+        [`//#${project.format}:root`]: {},
+        [project.docs]: {},
+        [project.spellcheck]: {
+          dependsOn: [`//#${project.spellcheck}:root`],
+        },
+        [`//#${project.spellcheck}:root`]: {},
+        [project.clean]: {
+          dependsOn: [`//#${project.clean}:root`],
+          cache: false,
+        },
+        [`//#${project.clean}:root`]: {
+          cache: false,
+        },
+        [project.develop]: {
+          cache: false,
+        },
       },
-      mrmPackageJson.engines
-    )
-  );
-  packageFile.save();
+      globalDependencies: ['tsconfig.settings.json'],
+    }),
+  });
 
   // Dependencies
+  // clean
   npm.dependency({
     dev: true,
     name: ['npm-run-all'],
+    state: 'absent',
+  });
+  npm.dependency({
+    dev: true,
+    name: ['concurrently'],
     state: 'present',
   });
   npm.dependency({
     dev: true,
-    name: ['lerna', 'turbo'],
-    state: useWorkspace ? 'present' : 'absent',
+    name: ['lerna'],
+    state: rootUseWorkspace ? 'present' : 'absent',
+  });
+  npm.dependency({
+    dev: true,
+    name: ['@w5s/conventional-changelog'],
+    state: 'present',
   });
 
   // VSCode

package/release/index.js

@@ -1,17 +1,17 @@
 const { packageJson } = require('mrm-core');
-const pkg = require('../core/pkg');
-const project = require('../core/project');
-const { semanticRelease } = require('../core/semanticRelease');
+const pkg = require('../core/pkg.js');
+const project = require('../core/project.js');
+const { semanticRelease } = require('../core/semanticRelease.js');
 
 function task() {
-  const useWorkspace = packageJson().get('mrmConfig.packageArchetype') === 'workspace';
+  const useWorkspace = pkg.hasWorkspaces(packageJson());
 
   // release
   pkg.withPackageJson((packageFile) => {
     pkg.script(packageFile, {
       name: project.release,
       // eslint-disable-next-line no-template-curly-in-string
-      script: useWorkspace ? 'is-ci && lerna publish --yes || lerna publish' : semanticRelease.command(),
+      update: useWorkspace ? '[ -n "${CI:-}" ] && lerna publish --yes || lerna publish' : semanticRelease.command(),
       state: 'present',
     });
   });

package/renovate/index.js

@@ -1,5 +1,6 @@
 const { json, packageJson } = require('mrm-core');
-const { hasGit } = require('../core/git');
+const { hasGit } = require('../core/git.js');
+const pkg = require('../core/pkg.js');
 
 /**
  *
@@ -19,13 +20,13 @@ function createRenovate({ renovatePresetApplication, renovatePresetLibrary }) {
     const gitSupported = hasGit();
 
     if (gitSupported) {
-      const packageArchetype = packageJson().get('mrmConfig.packageArchetype', 'library');
+      const packageFile = packageJson();
+      const packageArchetype = pkg.archetype(packageFile);
       const renovatePresetResolved =
         renovatePreset || (packageArchetype === 'application' ? renovatePresetApplication : renovatePresetLibrary);
       const renovateFile = json('renovate.json');
       renovateFile.merge({
         $schema: 'https://docs.renovatebot.com/renovate-schema.json',
-        ignorePaths: ['**/node_modules/**'],
       });
       renovateFile.set(
         'extends',

package/tsconfig.json

@@ -1,14 +1,11 @@
 {
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "../../tsconfig.json",
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../../tsconfig.settings.json",
   "compilerOptions": {
     "allowJs": true,
     "checkJs": true,
     "noEmit": true,
     "resolveJsonModule": true
   },
-  "exclude": [
-    "**/templates/**",
-    "_tester"
-  ]
+  "exclude": ["**/templates/**", "_tester"]
 }

package/{jest → vitest}/index.js

@@ -1,15 +1,15 @@
-const { jest } = require('../core/jest');
+const { vitest } = require('../core/vitest.js');
 
 /**
  *
  */
 function task() {
-  jest({
+  vitest({
     state: 'present',
   });
 }
 
-task.description = 'Setup Jest';
+task.description = 'Setup Vitest';
 task.parameters = {};
 
 module.exports = task;