@w5s/mrm-preset 1.0.0-alpha.1

package/lang/index.js

@@ -0,0 +1,143 @@
+const { join } = require('path');
+const { json, file, template, packageJson } = require('mrm-core');
+const npm = require('../core/npm');
+const { gitIgnore } = require('../core/git');
+const project = require('../core/project');
+const { eslintIgnore } = require('../core/eslint');
+const { useWorkspaces } = require('../core/workspace');
+const { typedoc } = require('../core/typedoc');
+const pkg = require('../core/pkg');
+
+/**
+ *
+ * @param {{
+ *  language: 'typescript',
+ *  tsConfig: string,
+ * }} config
+ */
+function createLang({ language: languageDefault = 'typescript', tsConfig: tsConfigDefault }) {
+  /**
+   *
+   * @param {{
+   *   language: 'typescript',
+   * }} config
+   */
+  function task({ language }) {
+    return task[language]();
+  }
+  task.typescript = () => {
+    const tsConfigPreset = tsConfigDefault;
+    const isApplication = packageJson().get('mrmConfig.packageArchetype') === 'application';
+    const hasWorkspaces = useWorkspaces();
+    const tsConfigSettingsName = 'tsconfig.settings.json';
+    const tsConfigSettings = json(tsConfigSettingsName);
+    const tsConfig = json('tsconfig.json');
+
+    // Should be run first
+    gitIgnore('Typescript', ['lib/', '*.tsbuildinfo', 'typings/']);
+    eslintIgnore(['lib/']);
+
+    if (hasWorkspaces) {
+      tsConfig
+        .unset('compilerOptions.rootDir')
+        .unset('compilerOptions.outDir')
+        .unset('include')
+        .merge({
+          extends: `./${tsConfigSettingsName}`,
+        })
+        .save();
+
+      file('src/index.ts').delete();
+      file('src/index.spec.ts').delete();
+    } else {
+      tsConfigSettings
+        .merge({
+          compilerOptions: {},
+          extends: tsConfigPreset,
+        })
+        .save();
+      tsConfig
+        .merge({
+          compilerOptions: {
+            outDir: './lib',
+            rootDir: './src',
+          },
+          extends: `./${tsConfigSettingsName}`,
+          include: ['./src'],
+        })
+        .save();
+
+      // Create default index
+      const templateDir = join(__dirname, 'templates');
+      if (!file('src/index.ts').exists()) {
+        template('src/index.ts', join(templateDir, 'index.ts')).apply().save();
+      }
+      if (!file('src/index.spec.ts').exists()) {
+        template('src/index.spec.ts', join(templateDir, 'index.spec.ts')).apply().save();
+      }
+    }
+    // Application setup
+    pkg.withPackageJson((packageFile) => {
+      if (isApplication) {
+        pkg.script(packageFile, {
+          name: project.develop,
+          script:
+            "NODE_ENV=development ts-node-dev --require='tsconfig-paths/register' -r dotenv/config -- ./src/index.ts dotenv_config_path=.env",
+          state: 'present',
+        });
+      }
+    });
+    npm.dependency({
+      dev: true,
+      name: ['ts-node-dev', 'tsconfig-paths'],
+      state: isApplication ? 'present' : 'absent',
+    });
+
+    // Dependencies
+    npm.dependency({
+      dev: true,
+      name: ['typescript', '@types/node', tsConfigPreset],
+      state: 'present',
+    });
+
+    typedoc({
+      state: 'present',
+      update: (config) => ({
+        // Default values
+        tsconfig: 'tsconfig.json',
+        excludePrivate: true,
+        excludeExternals: true,
+        readme: 'README.md',
+        theme: 'default',
+        // Inherits current
+        ...config,
+        // Force values
+        out: 'public',
+        exclude: [
+          '**/build/**/*',
+          '**/example/**/*',
+          '**/lib/**/*',
+          '**/node_modules/**',
+          '**/__tests__/*.(ts|tsx)',
+          '**/*.(spec|test).(ts|tsx)',
+        ],
+      }),
+    });
+  };
+
+  task.description = 'Setup Programming Language';
+  task.parameters = {
+    language: {
+      default: languageDefault,
+      message: 'Enter Programming language name',
+      type: 'input',
+    },
+  };
+
+  return task;
+}
+
+module.exports = createLang({
+  language: 'typescript',
+  tsConfig: '@w5s/ts-config',
+});

