@forsakringskassan/commitlint-config 2.0.5 → 3.0.0

package/dist/install.js

@@ -12,7 +12,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -474,19 +480,353 @@ var require_is_ci = __commonJS({
 });
 
 // src/install.ts
-var import_is_ci = __toESM(require_is_ci(), 1);
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path4 from "node:path";
 import { spawnSync } from "node:child_process";
+import * as fsp from "fs/promises";
+
+// node_modules/nano-spawn/source/context.js
+import process2 from "node:process";
+import { stripVTControlCharacters } from "node:util";
+var getContext = (raw) => ({
+  start: process2.hrtime.bigint(),
+  command: raw.map((part) => getCommandPart(stripVTControlCharacters(part))).join(" "),
+  state: { stdout: "", stderr: "", output: "" }
+});
+var getCommandPart = (part) => /[^\w./-]/.test(part) ? `'${part.replaceAll("'", "'\\''")}'` : part;
+
+// node_modules/nano-spawn/source/options.js
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import process3 from "node:process";
+var getOptions = ({
+  stdin,
+  stdout,
+  stderr,
+  stdio = [stdin, stdout, stderr],
+  env: envOption,
+  preferLocal,
+  cwd: cwdOption = ".",
+  ...options
+}) => {
+  const cwd = cwdOption instanceof URL ? fileURLToPath(cwdOption) : path.resolve(cwdOption);
+  const env = envOption ? { ...process3.env, ...envOption } : void 0;
+  const input = stdio[0]?.string;
+  return {
+    ...options,
+    input,
+    stdio: input === void 0 ? stdio : ["pipe", ...stdio.slice(1)],
+    env: preferLocal ? addLocalPath(env ?? process3.env, cwd) : env,
+    cwd
+  };
+};
+var addLocalPath = ({ Path = "", PATH = Path, ...env }, cwd) => {
+  const pathParts = PATH.split(path.delimiter);
+  const localPaths = getLocalPaths([], path.resolve(cwd)).map((localPath) => path.join(localPath, "node_modules/.bin")).filter((localPath) => !pathParts.includes(localPath));
+  return { ...env, PATH: [...localPaths, PATH].filter(Boolean).join(path.delimiter) };
+};
+var getLocalPaths = (localPaths, localPath) => localPaths.at(-1) === localPath ? localPaths : getLocalPaths([...localPaths, localPath], path.resolve(localPath, ".."));
+
+// node_modules/nano-spawn/source/spawn.js
+import { spawn } from "node:child_process";
+import { once as once2 } from "node:events";
+import process6 from "node:process";
+
+// node_modules/nano-spawn/source/windows.js
+import fs from "node:fs/promises";
+import path2 from "node:path";
+import process4 from "node:process";
+var applyForceShell = async (file, commandArguments, options) => await shouldForceShell(file, options) ? [escapeFile(file), commandArguments.map((argument) => escapeArgument(argument)), { ...options, shell: true }] : [file, commandArguments, options];
+var shouldForceShell = async (file, { shell, cwd, env = process4.env }) => process4.platform === "win32" && !shell && !await isExe(file, cwd, env);
+var isExe = (file, cwd, { Path = "", PATH = Path }) => (
+  // If the *.exe or *.com file extension was not omitted.
+  // Windows common file systems are case-insensitive.
+  exeExtensions.some((extension) => file.toLowerCase().endsWith(extension)) || mIsExe(file, cwd, PATH)
+);
+var EXE_MEMO = {};
+var memoize = (function_) => (...arguments_) => (
+  // Use returned assignment to keep code small
+  EXE_MEMO[arguments_.join("\0")] ??= function_(...arguments_)
+);
+var access = memoize(fs.access);
+var mIsExe = memoize(async (file, cwd, PATH) => {
+  const parts = PATH.split(path2.delimiter).filter(Boolean).map((part) => part.replace(/^"(.*)"$/, "$1"));
+  try {
+    await Promise.any(
+      [cwd, ...parts].flatMap(
+        (part) => exeExtensions.map((extension) => access(`${path2.resolve(part, file)}${extension}`))
+      )
+    );
+  } catch {
+    return false;
+  }
+  return true;
+});
+var exeExtensions = [".exe", ".com"];
+var escapeArgument = (argument) => escapeFile(escapeFile(`"${argument.replaceAll(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`));
+var escapeFile = (file) => file.replaceAll(/([()\][%!^"`<>&|;, *?])/g, "^$1");
+
+// node_modules/nano-spawn/source/result.js
+import { once, on } from "node:events";
+import process5 from "node:process";
+var getResult = async (nodeChildProcess, { input }, context) => {
+  const instance = await nodeChildProcess;
+  if (input !== void 0) {
+    instance.stdin.end(input);
+  }
+  const onClose = once(instance, "close");
+  try {
+    await Promise.race([
+      onClose,
+      ...instance.stdio.filter(Boolean).map((stream) => onStreamError(stream))
+    ]);
+    checkFailure(context, getErrorOutput(instance));
+    return getOutputs(context);
+  } catch (error) {
+    await Promise.allSettled([onClose]);
+    throw getResultError(error, instance, context);
+  }
+};
+var onStreamError = async (stream) => {
+  for await (const [error] of on(stream, "error")) {
+    if (!["ERR_STREAM_PREMATURE_CLOSE", "EPIPE"].includes(error?.code)) {
+      throw error;
+    }
+  }
+};
+var checkFailure = ({ command }, { exitCode, signalName }) => {
+  if (signalName !== void 0) {
+    throw new SubprocessError(`Command was terminated with ${signalName}: ${command}`);
+  }
+  if (exitCode !== void 0) {
+    throw new SubprocessError(`Command failed with exit code ${exitCode}: ${command}`);
+  }
+};
+var getResultError = (error, instance, context) => Object.assign(
+  getErrorInstance(error, context),
+  getErrorOutput(instance),
+  getOutputs(context)
+);
+var getErrorInstance = (error, { command }) => error instanceof SubprocessError ? error : new SubprocessError(`Command failed: ${command}`, { cause: error });
+var SubprocessError = class extends Error {
+  name = "SubprocessError";
+};
+var getErrorOutput = ({ exitCode, signalCode }) => ({
+  // `exitCode` can be a negative number (`errno`) when the `error` event is emitted on the `instance`
+  ...exitCode < 1 ? {} : { exitCode },
+  ...signalCode === null ? {} : { signalName: signalCode }
+});
+var getOutputs = ({ state: { stdout, stderr, output }, command, start }) => ({
+  stdout: getOutput(stdout),
+  stderr: getOutput(stderr),
+  output: getOutput(output),
+  command,
+  durationMs: Number(process5.hrtime.bigint() - start) / 1e6
+});
+var getOutput = (output) => output.at(-1) === "\n" ? output.slice(0, output.at(-2) === "\r" ? -2 : -1) : output;
+
+// node_modules/nano-spawn/source/spawn.js
+var spawnSubprocess = async (file, commandArguments, options, context) => {
+  try {
+    if (["node", "node.exe"].includes(file.toLowerCase())) {
+      file = process6.execPath;
+      commandArguments = [...process6.execArgv.filter((flag) => !flag.startsWith("--inspect")), ...commandArguments];
+    }
+    [file, commandArguments, options] = await applyForceShell(file, commandArguments, options);
+    [file, commandArguments, options] = concatenateShell(file, commandArguments, options);
+    const instance = spawn(file, commandArguments, options);
+    bufferOutput(instance.stdout, context, "stdout");
+    bufferOutput(instance.stderr, context, "stderr");
+    instance.once("error", () => {
+    });
+    await once2(instance, "spawn");
+    return instance;
+  } catch (error) {
+    throw getResultError(error, {}, context);
+  }
+};
+var concatenateShell = (file, commandArguments, options) => options.shell && commandArguments.length > 0 ? [[file, ...commandArguments].join(" "), [], options] : [file, commandArguments, options];
+var bufferOutput = (stream, { state }, streamName) => {
+  if (stream) {
+    stream.setEncoding("utf8");
+    if (!state.isIterating) {
+      state.isIterating = false;
+      stream.on("data", (chunk) => {
+        state[streamName] += chunk;
+        state.output += chunk;
+      });
+    }
+  }
+};
+
+// node_modules/nano-spawn/source/pipe.js
+import { pipeline } from "node:stream/promises";
+var handlePipe = async (subprocesses) => {
+  const [[from, to]] = await Promise.all([Promise.allSettled(subprocesses), pipeStreams(subprocesses)]);
+  if (to.reason) {
+    to.reason.pipedFrom = from.reason ?? from.value;
+    throw to.reason;
+  }
+  if (from.reason) {
+    throw from.reason;
+  }
+  return { ...to.value, pipedFrom: from.value };
+};
+var pipeStreams = async (subprocesses) => {
+  try {
+    const [{ stdout }, { stdin }] = await Promise.all(subprocesses.map(({ nodeChildProcess }) => nodeChildProcess));
+    if (stdin === null) {
+      throw new Error('The "stdin" option must be set on the first "spawn()" call in the pipeline.');
+    }
+    if (stdout === null) {
+      throw new Error('The "stdout" option must be set on the last "spawn()" call in the pipeline.');
+    }
+    pipeline(stdout, stdin).catch(() => {
+    });
+  } catch (error) {
+    await Promise.allSettled(subprocesses.map(({ nodeChildProcess }) => closeStdin(nodeChildProcess)));
+    throw error;
+  }
+};
+var closeStdin = async (nodeChildProcess) => {
+  const { stdin } = await nodeChildProcess;
+  stdin.end();
+};
+
+// node_modules/nano-spawn/source/iterable.js
+import * as readline from "node:readline/promises";
+var lineIterator = async function* (subprocess, { state }, streamName) {
+  if (state.isIterating === false) {
+    throw new Error(`The subprocess must be iterated right away, for example:
+	for await (const line of spawn(...)) { ... }`);
+  }
+  state.isIterating = true;
+  try {
+    const { [streamName]: stream } = await subprocess.nodeChildProcess;
+    if (!stream) {
+      return;
+    }
+    yield* readline.createInterface({ input: stream });
+  } finally {
+    await subprocess;
+  }
+};
+var combineAsyncIterators = async function* (...iterators) {
+  try {
+    let promises = [];
+    while (iterators.length > 0) {
+      promises = iterators.map((iterator2, index2) => promises[index2] ?? getNext(iterator2));
+      const [{ value, done }, index] = await Promise.race(promises.map((promise, index2) => Promise.all([promise, index2])));
+      const [iterator] = iterators.splice(index, 1);
+      promises.splice(index, 1);
+      if (!done) {
+        iterators.push(iterator);
+        yield value;
+      }
+    }
+  } finally {
+    await Promise.all(iterators.map((iterator) => iterator.return()));
+  }
+};
+var getNext = async (iterator) => {
+  try {
+    return await iterator.next();
+  } catch (error) {
+    await iterator.throw(error);
+  }
+};
+
+// node_modules/nano-spawn/source/index.js
+function spawn2(file, second, third, previous) {
+  const [commandArguments = [], options = {}] = Array.isArray(second) ? [second, third] : [[], second];
+  const context = getContext([file, ...commandArguments]);
+  const spawnOptions = getOptions(options);
+  const nodeChildProcess = spawnSubprocess(file, commandArguments, spawnOptions, context);
+  let subprocess = getResult(nodeChildProcess, spawnOptions, context);
+  Object.assign(subprocess, { nodeChildProcess });
+  subprocess = previous ? handlePipe([previous, subprocess]) : subprocess;
+  const stdout = lineIterator(subprocess, context, "stdout");
+  const stderr = lineIterator(subprocess, context, "stderr");
+  return Object.assign(subprocess, {
+    nodeChildProcess,
+    stdout,
+    stderr,
+    [Symbol.asyncIterator]: () => combineAsyncIterators(stdout, stderr),
+    pipe: (file2, second2, third2) => spawn2(file2, second2, third2, subprocess)
+  });
+}
+
+// src/install.ts
+var import_is_ci = __toESM(require_is_ci(), 1);
+
+// src/verifyPackage.ts
+import path3 from "node:path";
+var nonAllowedPackages = ["husky", "simple-git-hooks", "lint-staged"];
+function invalidInstalledPackages(packageJson) {
+  const dependencies = [
+    ...Object.keys(packageJson.dependencies),
+    ...Object.keys(packageJson.devDependencies)
+  ];
+  for (const item of nonAllowedPackages) {
+    if (dependencies.includes(item)) {
+      console.error(
+        `
+                @forsakringskassan/commitlint-config
+                You need to remove package ${item} before installing this package.
+
+                Unallowed dependencies:
+                ${nonAllowedPackages.join(" ")}
+
+                Command to uninstall:
+                npm uninstall ${nonAllowedPackages.join(" ")}
+                `
+      );
+      return true;
+    }
+  }
+  return false;
+}
+function existingSimpleGitConfig(packageJson) {
+  if ("simple-git-hooks" in packageJson) {
+    console.error(
+      `
+                @forsakringskassan/commitlint-config
+                You need to remove config in package.json for simple-git-hooks.
+
+                npm pkg delete "simple-git-hooks"
+            `
+    );
+    return true;
+  }
+  return false;
+}
+async function existingHuskyConfig(cwd, fileSystem) {
+  try {
+    await fileSystem.stat(path3.join(cwd, ".husky"));
+    console.error(
+      `
+                @forsakringskassan/commitlint-config
+                You need to remove husky folder before installing this package.
+
+                git rm -rf .husky
+            `
+    );
+    return true;
+  } catch {
+  }
+  return false;
+}
+
+// src/install.ts
 function findGit(cwd) {
   let current = cwd;
   while (true) {
-    const search = path.join(current, ".git");
-    if (fs.existsSync(search)) {
-      return path.resolve(current);
+    const search = path4.join(current, ".git");
+    if (fs2.existsSync(search)) {
+      return path4.resolve(current);
     }
     const child = current;
-    current = path.dirname(current);
+    current = path4.dirname(current);
     if (current === child) {
       break;
     }
@@ -499,12 +839,31 @@ function configureCommitTemplate() {
     console.warn("Failed to locate git directory, skipping gitmessage");
     return;
   }
-  const relPath = path.relative(gitDir, path.join(__dirname, ".."));
-  const gitmessage = path.join(relPath, "gitmessage");
+  const relPath = path4.relative(gitDir, path4.join(__dirname, ".."));
+  const gitmessage = path4.join(relPath, "gitmessage");
   const args = ["config", "commit.template", gitmessage];
   console.info(`git ${args.join(" ")}`);
   spawnSync("git", args);
 }
-if (!import_is_ci.default) {
+if (!import_is_ci.default && process.env.FK_COMMITLINT_SKIP !== "1") {
   configureCommitTemplate();
+  const originCwd = process.env["INIT_CWD"] || "";
+  const packageJson = JSON.parse(
+    await fsp.readFile(path4.join(originCwd, "package.json"), {
+      encoding: "utf-8"
+    })
+  );
+  if (invalidInstalledPackages(packageJson) || existingSimpleGitConfig(packageJson) || await existingHuskyConfig(originCwd, fsp)) {
+    process.exit(1);
+  }
+  const result = await spawn2(
+    "npm",
+    [
+      "exec",
+      "simple-git-hooks",
+      __require.resolve("@forsakringskassan/commitlint-config/hooks.js")
+    ],
+    { cwd: process.env["INIT_CWD"] }
+  );
+  console.log(result.output);
 }

package/hooks.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from "node:url";
+
+const lintConfigPath = fileURLToPath.meta.resolve("./lint-staged.js");
+
+export default {
+    "pre-commit": `npm exec lint-staged -- --config "${lintConfigPath}" "$@"`,
+    "commit-msg": 'npm exec commitlint -- --edit "$1"',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forsakringskassan/commitlint-config",
-  "version": "2.0.5",
+  "version": "3.0.0",
   "description": "FK commitlint shareable config",
   "keywords": [
     "commitlint"
@@ -18,7 +18,8 @@
     ".": "./dist/config/default.js",
     "./default": "./dist/config/default.js",
     "./no-jira": "./dist/config/no-jira.js",
-    "./lint-staged": "./lint-staged.js"
+    "./lint-staged": "./lint-staged.js",
+    "./hooks.js": "./hooks.js"
   },
   "main": "dist/config/default.js",
   "bin": {
@@ -30,7 +31,8 @@
     "bin",
     "dist",
     "gitmessage",
-    "lint-staged.js"
+    "lint-staged.js",
+    "hooks.js"
   ],
   "scripts": {
     "prebuild": "rimraf dist",
@@ -56,6 +58,7 @@
     "ts-node": "^10"
   },
   "engines": {
-    "node": ">= 20.18"
+    "node": ">= 22.12.0",
+    "npm": ">= 10.0.0"
   }
 }