@form8ion/javascript 15.6.0 → 15.6.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@form8ion/javascript",
   "description": "JavaScript language plugin for the @form8ion toolset",
   "license": "MIT",
-  "version": "15.6.0",
+  "version": "15.6.1",
   "type": "module",
   "engines": {
     "node": "^20.19.0 || >=22.14.0"
@@ -30,7 +30,7 @@
     "lint:publish": "publint --strict",
     "lint:sensitive": "ban",
     "test:unit": "run-s 'test:unit:base -- --coverage'",
-    "test:unit:base": "DEBUG=any vitest run",
+    "test:unit:base": "NODE_ENV=test DEBUG=any vitest run src/",
     "test:integration": "run-s 'test:integration:base -- --profile noWip'",
     "pretest:integration:base": "run-s build",
     "test:integration:base": "NODE_OPTIONS=--enable-source-maps DEBUG=any cucumber-js test/integration",
@@ -52,7 +52,8 @@
   "files": [
     "example.js",
     "lib/",
-    "templates/"
+    "templates/",
+    "src/"
   ],
   "publishConfig": {
     "access": "public",

package/src/code-style/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as lift} from './lifter.js';
+export {default as test} from './tester.js';

package/src/code-style/lifter.js

@@ -0,0 +1,6 @@
+import {applyEnhancers} from '@form8ion/core';
+import * as eslintPlugin from '@form8ion/eslint';
+
+export default function liftCodeStyle(options) {
+  return applyEnhancers({options, enhancers: [eslintPlugin]});
+}

package/src/code-style/lifter.test.js

@@ -0,0 +1,25 @@
+import {applyEnhancers} from '@form8ion/core';
+import * as eslintPlugin from '@form8ion/eslint';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import liftCodeStyle from './lifter.js';
+
+vi.mock('@form8ion/core');
+vi.mock('@form8ion/eslint');
+
+describe('code-style lifter', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should lift the code-style tools', async () => {
+    const options = any.simpleObject();
+    const results = any.simpleObject();
+    when(applyEnhancers).calledWith({options, enhancers: [eslintPlugin]}).thenResolve(results);
+
+    expect(await liftCodeStyle(options)).toEqual(results);
+  });
+});

package/src/code-style/remark/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

package/src/code-style/remark/lifter.js

@@ -0,0 +1,10 @@
+import {fileTypes} from '@form8ion/core';
+import {load, write} from '@form8ion/config-file';
+
+export default async function liftRemark({projectRoot}) {
+  const CONFIG_NAME = 'remark';
+
+  await write({format: fileTypes.JSON, path: projectRoot, name: CONFIG_NAME, config: await load({name: CONFIG_NAME})});
+
+  return {};
+}

package/src/code-style/remark/lifter.test.js

@@ -0,0 +1,28 @@
+import {fileTypes} from '@form8ion/core';
+import {load, write} from '@form8ion/config-file';
+
+import any from '@travi/any';
+import {describe, it, expect, afterEach, vi} from 'vitest';
+import {when} from 'vitest-when';
+
+import lift from './lifter.js';
+
+vi.mock('@form8ion/config-file');
+
+describe('remark lifter', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should copy existing config to json format', async () => {
+    const existingConfig = any.simpleObject();
+    when(load).calledWith({name: 'remark'}).thenResolve(existingConfig);
+
+    expect(await lift({projectRoot})).toEqual({});
+
+    expect(write)
+      .toHaveBeenCalledWith({format: fileTypes.JSON, path: projectRoot, name: 'remark', config: existingConfig});
+  });
+});

package/src/code-style/remark/scaffolder.js

@@ -0,0 +1,38 @@
+import deepmerge from 'deepmerge';
+import {fileTypes} from '@form8ion/core';
+import {projectTypes} from '@form8ion/javascript-core';
+import {write} from '@form8ion/config-file';
+
+export default async function scaffoldRemark({config, projectRoot, projectType, vcs}) {
+  await write({
+    format: fileTypes.JSON,
+    path: projectRoot,
+    name: 'remark',
+    config: {
+      settings: {
+        listItemIndent: 'one',
+        emphasis: '_',
+        strong: '_',
+        bullet: '*',
+        incrementListMarker: false
+      },
+      plugins: [
+        config,
+        ['remark-toc', {tight: true}],
+        ...projectTypes.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
+        ...!vcs ? [['validate-links', {repository: false}]] : []
+      ]
+    }
+  });
+
+  return deepmerge(
+    {
+      dependencies: {javascript: {development: [config, 'remark-cli', 'remark-toc']}},
+      scripts: {
+        'lint:md': 'remark . --frail',
+        'generate:md': 'remark . --output'
+      }
+    },
+    {...projectTypes.PACKAGE === projectType && {dependencies: {javascript: {development: ['remark-usage']}}}}
+  );
+}