package/lang/templates/index.spec.ts

@@ -0,0 +1,7 @@
+import { main } from '.';
+
+describe('index', () => {
+  test('main', () => {
+    expect(typeof main).toBe('function');
+  });
+});

package/lang/templates/index.ts

@@ -0,0 +1,6 @@
+export async function main(): Promise<void> {
+  // TODO
+}
+
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
+main();

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@w5s/mrm-preset",
+  "version": "1.0.0-alpha.1",
+  "description": "Mrm configuration presets",
+  "keywords": [
+    "mrm",
+    "config",
+    "bootstrap"
+  ],
+  "homepage": "https://github.com/w5s/project-config/blob/master/packages/mrm-preset#readme",
+  "bugs": {
+    "url": "https://github.com/w5s/project-config.git/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/w5s/project-config.git",
+    "directory": "packages/mrm-preset"
+  },
+  "license": "MIT",
+  "author": "Julien Polo <julien.polo@gmail.com>",
+  "main": "config.json",
+  "scripts": {
+    "build": "npm-run-all -p 'build:*'",
+    "build:empty": ":",
+    "build:tsc": "tsc --noEmit --skipLibCheck",
+    "docs": "md-magic --path '**/*.md' --ignore='node_modules'",
+    "format": "eslint . --fix",
+    "lint": "eslint .",
+    "test": "mkdir _tester; cd _tester; ../node_modules/.bin/mrm bootstrap --dir ..; ../node_modules/.bin/mrm configure --dir .."
+  },
+  "dependencies": {
+    "debug": "^4.3.3",
+    "mrm-core": "^6.0.0",
+    "semver-intersect": "^1.4.0",
+    "sync-directory": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "mrm": "3.0.10"
+  },
+  "engines": {
+    "node": ">=12.x",
+    "yarn": ">=1.x"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/postconfigure/index.js

@@ -0,0 +1,17 @@
+const { spawnSync } = require('child_process');
+const { packageJson } = require('mrm-core');
+const project = require('../core/project');
+const pkg = require('../core/pkg');
+
+function task() {
+  const packageFile = packageJson();
+  const packageManager = pkg.manager(packageFile);
+  const formatResult = spawnSync(packageManager, ['run', project.format]);
+  if (formatResult.status !== 0) {
+    // eslint-disable-next-line no-console
+    console.error('Error: to format code\n', formatResult.output.join(''));
+  }
+}
+task.description = 'Sort scripts';
+
+module.exports = task;

package/project/index.js

@@ -0,0 +1,232 @@
+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 mrmPackageJson = require('../package.json');
+
+function task() {
+  const packageFile = packageJson();
+  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) => {
+    return `lerna run ${script}`;
+  };
+  /**
+   *
+   * @param {string} script
+   */
+  const npmRunAll = (script) => {
+    return `npm-run-all -p "${script}:*"`;
+  };
+
+  // Detect git repository
+  pkg.value(packageFile, {
+    path: 'repository',
+    state: 'present',
+    update: () => {
+      const gitRepository = git.remoteSync();
+      if (gitRepository) {
+        return {
+          type: 'git',
+          url: gitRepository,
+        };
+      }
+
+      return undefined;
+    },
+  });
+
+  // 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',
+  });
+
+  // develop & auto build & load
+  pkg.script(packageFile, {
+    name: project.develop,
+    script: pkg.emptyScript,
+    state: 'default',
+  });
+
+  // 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(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',
+  });
+
+  // code analysis
+  pkg.script(packageFile, {
+    name: project.codeAnalysis,
+    script: pkg.emptyScript,
+    state: 'default',
+  });
+
+  // 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',
+  });
+
+  // rescue
+  pkg.script(packageFile, {
+    name: project.rescue,
+    script: `${gitSupported ? 'git clean -fdx' : ''};${packageManager} install`,
+    state: 'present',
+  });
+
+  // release
+  pkg.script(packageFile, {
+    name: project.release,
+    script: pkg.emptyScript,
+    state: 'default',
+  });
+
+  // workspace
+  const lernaConfig = json('lerna.json', {
+    version: packageFile.get('version'),
+  });
+  if (useWorkspace) {
+    const packages = ['packages/*'];
+    const versionIndependent = lernaConfig.get('version') === 'independent';
+    packageFile.merge({ workspaces: { packages } });
+    lernaConfig.merge({
+      command: {
+        publish: {
+          conventionalCommits: true,
+          npmClient: 'npm',
+        },
+        version: {
+          message: `chore(release): publish${versionIndependent ? '' : ' %s'}`,
+        },
+      },
+      npmClient: packageManager,
+      useWorkspaces: useWorkspace,
+    });
+    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',
+      },
+      mrmPackageJson.engines
+    )
+  );
+  packageFile.save();
+
+  // Dependencies
+  npm.dependency({
+    dev: true,
+    name: ['npm-run-all'],
+    state: 'present',
+  });
+  npm.dependency({
+    dev: true,
+    name: ['lerna'],
+    state: useWorkspace ? 'present' : 'absent',
+  });
+
+  // VSCode
+  vscodeTask({
+    group: {
+      isDefault: true,
+      kind: 'build',
+    },
+    script: 'build',
+    type: 'npm',
+  });
+  vscodeTask({
+    group: {
+      isDefault: true,
+      kind: 'test',
+    },
+    script: 'test',
+    type: 'npm',
+  });
+}
+
+task.description = 'Init project';
+task.parameters = {};
+
+module.exports = task;

