@forsakringskassan/commitlint-config 1.2.0

package/dist/parser.js

@@ -0,0 +1,491 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/conventional-changelog-conventionalcommits/parser-opts.js
+var require_parser_opts = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/parser-opts.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(config) {
+      config = defaultConfig(config);
+      return {
+        headerPattern: /^(\w*)(?:\((.*)\))?!?: (.*)$/,
+        breakingHeaderPattern: /^(\w*)(?:\((.*)\))?!: (.*)$/,
+        headerCorrespondence: [
+          "type",
+          "scope",
+          "subject"
+        ],
+        noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
+        revertPattern: /^(?:Revert|revert:)\s"?([\s\S]+?)"?\s*This reverts commit (\w*)\./i,
+        revertCorrespondence: ["header", "hash"],
+        issuePrefixes: config.issuePrefixes
+      };
+    };
+    function defaultConfig(config) {
+      config = config || {};
+      config.issuePrefixes = config.issuePrefixes || ["#"];
+      return config;
+    }
+  }
+});
+
+// node_modules/conventional-changelog-conventionalcommits/add-bang-notes.js
+var require_add_bang_notes = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/add-bang-notes.js"(exports2, module2) {
+    var { breakingHeaderPattern } = require_parser_opts()();
+    module2.exports = (commit) => {
+      const match = commit.header.match(breakingHeaderPattern);
+      if (match && commit.notes.length === 0) {
+        const noteText = match[3];
+        commit.notes.push({
+          text: noteText
+        });
+      }
+    };
+  }
+});
+
+// node_modules/array-ify/index.js
+var require_array_ify = __commonJS({
+  "node_modules/array-ify/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(val) {
+      return Array.isArray(val) ? val : [val];
+    };
+  }
+});
+
+// node_modules/is-obj/index.js
+var require_is_obj = __commonJS({
+  "node_modules/is-obj/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (value) => {
+      const type = typeof value;
+      return value !== null && (type === "object" || type === "function");
+    };
+  }
+});
+
+// node_modules/dot-prop/index.js
+var require_dot_prop = __commonJS({
+  "node_modules/dot-prop/index.js"(exports2, module2) {
+    "use strict";
+    var isObj = require_is_obj();
+    var disallowedKeys = [
+      "__proto__",
+      "prototype",
+      "constructor"
+    ];
+    var isValidPath = (pathSegments) => !pathSegments.some((segment) => disallowedKeys.includes(segment));
+    function getPathSegments(path) {
+      const pathArray = path.split(".");
+      const parts = [];
+      for (let i = 0; i < pathArray.length; i++) {
+        let p = pathArray[i];
+        while (p[p.length - 1] === "\\" && pathArray[i + 1] !== void 0) {
+          p = p.slice(0, -1) + ".";
+          p += pathArray[++i];
+        }
+        parts.push(p);
+      }
+      if (!isValidPath(parts)) {
+        return [];
+      }
+      return parts;
+    }
+    module2.exports = {
+      get(object, path, value) {
+        if (!isObj(object) || typeof path !== "string") {
+          return value === void 0 ? object : value;
+        }
+        const pathArray = getPathSegments(path);
+        if (pathArray.length === 0) {
+          return;
+        }
+        for (let i = 0; i < pathArray.length; i++) {
+          if (!Object.prototype.propertyIsEnumerable.call(object, pathArray[i])) {
+            return value;
+          }
+          object = object[pathArray[i]];
+          if (object === void 0 || object === null) {
+            if (i !== pathArray.length - 1) {
+              return value;
+            }
+            break;
+          }
+        }
+        return object;
+      },
+      set(object, path, value) {
+        if (!isObj(object) || typeof path !== "string") {
+          return object;
+        }
+        const root = object;
+        const pathArray = getPathSegments(path);
+        for (let i = 0; i < pathArray.length; i++) {
+          const p = pathArray[i];
+          if (!isObj(object[p])) {
+            object[p] = {};
+          }
+          if (i === pathArray.length - 1) {
+            object[p] = value;
+          }
+          object = object[p];
+        }
+        return root;
+      },
+      delete(object, path) {
+        if (!isObj(object) || typeof path !== "string") {
+          return false;
+        }
+        const pathArray = getPathSegments(path);
+        for (let i = 0; i < pathArray.length; i++) {
+          const p = pathArray[i];
+          if (i === pathArray.length - 1) {
+            delete object[p];
+            return true;
+          }
+          object = object[p];
+          if (!isObj(object)) {
+            return false;
+          }
+        }
+      },
+      has(object, path) {
+        if (!isObj(object) || typeof path !== "string") {
+          return false;
+        }
+        const pathArray = getPathSegments(path);
+        if (pathArray.length === 0) {
+          return false;
+        }
+        for (let i = 0; i < pathArray.length; i++) {
+          if (isObj(object)) {
+            if (!(pathArray[i] in object)) {
+              return false;
+            }
+            object = object[pathArray[i]];
+          } else {
+            return false;
+          }
+        }
+        return true;
+      }
+    };
+  }
+});
+
+// node_modules/compare-func/index.js
+var require_compare_func = __commonJS({
+  "node_modules/compare-func/index.js"(exports2, module2) {
+    "use strict";
+    var arrayify = require_array_ify();
+    var dotPropGet = require_dot_prop().get;
+    function compareFunc(prop) {
+      return function(a, b) {
+        var ret = 0;
+        arrayify(prop).some(function(el) {
+          var x;
+          var y;
+          if (typeof el === "function") {
+            x = el(a);
+            y = el(b);
+          } else if (typeof el === "string") {
+            x = dotPropGet(a, el);
+            y = dotPropGet(b, el);
+          } else {
+            x = a;
+            y = b;
+          }
+          if (x === y) {
+            ret = 0;
+            return;
+          }
+          if (typeof x === "string" && typeof y === "string") {
+            ret = x.localeCompare(y);
+            return ret !== 0;
+          }
+          ret = x < y ? -1 : 1;
+          return true;
+        });
+        return ret;
+      };
+    }
+    module2.exports = compareFunc;
+  }
+});
+
+// node_modules/conventional-changelog-conventionalcommits/writer-opts.js
+var require_writer_opts = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/writer-opts.js"(exports2, module2) {
+    "use strict";
+    var addBangNotes = require_add_bang_notes();
+    var compareFunc = require_compare_func();
+    var { readFile } = require("fs").promises;
+    var { resolve } = require("path");
+    var releaseAsRe = /release-as:\s*\w*@?([0-9]+\.[0-9]+\.[0-9a-z]+(-[0-9a-z.]+)?)\s*/i;
+    var owner = "{{#if this.owner}}{{~this.owner}}{{else}}{{~@root.owner}}{{/if}}";
+    var host = "{{~@root.host}}";
+    var repository = "{{#if this.repository}}{{~this.repository}}{{else}}{{~@root.repository}}{{/if}}";
+    module2.exports = async (config) => {
+      config = defaultConfig(config);
+      const commitUrlFormat = expandTemplate(config.commitUrlFormat, {
+        host,
+        owner,
+        repository
+      });
+      const compareUrlFormat = expandTemplate(config.compareUrlFormat, {
+        host,
+        owner,
+        repository
+      });
+      const issueUrlFormat = expandTemplate(config.issueUrlFormat, {
+        host,
+        owner,
+        repository,
+        id: "{{this.issue}}",
+        prefix: "{{this.prefix}}"
+      });
+      const [
+        template,
+        header,
+        commit,
+        footer
+      ] = await Promise.all([
+        readFile(resolve(__dirname, "./templates/template.hbs"), "utf-8"),
+        readFile(resolve(__dirname, "./templates/header.hbs"), "utf-8"),
+        readFile(resolve(__dirname, "./templates/commit.hbs"), "utf-8"),
+        readFile(resolve(__dirname, "./templates/footer.hbs"), "utf-8")
+      ]);
+      const writerOpts = getWriterOpts(config);
+      writerOpts.mainTemplate = template;
+      writerOpts.headerPartial = header.replace(/{{compareUrlFormat}}/g, compareUrlFormat);
+      writerOpts.commitPartial = commit.replace(/{{commitUrlFormat}}/g, commitUrlFormat).replace(/{{issueUrlFormat}}/g, issueUrlFormat);
+      writerOpts.footerPartial = footer;
+      return writerOpts;
+    };
+    function findTypeEntry(types, commit) {
+      const typeKey = (commit.revert ? "revert" : commit.type || "").toLowerCase();
+      return types.find((entry) => {
+        if (entry.type !== typeKey) {
+          return false;
+        }
+        if (entry.scope && entry.scope !== commit.scope) {
+          return false;
+        }
+        return true;
+      });
+    }
+    function getWriterOpts(config) {
+      config = defaultConfig(config);
+      const commitGroupOrder = config.types.flatMap((t) => t.section).filter((t) => t);
+      return {
+        transform: (commit, context) => {
+          let discard = true;
+          const issues = [];
+          const entry = findTypeEntry(config.types, commit);
+          addBangNotes(commit);
+          if (commit.footer && releaseAsRe.test(commit.footer) || commit.body && releaseAsRe.test(commit.body)) {
+            discard = false;
+          }
+          commit.notes.forEach((note) => {
+            note.title = "BREAKING CHANGES";
+            discard = false;
+          });
+          if (discard && (entry === void 0 || entry.hidden))
+            return;
+          if (entry)
+            commit.type = entry.section;
+          if (commit.scope === "*") {
+            commit.scope = "";
+          }
+          if (typeof commit.hash === "string") {
+            commit.shortHash = commit.hash.substring(0, 7);
+          }
+          if (typeof commit.subject === "string") {
+            config.issuePrefixes.join("|");
+            const issueRegEx = "(" + config.issuePrefixes.join("|") + ")([0-9]+)";
+            const re = new RegExp(issueRegEx, "g");
+            commit.subject = commit.subject.replace(re, (_, prefix, issue) => {
+              issues.push(prefix + issue);
+              const url = expandTemplate(config.issueUrlFormat, {
+                host: context.host,
+                owner: context.owner,
+                repository: context.repository,
+                id: issue,
+                prefix
+              });
+              return `[${prefix}${issue}](${url})`;
+            });
+            commit.subject = commit.subject.replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/g, (_, user) => {
+              if (user.includes("/")) {
+                return `@${user}`;
+              }
+              const usernameUrl = expandTemplate(config.userUrlFormat, {
+                host: context.host,
+                owner: context.owner,
+                repository: context.repository,
+                user
+              });
+              return `[@${user}](${usernameUrl})`;
+            });
+          }
+          commit.references = commit.references.filter((reference) => {
+            if (issues.indexOf(reference.prefix + reference.issue) === -1) {
+              return true;
+            }
+            return false;
+          });
+          return commit;
+        },
+        groupBy: "type",
+        // the groupings of commit messages, e.g., Features vs., Bug Fixes, are
+        // sorted based on their probable importance:
+        commitGroupsSort: (a, b) => {
+          const gRankA = commitGroupOrder.indexOf(a.title);
+          const gRankB = commitGroupOrder.indexOf(b.title);
+          return gRankA - gRankB;
+        },
+        commitsSort: ["scope", "subject"],
+        noteGroupsSort: "title",
+        notesSort: compareFunc
+      };
+    }
+    function defaultConfig(config) {
+      config = config || {};
+      config.types = config.types || [
+        { type: "feat", section: "Features" },
+        { type: "feature", section: "Features" },
+        { type: "fix", section: "Bug Fixes" },
+        { type: "perf", section: "Performance Improvements" },
+        { type: "revert", section: "Reverts" },
+        { type: "docs", section: "Documentation", hidden: true },
+        { type: "style", section: "Styles", hidden: true },
+        { type: "chore", section: "Miscellaneous Chores", hidden: true },
+        { type: "refactor", section: "Code Refactoring", hidden: true },
+        { type: "test", section: "Tests", hidden: true },
+        { type: "build", section: "Build System", hidden: true },
+        { type: "ci", section: "Continuous Integration", hidden: true }
+      ];
+      config.issueUrlFormat = config.issueUrlFormat || "{{host}}/{{owner}}/{{repository}}/issues/{{id}}";
+      config.commitUrlFormat = config.commitUrlFormat || "{{host}}/{{owner}}/{{repository}}/commit/{{hash}}";
+      config.compareUrlFormat = config.compareUrlFormat || "{{host}}/{{owner}}/{{repository}}/compare/{{previousTag}}...{{currentTag}}";
+      config.userUrlFormat = config.userUrlFormat || "{{host}}/{{user}}";
+      config.issuePrefixes = config.issuePrefixes || ["#"];
+      return config;
+    }
+    function expandTemplate(template, context) {
+      let expanded = template;
+      Object.keys(context).forEach((key) => {
+        expanded = expanded.replace(new RegExp(`{{${key}}}`, "g"), context[key]);
+      });
+      return expanded;
+    }
+  }
+});
+
+// node_modules/conventional-changelog-conventionalcommits/conventional-changelog.js
+var require_conventional_changelog = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/conventional-changelog.js"(exports2, module2) {
+    "use strict";
+    var parserOpts = require_parser_opts();
+    var writerOpts = require_writer_opts();
+    module2.exports = function(config) {
+      return Promise.all([parserOpts(config), writerOpts(config)]).then(([parserOpts2, writerOpts2]) => ({
+        parserOpts: parserOpts2,
+        writerOpts: writerOpts2
+      }));
+    };
+  }
+});
+
+// node_modules/conventional-changelog-conventionalcommits/conventional-recommended-bump.js
+var require_conventional_recommended_bump = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/conventional-recommended-bump.js"(exports2, module2) {
+    "use strict";
+    var addBangNotes = require_add_bang_notes();
+    var parserOpts = require_parser_opts();
+    module2.exports = function(config) {
+      return {
+        parserOpts: parserOpts(config),
+        whatBump: (commits) => {
+          let level = 2;
+          let breakings = 0;
+          let features = 0;
+          commits.forEach((commit) => {
+            addBangNotes(commit);
+            if (commit.notes.length > 0) {
+              breakings += commit.notes.length;
+              level = 0;
+            } else if (commit.type === "feat" || commit.type === "feature") {
+              features += 1;
+              if (level === 2) {
+                level = 1;
+              }
+            }
+          });
+          if (config.preMajor && level < 2) {
+            level++;
+          }
+          return {
+            level,
+            reason: breakings === 1 ? `There is ${breakings} BREAKING CHANGE and ${features} features` : `There are ${breakings} BREAKING CHANGES and ${features} features`
+          };
+        }
+      };
+    };
+  }
+});
+
+// node_modules/conventional-changelog-conventionalcommits/index.js
+var require_conventional_changelog_conventionalcommits = __commonJS({
+  "node_modules/conventional-changelog-conventionalcommits/index.js"(exports2, module2) {
+    "use strict";
+    var conventionalChangelog = require_conventional_changelog();
+    var parserOpts = require_parser_opts();
+    var recommendedBumpOpts = require_conventional_recommended_bump();
+    var writerOpts = require_writer_opts();
+    module2.exports = function(parameter) {
+      if (typeof parameter === "function") {
+        const config = {};
+        Promise.all([
+          conventionalChangelog(config),
+          parserOpts(config),
+          recommendedBumpOpts(config),
+          writerOpts(config)
+        ]).then(([conventionalChangelog2, parserOpts2, recommendedBumpOpts2, writerOpts2]) => {
+          parameter(null, {
+            gitRawCommitsOpts: {
+              noMerges: null
+            },
+            conventionalChangelog: conventionalChangelog2,
+            parserOpts: parserOpts2,
+            recommendedBumpOpts: recommendedBumpOpts2,
+            writerOpts: writerOpts2
+          });
+        });
+      } else {
+        const config = parameter || {};
+        return presetOpts(config);
+      }
+    };
+    function presetOpts(config) {
+      return Promise.all([
+        conventionalChangelog(config),
+        parserOpts(config),
+        recommendedBumpOpts(config),
+        writerOpts(config)
+      ]).then(([conventionalChangelog2, parserOpts2, recommendedBumpOpts2, writerOpts2]) => ({
+        conventionalChangelog: conventionalChangelog2,
+        parserOpts: parserOpts2,
+        recommendedBumpOpts: recommendedBumpOpts2,
+        writerOpts: writerOpts2
+      }));
+    }
+  }
+});
+
+// src/parser.js
+module.exports = require_conventional_changelog_conventionalcommits();

