@w5s/mrm-preset 1.0.0-alpha.2 → 1.0.0-alpha.21

package/project/index.js

@@ -1,207 +1,268 @@
+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 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}`;
+  }
+};
+/**
+ *
+ * @param {string} script
+ */
+const turboRun = (script) => `turbo run ${script}`;
+
+/**
+ *
+ * @param {string} script
+ * @param {boolean} allowEmpty
+ */
+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 = Object.assign(
+    {
+      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);
-
-  /**
-   *
-   * @param {string} script
-   */
-  const npmRun = (script) => {
-    switch (script) {
-      case project.install:
-      case project.test:
-        return `npm ${script}`;
-      default:
-        return `npm run ${script}`;
-    }
-  };
-  /**
-   *
-   * @param {string} script
-   */
-  const lernaRun = (script) => `lerna run ${script}`;
-
-  /**
-   *
-   * @param {string} script
-   */
-  const npmRunAll = (script) => `npm-run-all -p "${script}:*"`;
+  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,
-        };
-      }
-
-      return undefined;
-    },
-  });
+  if (rootUseWorkspace) {
+    const dirs = pkg.listWorkspaceMatchers(rootPackageFile).map(dirname);
+    makeDirs(dirs);
+  }
 
-  // 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: lernaRun(project.build),
-    state: useWorkspace ? 'present' : 'absent',
-  });
-  pkg.script(packageFile, {
-    name: project.clean,
-    script: useWorkspace ? lernaRun(project.clean) : pkg.emptyScript,
-    state: useWorkspace ? 'present' : 'default',
-  });
+  const addScripts = (/** @type {import("mrm-core").Json} */ currentPackageFile, /** @type {boolean} */ root) => {
+    const useWorkspace = pkg.hasWorkspaces(currentPackageFile);
 
-  // develop & auto build & load
-  pkg.script(packageFile, {
-    name: project.develop,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // build
+    pkg.script(currentPackageFile, {
+      name: project.build,
+      script: npmRunAll(project.build, false),
+      state: 'present',
+    });
+    pkg.script(currentPackageFile, {
+      name: `${project.build}:packages`,
+      script: turboRun(project.build),
+      state: useWorkspace ? 'present' : 'absent',
+    });
 
-  // lint
-  pkg.script(packageFile, {
-    name: project.lint,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: project.format,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // lint
+    pkg.script(currentPackageFile, {
+      name: project.lint,
+      script: npmRunAll(project.lint, true),
+      state: 'present',
+    });
+    pkg.script(currentPackageFile, {
+      name: project.format,
+      script: npmRunAll(project.format, true),
+      state: 'present',
+    });
 
-  // test
-  pkg.script(packageFile, {
-    name: project.coverage,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
-  pkg.script(packageFile, {
-    name: project.test,
-    script: useWorkspace ? lernaRun(project.test) : pkg.emptyScript,
-    state: useWorkspace ? 'present' : 'default',
-  });
-  pkg.script(packageFile, {
-    name: project.validate,
-    script: `${npmRun(project.build)} && ${npmRun(project.lint)} && ${npmRun(project.test)}`,
-    state: 'present',
-  });
+    // test
+    // pkg.script(currentPackageFile, {
+    //   name: project.coverage,
+    //   script: pkg.emptyScript,
+    //   state: 'default',
+    // });
+    pkg.script(currentPackageFile, {
+      name: project.test,
+      script: useWorkspace ? npmRunAll(project.test, false) : pkg.emptyScript,
+      state: useWorkspace ? 'present' : 'default',
+    });
 
-  // code analysis
-  pkg.script(packageFile, {
-    name: project.codeAnalysis,
-    script: pkg.emptyScript,
-    state: 'default',
-  });
+    // prepare
+    pkg.script(currentPackageFile, {
+      name: project.prepare,
+      script: npmRunAll(project.prepare, 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',
-  });
+    // clean
+    pkg.script(currentPackageFile, {
+      name: project.clean,
+      script: npmRunAll(project.clean, true),
+      state: 'present',
+    });
+    pkg.script(currentPackageFile, {
+      name: `${project.clean}:packages`,
+      script: turboRun(project.clean),
+      state: useWorkspace ? 'present' : 'absent',
+    });
 
-  // rescue
-  pkg.script(packageFile, {
-    name: project.rescue,
-    script: `${gitSupported ? 'git clean -fdx' : ''};${packageManager} install`,
-    state: 'present',
+    // Root
+
+    // rescue
+    pkg.script(currentPackageFile, {
+      name: project.rescue,
+      script: `${gitSupported ? 'git clean -fdx' : ''};${packageManager} install`,
+      state: root ? 'present' : 'absent',
+    });
+
+    // release
+    pkg.script(currentPackageFile, {
+      name: project.release,
+      script: pkg.emptyScript,
+      state: root ? 'default' : 'absent',
+    });
+
+    // code analysis
+    pkg.script(currentPackageFile, {
+      name: project.codeAnalysis,
+      script: pkg.emptyScript,
+      state: root ? 'default' : 'absent',
+    });
+
+    // develop & auto build & load
+    pkg.script(currentPackageFile, {
+      name: project.develop,
+      script: pkg.emptyScript,
+      state: root ? 'default' : 'absent',
+    });
+  };
+
+  // eslint-disable-next-line no-shadow
+  pkg.withPackageJson((packageFile) => {
+    pkg.value(packageFile, {
+      path: 'repository',
+      state: 'present',
+      update: () =>
+        gitRepository
+          ? {
+              type: 'git',
+              url: gitRepository,
+            }
+          : undefined,
+    });
+
+    addScripts(packageFile, true);
+
+    pkg.script(packageFile, {
+      name: project.validate,
+      script: `${npmRun(project.build)} && ${npmRun(project.lint)} && ${npmRun(project.test)}`,
+      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,
+    });
+    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 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: 'gitmoji-config',
     });
     lernaConfig.save();
-    makeDirs('packages');
   } else {
-    packageFile.unset('workspaces');
     lernaConfig.delete();
   }
 
-  // Engine
-  pkg.engineMinVersion(
-    packageFile,
-    Object.assign(
-      {
-        node: '>=12.x',
-        yarn: '>=1.x',
-        npm: '>=6.x',
+  rootPackageFile.save();
+
+  // Turbo config
+  turbo({
+    state: rootUseWorkspace ? 'present' : 'absent',
+    update: (_) => ({
+      ..._,
+      baseBranch: 'origin/main',
+      pipeline: {
+        [project.build]: {
+          dependsOn: ['^build'],
+          outputs: ['lib/**', 'dist/**', '.next/**'],
+        },
+        [project.test]: {},
+        [project.lint]: {},
+        [project.prepare]: {},
+        [project.format]: {},
+        [project.docs]: {},
+        [project.spellcheck]: {},
+        [project.clean]: {
+          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'],
-    state: useWorkspace ? 'present' : 'absent',
+    name: ['lerna', 'conventional-changelog-gitmoji-config'],
+    state: rootUseWorkspace ? 'present' : 'absent',
   });
 
   // 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 ? 'CI=$(is-ci) lerna publish ${CI:+"--yes"}' : semanticRelease.command(),
+      script: useWorkspace ? 'is-ci && lerna publish --yes || lerna publish' : semanticRelease.command(),
       state: 'present',
     });
   });

package/renovate/index.js

@@ -1,10 +1,11 @@
 const { json, packageJson } = require('mrm-core');
-const { hasGit } = require('../core/git');
+const { hasGit } = require('../core/git.js');
+const pkg = require('../core/pkg.js');
 
 /**
  *
  * @param {{
- *   renovatePresetApplication: string
+ *   renovatePresetApplication: string,
  *   renovatePresetLibrary: string
  * }} config
  */
@@ -19,7 +20,8 @@ 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');
@@ -54,6 +56,6 @@ function createRenovate({ renovatePresetApplication, renovatePresetLibrary }) {
 }
 
 module.exports = createRenovate({
-  renovatePresetApplication: '@w5s/renovate-config:application',
-  renovatePresetLibrary: '@w5s/renovate-config:library',
+  renovatePresetApplication: 'github>w5s/renovate-config:application',
+  renovatePresetLibrary: 'github>w5s/renovate-config:library',
 });

package/tsconfig.json

@@ -1,5 +1,6 @@
 {
-  "extends": "../../tsconfig.json",
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../../tsconfig.settings.json",
   "compilerOptions": {
     "allowJs": true,
     "checkJs": true,

package/core/workspace.js

@@ -1,6 +0,0 @@
-const { packageJson } = require('mrm-core');
-
-function useWorkspaces() {
-  return packageJson().get('mrmConfig.packageArchetype') === 'workspace';
-}
-exports.useWorkspaces = useWorkspaces;