package/src/code-style/remark/scaffolder.test.js

@@ -0,0 +1,102 @@
+import {fileTypes} from '@form8ion/core';
+import {projectTypes} from '@form8ion/javascript-core';
+import {write as writeConfigFile} from '@form8ion/config-file';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldRemark from './scaffolder.js';
+
+vi.mock('@form8ion/config-file');
+
+describe('remark scaffolder', () => {
+  const config = any.string();
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should write the config and define dependencies', async () => {
+    expect(await scaffoldRemark({config, projectRoot, vcs: any.simpleObject()}))
+      .toEqual({
+        dependencies: {javascript: {development: [config, 'remark-cli', 'remark-toc']}},
+        scripts: {
+          'lint:md': 'remark . --frail',
+          'generate:md': 'remark . --output'
+        }
+      });
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      format: fileTypes.JSON,
+      path: projectRoot,
+      name: 'remark',
+      config: {
+        settings: {
+          listItemIndent: 'one',
+          emphasis: '_',
+          strong: '_',
+          bullet: '*',
+          incrementListMarker: false
+        },
+        plugins: [
+          config,
+          ['remark-toc', {tight: true}]
+        ]
+      }
+    });
+  });
+
+  it('should configure the remark-usage plugin for package projects', async () => {
+    expect(await scaffoldRemark({config, projectRoot, projectType: projectTypes.PACKAGE, vcs: any.simpleObject()}))
+      .toEqual({
+        dependencies: {javascript: {development: [config, 'remark-cli', 'remark-toc', 'remark-usage']}},
+        scripts: {
+          'lint:md': 'remark . --frail',
+          'generate:md': 'remark . --output'
+        }
+      });
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      format: fileTypes.JSON,
+      path: projectRoot,
+      name: 'remark',
+      config: {
+        settings: {
+          listItemIndent: 'one',
+          emphasis: '_',
+          strong: '_',
+          bullet: '*',
+          incrementListMarker: false
+        },
+        plugins: [
+          config,
+          ['remark-toc', {tight: true}],
+          ['remark-usage', {heading: 'example'}]
+        ]
+      }
+    });
+  });
+
+  it('should configure validate-links when the project will not be versioned', async () => {
+    await scaffoldRemark({config, projectRoot, vcs: undefined});
+
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      format: fileTypes.JSON,
+      path: projectRoot,
+      name: 'remark',
+      config: {
+        settings: {
+          listItemIndent: 'one',
+          emphasis: '_',
+          strong: '_',
+          bullet: '*',
+          incrementListMarker: false
+        },
+        plugins: [
+          config,
+          ['remark-toc', {tight: true}],
+          ['validate-links', {repository: false}]
+        ]
+      }
+    });
+  });
+});

package/src/code-style/remark/tester.js

@@ -0,0 +1,11 @@
+import {fileExists} from '@form8ion/core';
+
+export default async function remarkConfigured({projectRoot}) {
+  const [jsonConfigExists, jsConfigExists, cjsConfigExists] = await Promise.all([
+    fileExists(`${projectRoot}/.remarkrc.json`),
+    fileExists(`${projectRoot}/.remarkrc.js`),
+    fileExists(`${projectRoot}/.remarkrc.cjs`)
+  ]);
+
+  return jsonConfigExists || jsConfigExists || cjsConfigExists;
+}

package/src/code-style/remark/tester.test.js