package/gitmessage

@@ -0,0 +1,52 @@
+
+
+#
+# Our commit message format is as follows:
+#
+# type: short summary (fixes XYZ-1234)
+#
+# Longer description here if necessary
+#
+# The first line of the commit message (the commit title) must have a specific format. This format is checked by our build tools.
+#
+# The type is one of the following:
+#
+# * feat     - for a new feature.
+# * fix      - for a bug fix
+# * build    - changes to build process only.
+# * ci       - changes to ci/cd configuration only.
+# * docs     - changes to documentation only..
+# * perf     - for a performance improvement.
+# * refactor - code refactor without change in behaviour.
+# * revert   - for reverting a commit.
+# * style    - cosmetic changes only.
+# * test     - changes to test cases only.
+# * chore    - changes not fitting any other description.
+#
+# Breaking changes must include "BREAKING CHANGE: " in the longer description.
+#
+# The message summary should be a one-sentence description of the change, and it must be 72 characters in length or shorter.
+# If the pull request addresses an issue, then the issue number should be mentioned at the end. If the commit doesn’t completely
+# fix the issue, then use (refs XYZ-1234) instead of (fixes XYZ-1234).
+#
+# Here are some good commit message summary examples:
+#
+# * build: update Travis to only test Node 0.10 (refs XYZ-1234)
+#
+#   Travis did not work properly with last upgrade
+#   to 0.11. To ensure that we execute all our tests
+#   Travis is downgraded to the last working Node version.
+#
+# * fix: semi rule incorrectly flagging extra semicolon (fixes XYZ-1234)
+#
+#   In a few edge cases the semi rule wanted an extra
+#   semicolon.
+#
+#   Update code to work with these edge cases and add tests
+#   for the edge cases.
+#
+# * chore(deps): esprima to 1.2, switch to using Esprima comment attachment (fixes XYZ-1234)
+#
+# The commit message format is important because these messages are used to create a changelog for each release. The tag and issue
+# number help to create more consistent and useful changelogs.
+#

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@forsakringskassan/commitlint-config",
+  "version": "1.2.0",
+  "description": "FK commitlint shareable config",
+  "keywords": [
+    "commitlint"
+  ],
+  "homepage": "https://github.com/Forsakringskassan/commitlint-config",
+  "bugs": "https://github.com/Forsakringskassan/commitlint-config/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Forsakringskassan/commitlint-config.git"
+  },
+  "license": "MIT",
+  "author": "Försäkringskassan",
+  "exports": {
+    ".": "./dist/config/default.js",
+    "./default": "./dist/config/default.js",
+    "./no-jira": "./dist/config/no-jira.js"
+  },
+  "main": "dist/config/default.js",
+  "bin": {
+    "commitlint": "bin/cli.js",
+    "commitlint-config": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "gitmessage"
+  ],
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "run-s build:*",
+    "build:cli": "esbuild --bundle --platform=node --target=node16.0 --external:ts-node --outdir=dist/cli src/commitlint.js",
+    "build:config": "esbuild --bundle --platform=node --target=node16.0 --external:@forsakringskassan/commitlint-config --outdir=dist/config src/config/default.js src/config/no-jira.js",
+    "build:install": "esbuild --bundle --platform=node --target=node16.0 --outdir=dist src/install.js",
+    "build:format": "esbuild --bundle --platform=node --target=node16.0 --outdir=dist src/format.js",
+    "build:parser": "esbuild --bundle --platform=node --target=node16.0 --outdir=dist src/parser.js",
+    "postbuild": "run-s postbuild:*",
+    "postbuild:cli": "cp -R node_modules/conventional-changelog-angular/templates/ dist/cli",
+    "postbuild:config": "cp -R node_modules/conventional-changelog-conventionalcommits/templates/ dist/config",
+    "prepack": "run-s pkg:mangle",
+    "postpack": "run-s pkg:restore",
+    "prepublishOnly": "run-s pkg:mangle",
+    "eslint": "eslint .",
+    "eslint:fix": "eslint --fix .",
+    "pkg:mangle": "run-s pkg:mangle:*",
+    "pkg:mangle:pack": "release-prepack package.json --bundle --retain-scripts",
+    "pkg:mangle:add": "npm pkg set scripts.postinstall=\"node bin/install.js\"",
+    "pkg:restore": "release-postpack package.json",
+    "prepare": "husky && git config commit.template gitmessage",
+    "prettier:check": "prettier . --check",
+    "prettier:write": "prettier . --write",
+    "pretest": "run-s eslint prettier:check",
+    "test": "jest",
+    "postinstall": "node bin/install.js"
+  },
+  "peerDependencies": {
+    "ts-node": "^10"
+  },
+  "engines": {
+    "node": ">= 16"
+  }
+}