package/release/index.js

@@ -0,0 +1,29 @@
+const { packageJson } = require('mrm-core');
+const pkg = require('../core/pkg');
+const project = require('../core/project');
+const { semanticRelease } = require('../core/semanticRelease');
+
+function task() {
+  const useWorkspace = packageJson().get('mrmConfig.packageArchetype') === 'workspace';
+
+  // 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(),
+      state: 'present',
+    });
+  });
+
+  // Dependencies
+  semanticRelease({
+    state: useWorkspace ? 'absent' : 'present',
+    preset: '@semantic-release/gitlab-config', // TODO: cherry pick plugins depending on context (github, gitlab, etc)
+  });
+}
+
+task.description = 'Setup release task';
+task.parameters = {};
+
+module.exports = task;

package/renovate/index.js

@@ -0,0 +1,61 @@
+const { json, packageJson } = require('mrm-core');
+const { hasGit } = require('../core/git');
+
+/**
+ *
+ * @param {{
+ *   renovatePresetApplication: string
+ *   renovatePresetLibrary: string
+ * }} config
+ */
+function createRenovate({ renovatePresetApplication, renovatePresetLibrary }) {
+  /**
+   *
+   * @param {{
+   *   renovatePreset: string
+   * }} parameters
+   */
+  function task({ renovatePreset }) {
+    const gitSupported = hasGit();
+
+    if (gitSupported) {
+      const packageArchetype = packageJson().get('mrmConfig.packageArchetype', 'library');
+      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',
+        [renovatePresetResolved].concat(
+          renovateFile.get('extends', []).filter(
+            /**
+             * @param {string} extension
+             */
+            (extension) => {
+              return extension !== renovatePresetApplication && extension !== renovatePresetLibrary;
+            }
+          )
+        )
+      );
+      renovateFile.save();
+    }
+  }
+
+  task.description = 'Setup Renovate';
+  task.parameters = {
+    renovatePreset: {
+      message: 'Enter Renovate preset name',
+      type: 'input',
+    },
+  };
+
+  return task;
+}
+
+module.exports = createRenovate({
+  renovatePresetApplication: '@w5s/renovate-config:application',
+  renovatePresetLibrary: '@w5s/renovate-config:library',
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "resolveJsonModule": true
+  },
+  "exclude": [
+    "**/templates/**",
+    "_tester"
+  ]
+}