@@ -0,0 +1,46 @@
+import {fileExists} from '@form8ion/core';
+
+import {describe, vi, it, expect, afterEach, beforeEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import testForRemark from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('remark predicate', () => {
+  const projectRoot = any.string();
+
+  beforeEach(() => {
+    fileExists.mockResolvedValue(false);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return false when remark config is not present in the project', async () => {
+    expect(await testForRemark({projectRoot})).toBe(false);
+  });
+
+  it('should return true when json remark config is present in the project', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.json`).thenResolve(true);
+
+    expect(await testForRemark({projectRoot})).toBe(true);
+  });
+
+  it('should return true when js remark config is present in the project', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.json`).thenResolve(false);
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.js`).thenResolve(true);
+
+    expect(await testForRemark({projectRoot})).toBe(true);
+  });
+
+  it('should return true when cjs remark config is present in the project', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.json`).thenResolve(false);
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.js`).thenResolve(false);
+    when(fileExists).calledWith(`${projectRoot}/.remarkrc.cjs`).thenResolve(true);
+
+    expect(await testForRemark({projectRoot})).toBe(true);
+  });
+});

package/src/code-style/scaffolder.js

@@ -0,0 +1,26 @@
+import deepmerge from 'deepmerge';
+import {scaffold as scaffoldPrettier} from '@form8ion/prettier';
+import {scaffold as scaffoldEslint} from '@form8ion/eslint';
+
+import {scaffold as scaffoldRemark} from './remark/index.js';
+
+export default async function scaffoldCodeStyle({
+  projectRoot,
+  projectType,
+  configs,
+  vcs,
+  configureLinting
+}) {
+  return deepmerge.all(await Promise.all([
+    configs.eslint
+      && configureLinting
+      && scaffoldEslint({projectRoot, config: configs.eslint}),
+    scaffoldRemark({
+      projectRoot,
+      projectType,
+      vcs,
+      config: configs.remark || '@form8ion/remark-lint-preset'
+    }),
+    scaffoldPrettier({projectRoot, config: configs.prettier})
+  ].filter(Boolean)));
+}

package/src/code-style/scaffolder.test.js

@@ -0,0 +1,87 @@
+import {scaffold as scaffoldPrettier} from '@form8ion/prettier';
+import {scaffold as scaffoldEslint} from '@form8ion/eslint';
+import deepmerge from 'deepmerge';
+
+import {describe, vi, it, expect, afterEach, beforeEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldRemark} from './remark/index.js';
+import {scaffold} from './index.js';
+
+vi.mock('@form8ion/prettier');
+vi.mock('@form8ion/eslint');
+vi.mock('deepmerge');
+vi.mock('./remark');
+
+describe('code-style scaffolder', () => {
+  const pathWithinParent = any.string();
+  const projectRoot = any.string();
+  const projectType = any.word();
+  const configForEslint = any.simpleObject();
+  const configForPrettier = any.simpleObject();
+  const vcs = any.simpleObject();
+  const configForRemark = any.simpleObject();
+  const configureLinting = true;
+  const remarkResults = any.simpleObject();
+  const eslintResults = any.simpleObject();
+  const prettierResults = any.simpleObject();
+  const mergedResults = any.simpleObject();
+
+  beforeEach(() => {
+    when(scaffoldEslint).calledWith({projectRoot, config: configForEslint}).thenResolve(eslintResults);
+    when(scaffoldRemark)
+      .calledWith({projectRoot, projectType, config: configForRemark, vcs})
+      .thenResolve(remarkResults);
+    when(scaffoldPrettier).calledWith({projectRoot, config: configForPrettier}).thenResolve(prettierResults);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should configure linters when config definitions are provided', async () => {
+    when(deepmerge.all).calledWith([eslintResults, remarkResults, prettierResults]).thenReturn(mergedResults);
+
+    const result = await scaffold({
+      projectRoot,
+      projectType,
+      configs: {eslint: configForEslint, remark: configForRemark, prettier: configForPrettier},
+      vcs,
+      configureLinting,
+      pathWithinParent
+    });
+
+    expect(result).toEqual(mergedResults);
+  });
+
+  it('should not scaffold eslint when a config is not provided', async () => {
+    when(deepmerge.all).calledWith([remarkResults, prettierResults]).thenReturn(mergedResults);
+
+    const result = await scaffold({
+      projectRoot,
+      projectType,
+      configs: {remark: configForRemark, prettier: configForPrettier},
+      vcs,
+      configureLinting,
+      pathWithinParent
+    });
+
+    expect(result).toEqual(mergedResults);
+  });
+
+  it('should not scaffold eslint when `transpileLint` is false', async () => {
+    when(deepmerge.all).calledWith([remarkResults, prettierResults]).thenReturn(mergedResults);
+
+    const result = await scaffold({
+      projectRoot,
+      projectType,
+      configs: {eslint: configForEslint, remark: configForRemark, prettier: configForPrettier},
+      vcs,
+      configureLinting: false,
+      pathWithinParent
+    });
+
+    expect(result).toEqual(mergedResults);
+  });
+});

package/src/code-style/tester.js

@@ -0,0 +1,5 @@
+import {test as testForEslint} from '@form8ion/eslint';
+
+export default function codeStyleConfigured(options) {
+  return testForEslint(options);
+}

package/src/code-style/tester.test.js

@@ -0,0 +1,23 @@
+import {test as testForEslint} from '@form8ion/eslint';
+
+import {describe, vi, it, expect, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import testForCodeStyleTools from './tester.js';
+
+vi.mock('@form8ion/eslint');
+
+describe('code-style tester', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should determine if eslint is used by the project', async () => {
+    const options = any.simpleObject();
+    const eslintResult = any.boolean();
+    when(testForEslint).calledWith(options).thenResolve(eslintResult);
+
+    expect(await testForCodeStyleTools(options)).toEqual(eslintResult);
+  });
+});

package/src/corepack/index.js

@@ -0,0 +1 @@
+export {default as lift} from './lifter.js';

package/src/corepack/lifter.js

@@ -0,0 +1,5 @@
+import {execa} from 'execa';
+
+export default async function liftCorepack() {
+  await execa('corepack', ['use', 'npm@latest']);
+}

package/src/corepack/lifter.test.js

@@ -0,0 +1,22 @@
+import {execa} from 'execa';
+
+import {describe, it, vi, expect, afterEach} from 'vitest';
+
+import liftCorepack from './lifter.js';
+
+vi.mock('execa');
+
+describe('corepack lifter', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it(
+    'should set the `packageManager` package.json property to the latest version of the current package manager',
+    async () => {
+      await liftCorepack();
+
+      expect(execa).toHaveBeenCalledWith('corepack', ['use', 'npm@latest']);
+    }
+  );
+});

package/src/coverage/index.js

@@ -0,0 +1,3 @@
+export {default as scaffold} from './scaffolder.js';
+export {lift} from './lifter.js';
+export {default as test} from './tester.js';

package/src/coverage/lifter.js

@@ -0,0 +1,31 @@
+import deepmerge from 'deepmerge';
+import {lift as liftCodecov} from '@form8ion/codecov';
+import {scaffold as scaffoldC8} from '@form8ion/c8';
+
+import {test as nycIsConfigured, remove as removeNyc} from './nyc/index.js';
+
+export async function lift({projectRoot, packageManager, vcs}) {
+  const codecovResults = await liftCodecov({projectRoot, packageManager, vcs});
+
+  if (await nycIsConfigured({projectRoot})) {
+    const [c8Results, nycResults] = await Promise.all([
+      scaffoldC8({projectRoot}),
+      removeNyc({projectRoot})
+    ]);
+
+    return deepmerge.all([
+      c8Results,
+      nycResults,
+      codecovResults,
+      {
+        scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'},
+        nextSteps: [{
+          summary: 'Remove use of `@istanbuljs/nyc-config-babel` from your babel config, if present,'
+            + ' after the migration away from `nyc`'
+        }]
+      }
+    ]);
+  }
+
+  return codecovResults;
+}

package/src/coverage/lifter.test.js

@@ -0,0 +1,58 @@
+import deepmerge from 'deepmerge';
+import {lift as liftCodecov} from '@form8ion/codecov';
+import {scaffold as scaffoldC8} from '@form8ion/c8';
+
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import testForNyc from './nyc/tester.js';
+import removeNyc from './nyc/remover.js';
+import {lift} from './lifter.js';
+
+vi.mock('deepmerge');
+vi.mock('@form8ion/codecov');
+vi.mock('@form8ion/c8');
+vi.mock('./nyc/tester');
+vi.mock('./nyc/remover');
+
+describe('coverage lifter', () => {
+  const projectRoot = any.string();
+  const vcs = any.simpleObject();
+  const c8Results = any.simpleObject();
+  const codecovResults = any.simpleObject();
+  const packageManager = any.word();
+
+  it('should replace `nyc` with `c8` if nyc config exists', async () => {
+    const nycResults = any.simpleObject();
+    const mergedResults = any.simpleObject();
+    when(scaffoldC8).calledWith({projectRoot}).thenResolve(c8Results);
+    when(testForNyc).calledWith({projectRoot}).thenResolve(true);
+    when(removeNyc).calledWith({projectRoot}).thenResolve(nycResults);
+    when(liftCodecov).calledWith({projectRoot, packageManager, vcs}).thenResolve(codecovResults);
+    when(deepmerge.all).calledWith([
+      c8Results,
+      nycResults,
+      codecovResults,
+      {
+        scripts: {'test:unit': 'cross-env NODE_ENV=test c8 run-s test:unit:base'},
+        nextSteps: [{
+          summary: 'Remove use of `@istanbuljs/nyc-config-babel` from your babel config, if present,'
+            + ' after the migration away from `nyc`'
+        }]
+      }
+    ]).thenReturn(mergedResults);
+
+    expect(await lift({projectRoot, packageManager, vcs})).toEqual(mergedResults);
+  });
+
+  it('should not replace `nyc` with `c8` if nyc config does not exist', async () => {
+    when(scaffoldC8).calledWith({projectRoot}).thenResolve(c8Results);
+    when(testForNyc).calledWith({projectRoot}).thenResolve(false);
+    when(liftCodecov).calledWith({projectRoot, packageManager}).thenResolve(codecovResults);
+
+    expect(await lift({projectRoot, packageManager})).toEqual(codecovResults);
+
+    expect(scaffoldC8).not.toHaveBeenCalled();
+  });
+});

package/src/coverage/nyc/index.js

@@ -0,0 +1,2 @@
+export {default as test} from './tester.js';
+export {default as remove} from './remover.js';

package/src/coverage/nyc/remover.js

@@ -0,0 +1,16 @@
+import {promises as fs} from 'node:fs';
+
+export default async function removeNyc({projectRoot}) {
+  await Promise.all([
+    fs.unlink(`${projectRoot}/.nycrc`),
+    fs.rm(`${projectRoot}/.nyc_output`, {recursive: true, force: true})
+  ]);
+
+  return {
+    dependencies: {
+      javascript: {
+        remove: ['nyc', '@istanbuljs/nyc-config-babel', 'babel-plugin-istanbul']
+      }
+    }
+  };
+}

package/src/coverage/nyc/remover.test.js

@@ -0,0 +1,24 @@
+import {promises as fs} from 'node:fs';
+
+import {describe, it, expect, vi, afterEach} from 'vitest';
+import any from '@travi/any';
+
+import removeNyc from './remover.js';
+
+vi.mock('node:fs');
+
+describe('nyc remover', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should remove configuration and dependencies', async () => {
+    const projectRoot = any.string();
+
+    const {dependencies} = await removeNyc({projectRoot});
+
+    expect(fs.unlink).toHaveBeenCalledWith(`${projectRoot}/.nycrc`);
+    expect(fs.rm).toHaveBeenCalledWith(`${projectRoot}/.nyc_output`, {recursive: true, force: true});
+    expect(dependencies.javascript.remove).toEqual(['nyc', '@istanbuljs/nyc-config-babel', 'babel-plugin-istanbul']);
+  });
+});

package/src/coverage/nyc/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default function nyvInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.nycrc`);
+}

package/src/coverage/nyc/tester.test.js

@@ -0,0 +1,29 @@
+import {fileExists} from '@form8ion/core';
+
+import {describe, it, expect, vi, afterEach} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import nycIsConfigured from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('nyc predicate', () => {
+  const projectRoot = any.string();
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return `true` if the config file exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.nycrc`).thenResolve(true);
+
+    expect(await nycIsConfigured({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` if the config file does not exist', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.nycrc`).thenResolve(false);
+
+    expect(await nycIsConfigured({projectRoot})).toBe(false);
+  });
+});