@polygontech/commit-template 1.0.0

package/.czrc.json

@@ -0,0 +1,5 @@
+{
+  "issue_trackers": [],
+  "default_issue_tracker": null,
+  "scopes": ["Loader", "Formatter", "DTO"]
+}

package/CZRC.js

@@ -0,0 +1,131 @@
+const pad = require("pad");
+const fuzzy = require("fuzzy");
+
+function CZRC() {
+  this.types = [];
+  this.issueTrackers = [];
+  this.defaultIssueTracker = "";
+  this.authors = [];
+  this.scopes = [];
+  this.subjectMaxLength = 72;
+  this.bodyMaxLength = 80;
+  this.sectionHeaders = {};
+  this.bullet = "- ";
+  this.inlineSeparator = ", ";
+  this.issueTrackerIdSeparator = ": ";
+  this.authorEmailTag = { start: " <", end: ">" };
+  this.blockNonImperativeSubject = true;
+  this.extraImperativeVerbs = [];
+}
+
+CZRC.prototype.overwrite = function (overwrite) {
+  if (overwrite === null) return;
+
+  this.types = overwrite.types || this.types;
+  this.issueTrackers = overwrite.issueTrackers || this.issueTrackers;
+  this.defaultIssueTracker = this.hasIssueTracker() ? overwrite.defaultIssueTracker || this.defaultIssueTracker : "";
+  this.authors = overwrite.authors || this.authors;
+  this.scopes = overwrite.scopes || this.scopes;
+  this.subjectMaxLength = overwrite.subjectMaxLength || this.subjectMaxLength;
+  this.bodyMaxLength = overwrite.bodyMaxLength || this.bodyMaxLength;
+  this.sectionHeaders = overwrite.sectionHeaders || this.sectionHeaders;
+  this.bullet = overwrite.bullet || this.bullet;
+  this.inlineSeparator = overwrite.inlineSeparator || this.inlineSeparator;
+  this.issueTrackerIdSeparator = overwrite.issueTrackerIdSeparator || this.issueTrackerIdSeparator;
+  this.authorEmailTag = overwrite.authorEmailTag || this.authorEmailTag;
+  this.blockNonImperativeSubject = overwrite.blockNonImperativeSubject === false ? false : true;
+};
+
+CZRC.prototype.pushExtraImperativeVerbs = function (extraImperativeVerbs) {
+  if (!Array.isArray(extraImperativeVerbs)) return;
+  if (extraImperativeVerbs.length == 0) return;
+  this.extraImperativeVerbs = [...this.extraImperativeVerbs, ...extraImperativeVerbs];
+};
+
+CZRC.prototype.getPromise = function () {
+  return new Promise((resolve) => resolve(this));
+};
+
+CZRC.prototype.formatTypesWithEmoji = function () {
+  let types = this.types;
+  const max_name_length = types.reduce((max, type) => (type.name.length > max ? type.name.length : max), 0);
+  const max_emoji_length = types.reduce((max, type) => (type.emoji.length > max ? type.emoji.length : max), 0);
+
+  return types.map((type) => ({
+    name: `${pad(type.name, max_name_length)}  ${pad(type.emoji, max_emoji_length)}  ${type.description.trim()}`,
+    value: type,
+    code: type.code,
+  }));
+};
+
+CZRC.prototype.searchAuthor = function (answers, input) {
+  input = input || "";
+  let authors = this.authors.map((author) => author.name);
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      var fuzzy_result = fuzzy.filter(input, authors);
+      resolve(fuzzy_result.map((el) => el.original));
+    }, Math.random() * (500 - 30) + 30);
+  });
+};
+
+CZRC.prototype.getAuthorByName = function (name) {
+  for (let i = 0; i < this.authors.length; i++) {
+    if (this.authors[i].name === name) return this.authors[i];
+  }
+  return null;
+};
+
+CZRC.prototype.getTypeByName = function (name) {
+  for (let i = 0; i < this.types.length; i++) {
+    if (this.types[i].name === name) return this.types[i];
+  }
+  return null;
+};
+
+CZRC.prototype.getTypeByEmoji = function (emoji) {
+  for (let i = 0; i < this.types.length; i++) {
+    if (this.types[i].emoji === emoji) return this.types[i];
+  }
+  return null;
+};
+
+CZRC.prototype.isValidTypeName = function (type) {
+  return this.getTypeByName(type) !== null;
+};
+
+CZRC.prototype.isValidTypeEmoji = function (emoji) {
+  return this.getTypeByEmoji(emoji) !== null;
+};
+
+CZRC.prototype.isValidType = function (name, emoji) {
+  let type = this.getTypeByName(name);
+  if (type === null) return false;
+  return type.emoji === emoji;
+};
+
+CZRC.prototype.isValidAuthor = function (name, email) {
+  let author = this.getAuthorByName(name);
+  if (author === null) return false;
+  return author.email === email;
+};
+
+CZRC.prototype.isValidScope = function (scope) {
+  return this.scopes.includes(scope);
+};
+
+CZRC.prototype.doesNotHaveIssueTracker = function () {
+  return !this.hasIssueTracker();
+};
+
+CZRC.prototype.hasIssueTracker = function () {
+  return this.issueTrackers.length > 0;
+};
+
+CZRC.prototype.isValidIssueTracker = function (name) {
+  if (this.doesNotHaveIssueTracker()) return true;
+
+  return this.issueTrackers.includes(name);
+};
+
+module.exports = CZRC;

package/CZRCLoader.js

@@ -0,0 +1,117 @@
+const fs = require("fs");
+const download = require("download");
+const homeDir = require("home-dir");
+const CZRC = require("./CZRC");
+
+const read = (file) => fs.readFileSync(file, "utf8");
+const write = fs.writeFileSync;
+const rc_folder_name = homeDir(".czrc.d");
+const deafult_rc_file = rc_folder_name + "/default.json";
+const project_rc_url_file_name = ".czrc.url";
+const project_rc_file_name = ".czrc.json";
+const default_file_hosted_url = "https://raw.githubusercontent.com/ShafiqIslam/dotfiles/master/git/.czrc.json";
+
+function CZRCLoader() {
+  this.czrc = new CZRC();
+}
+
+CZRCLoader.prototype.load = async function () {
+  ensureRCFolder();
+  await this.loadDefaultRC();
+  await this.overwriteFromProject();
+  return this.czrc;
+};
+
+CZRCLoader.prototype.loadDefaultRC = async function () {
+  await this.ensureAndLoadFile(deafult_rc_file, default_file_hosted_url);
+};
+
+CZRCLoader.prototype.ensureAndLoadFile = async function (file_fqn, file_url) {
+  await ensureFile(file_fqn, file_url);
+  this.loadFromFile(file_fqn);
+};
+
+CZRCLoader.prototype.loadFromFile = function (file) {
+  let czrc = read(file);
+  czrc = (czrc && JSON.parse(czrc)) || null;
+
+  if (czrc === null) return;
+
+  czrc.issueTrackers = czrc.issue_trackers;
+  czrc.defaultIssueTracker = czrc.default_issue_tracker;
+  czrc.subjectMaxLength = czrc.subject_max_length;
+  czrc.bodyMaxLength = czrc.body_max_length;
+  czrc.sectionHeaders = czrc.section_headers;
+  czrc.inlineSeparator = czrc.inline_separator;
+  czrc.issueTrackerIdSeparator = czrc.issue_tracker_id_separator;
+  czrc.authorEmailTag = czrc.author_email_tag;
+  czrc.blockNonImperativeSubject = czrc.block_non_imperative_subject;
+
+  this.czrc.overwrite(czrc);
+  this.czrc.pushExtraImperativeVerbs(czrc.extra_imperative_verbs);
+};
+
+CZRCLoader.prototype.overwriteFromProject = async function () {
+  await this.loadFromProjectURL();
+  this.loadFromProjectRC();
+};
+
+CZRCLoader.prototype.loadFromProjectURL = async function () {
+  let urlFile = process.cwd() + "/" + project_rc_url_file_name;
+
+  if (!fs.existsSync(urlFile)) return;
+
+  await this.ensureAndLoadFile(getProjectRCDownloadFileFQN(), getUrlFromFile(urlFile));
+};
+
+CZRCLoader.prototype.loadFromProjectRC = function () {
+  let project_rc_file_fqn = process.cwd() + "/" + project_rc_file_name;
+
+  if (!fs.existsSync(project_rc_file_fqn)) return;
+
+  this.loadFromFile(project_rc_file_fqn);
+};
+
+function ensureRCFolder() {
+  if (!fs.existsSync(rc_folder_name)) {
+    createRCFolder();
+    return;
+  }
+
+  if (fs.lstatSync(rc_folder_name).isDirectory()) return;
+
+  fs.unlinkSync(rc_folder_name);
+  createRCFolder();
+}
+
+function createRCFolder() {
+  fs.mkdirSync(rc_folder_name, { recursive: true });
+}
+
+async function ensureFile(file_fqn, file_url) {
+  let _download = (async () => {
+    write(file_fqn, await download(file_url));
+  })();
+
+  if (fs.existsSync(file_fqn)) {
+    _download.catch(function (e) {
+      console.error(e);
+    });
+  } else {
+    await _download;
+  }
+}
+
+function getUrlFromFile(urlFile) {
+  return read(urlFile)
+    .split(/(?:\r\n|\r|\n)/g)
+    .reduce((prev, cur) => {
+      if (cur.startsWith("URL=")) return cur.replace("URL=", "");
+    });
+}
+
+function getProjectRCDownloadFileFQN() {
+  return rc_folder_name + "/" + process.cwd().replace("/", "").replaceAll("/", "_").replaceAll("-", "_") + ".json";
+}
+
+module.exports = CZRCLoader;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2015-2018 Commitizen Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# commit-template
+JS wrapper for the [commit template](https://github.com/ShafiqIslam/dotfiles/blob/master/.gitmessage).
+
+# usage
+Not for open use. Meant to be used with
+[@sheba/cz-convention](https://github.com/ShafiqIslam/cz-convention) and [@sheba/commitlint](https://github.com/ShafiqIslam/commitlint) 

package/dto/author.js

@@ -0,0 +1,6 @@
+function Author(name, email) {
+    this.name = name;
+    this.email = email;
+}
+
+module.exports = Author;

package/dto/issue.js

@@ -0,0 +1,6 @@
+function Issue(tracker, issue_id) {
+    this.tracker = tracker;
+    this.issueId = issue_id;
+}
+
+module.exports = Issue;

package/dto/message.js

@@ -0,0 +1,121 @@
+const nlp = require("compromise");
+const util = require("node:util");
+
+const ValidationError = require("../formatter/errors/validation_error");
+
+let _czrc = null;
+function Message() {
+  this.subject = null;
+  this.types = [];
+  this.scopes = [];
+  this.what = null;
+  this.why = null;
+  this.issues = [];
+  this.coAuthors = [];
+  this.references = [];
+}
+
+/**
+ * @param string
+ */
+Message.prototype.setSubject = function (subject) {
+  this.subject = subject;
+  return this;
+};
+
+/**
+ * @param array<Type>
+ */
+Message.prototype.setTypes = function (types) {
+  this.types = types;
+  return this;
+};
+
+/**
+ * @param array<string>
+ */
+Message.prototype.setScopes = function (scopes) {
+  this.scopes = scopes;
+  return this;
+};
+
+/**
+ * @param string
+ */
+Message.prototype.setWhat = function (what) {
+  this.what = what;
+  return this;
+};
+
+/**
+ * @param string
+ */
+Message.prototype.setWhy = function (why) {
+  this.why = why;
+  return this;
+};
+
+/**
+ * @param array<Issue>
+ */
+Message.prototype.setIssues = function (issues) {
+  this.issues = issues;
+  return this;
+};
+
+/**
+ * @param array<string>
+ */
+Message.prototype.setReferences = function (references) {
+  this.references = references;
+  return this;
+};
+
+/**
+ * @param array<Author>
+ */
+Message.prototype.setCoAuthors = function (co_authors) {
+  this.coAuthors = co_authors;
+  return this;
+};
+
+Message.prototype.validate = function () {
+  validateSubject(this.subject);
+  validateIssues(this.issues);
+};
+
+function validateSubject(subject) {
+  if (!subject) throw new ValidationError("Subject can't be empty");
+
+  if (isImperative(subject)) return;
+
+  let message =
+    'Subject %s be in imperative mood, and should complete "This commit will ... ", e.g. "... Do something".';
+
+  if (_czrc.blockNonImperativeSubject) {
+    throw new ValidationError(util.format(message, "must"));
+  } else {
+    console.log(`\n\x1b[33m${util.format(message, "should")}`);
+    console.log("However, this is allowed for the time being, please be aware next time. \x1b[0m\n");
+  }
+}
+
+function isImperative(sentence) {
+  let first_word = sentence.split(" ")[0];
+  let imperative = nlp(first_word).verbs().isImperative().text();
+  if (first_word == imperative) return true;
+
+  if (_czrc.extraImperativeVerbs.includes(first_word)) return true;
+
+  return false;
+}
+
+function validateIssues(issues) {
+  if (_czrc.doesNotHaveIssueTracker()) return;
+  if (!issues || issues.length == 0) throw new ValidationError("Issues can't be empty");
+}
+
+module.exports = function (czrc) {
+  _czrc = czrc;
+  return Message;
+};

package/dto/type.js

@@ -0,0 +1,8 @@
+function Type(obj) {
+    this.name = obj ? obj.name : null;
+    this.emoji = obj ? obj.emoji : null;
+    this.code = obj ? obj.code : null;
+    this.description = obj ? obj.description : null;
+}
+
+module.exports = Type;

package/formatter/errors/decomposing_error.js

@@ -0,0 +1,8 @@
+class DecomposingError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DecomposingError";
+	}
+}
+
+module.exports = DecomposingError;

package/formatter/errors/invalid_author.js

@@ -0,0 +1,9 @@
+let DecomposingError = require('./decomposing_error.js');
+class InvalidAuthor extends DecomposingError {
+    constructor(author, message) {
+        super("Invalid author: " + author + ". " + (message || ""));
+        this.name = "InvalidAuthor";
+    }
+}
+
+module.exports = InvalidAuthor;

package/formatter/errors/invalid_scope.js

@@ -0,0 +1,9 @@
+let DecomposingError = require('./decomposing_error.js');
+class InvalidScope extends DecomposingError {
+    constructor(scope) {
+        super("Given scope " + scope + " does not exist.");
+        this.name = "InvalidScope";
+    }
+}
+
+module.exports = InvalidScope;

package/formatter/errors/invalid_type.js

@@ -0,0 +1,9 @@
+let DecomposingError = require('./decomposing_error.js');
+class InvalidType extends DecomposingError {
+	constructor(type) {
+		super("Given type " + type + " does not exist.");
+		this.name = "InvalidType";
+	}
+}
+
+module.exports = InvalidType;

package/formatter/errors/malformed_string.js

@@ -0,0 +1,10 @@
+let DecomposingError = require('./decomposing_error.js');
+class MalformedString extends DecomposingError {
+	constructor(message) {
+        message = message || "The given message string is malformed";
+		super(message);
+		this.name = "MalformedString";
+	}
+}
+
+module.exports = MalformedString;

package/formatter/errors/max_length_exceeded.js

@@ -0,0 +1,9 @@
+let DecomposingError = require('./decomposing_error.js');
+class MaxLengthExceeded extends DecomposingError {
+    constructor(line, expected_length) {
+        super("Max length exceeded in \"" + line + "\". Expected " + expected_length + " found " + line.length);
+        this.name = "MaxLengthExceeded";
+    }
+}
+
+module.exports = MaxLengthExceeded;

package/formatter/errors/validation_error.js

@@ -0,0 +1,8 @@
+class ValidationError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ValidationError";
+	}
+}
+
+module.exports = ValidationError;

package/formatter/helpers.js

@@ -0,0 +1,16 @@
+String.prototype.ucFirst = function () {
+    return this.charAt(0).toUpperCase() + this.slice(1);
+};
+
+String.prototype.trimAny = function (s) {
+    if (s === " ") return this.trim();
+    if (s === "]") s = "\\]";
+    if (s === "\\") s = "\\\\";
+    let regex = new RegExp("^[" + s + "]+|[" + s + "]+$", "g");
+    return this.replace(regex, "");
+};
+
+String.prototype.replaceAll = function(search, replacement) {
+    var target = this;
+    return target.replace(new RegExp(search, 'g'), replacement);
+};

package/formatter/to_object.js

@@ -0,0 +1,128 @@
+require('./helpers.js');
+let Message = require('../dto/message.js');
+let Type = require('../dto/type.js');
+let Author = require('../dto/author.js');
+let Issue = require('../dto/issue.js');
+let DecomposingError = require('./errors/decomposing_error.js');
+let MaxLengthExceeded = require('./errors/max_length_exceeded.js');
+let MalformedString = require('./errors/malformed_string.js');
+let InvalidType = require('./errors/invalid_type.js');
+let InvalidScope = require('./errors/invalid_scope.js');
+let InvalidAuthor = require('./errors/invalid_author.js');
+
+let _czrc = null;
+let _headers = null;
+let _message_splits = null;
+
+/**
+ * Format the git commit message from given answers.
+ *
+ * @param {String} Formated git commit message
+ * @return {Message} Message object containing message segments
+ */
+function format(message_string) {
+    _message_splits = message_string.replaceAll('\r\n', '\n').trimAny('\n').split('\n\n');
+    let message = new Message();
+    checkRequired();
+	let types = getTypes();
+    message.setSubject(getSubject(types)).setTypes(types);
+    for(let i=2; i<_message_splits.length; i++) {
+        let split = _message_splits[i];
+        if(split.startsWith(_headers.scopes)) message.setScopes(getScopes(split));
+        else if(split.startsWith(_headers.why)) message.setWhy(split.replace(_headers.why, ''));
+        else if(split.startsWith(_headers.what)) message.setWhat(split.replace(_headers.what, ''));
+        else if(split.startsWith(_headers.issues + _czrc.bullet)) message.setIssues(getIssues(split));
+        else if(split.startsWith(_headers.references + _czrc.bullet)) message.setReferences(getReferences(split));
+        else if(split.startsWith(_headers.co_authors + _czrc.bullet)) message.setCoAuthors(getAuthors(split));
+        else throw new MalformedString("Invalid section containing: " + split);
+    }
+    return message;
+}
+
+function checkRequired() {
+    if(_message_splits.length < 2) {
+        throw new MalformedString("At least 2 section (subject and types) must be present");
+    }
+    if(!_message_splits[1].startsWith(_headers.types)) {
+        throw new MalformedString("Type(s) must be present in second section, found: " + _message_splits[1]);
+    }
+}
+
+function getSubject(types) {
+	let subject = _message_splits[0];
+	if(subject.length > _czrc.subjectMaxLength) throw new MaxLengthExceeded(subject, _czrc.subjectMaxLength);
+	if(subject.endsWith('.') || subject.endsWith(',')) throw new DecomposingError("Punctuations not allowed for subject line ending.");
+	/*for(let i=0; i<types.length; i++) {
+		if(!subject.startsWith(types[i].emoji)) throw new DecomposingError("Type emoji does not match for type: " + types[i].name);
+		subject = subject.replace(types[i].emoji, '').trim();
+	}
+	if(subject[0] !== subject[0].toUpperCase()) throw new DecomposingError("Subject must be capitalized");*/
+	return subject;
+}
+
+function getTypes() {
+    let types = _message_splits[1].replace(_headers.types, '').split(_czrc.inlineSeparator);
+    for(let i=0; i<types.length; i++) {
+        let type = _czrc.getTypeByName(types[i]);
+        if(type == null) throw new InvalidType(types[i]);
+        types[i] = new Type(type);
+    }
+    return types;
+}
+
+function getScopes(split) {
+    let scopes = split.replace(_headers.scopes, '').split(_czrc.inlineSeparator);
+    for(let i=0; i<scopes.length; i++) {
+        if(!_czrc.isValidScope(scopes[i])) throw new InvalidScope(scopes[i]);
+    }
+    return scopes;
+}
+
+function getReferences(split) {
+    let references = split.replace(_headers.references + _czrc.bullet, '').split('\n' + _czrc.bullet);
+    for(let i=0; i<references.length; i++) {
+        if(!references[i]) throw new DecomposingError("Empty reference is not allowed.");
+    }
+    return references;
+}
+
+function getIssues(split) {
+    let issues = split.replace(_headers.issues + _czrc.bullet, '').split('\n' + _czrc.bullet);
+	let issue_objects = [];
+    for(let i=0; i<issues.length; i++) {
+        let issues_splited = issues[i].split(_czrc.issueTrackerIdSeparator);
+		if(issues_splited.length != 2) throw new MalformedString("Could not parse issue: " + issues[i]);
+		let tracker = issues_splited[0];
+        if(!_czrc.isValidIssueTracker(tracker)) throw new InvalidIssueTracker(tracker);
+		let issue_ids = issues_splited[1].split(_czrc.inlineSeparator);
+		for(let j=0; j<issue_ids.length; j++) {
+			if(!issue_ids[j]) throw new DecomposingError("Empty issue id is not allowed.");
+        	issue_objects.push(new Issue(tracker, issue_ids[i]));
+		}
+    }
+    return issue_objects;
+}
+
+function getAuthors(split) {
+	let authors = split.replace(_headers.co_authors + _czrc.bullet, '').split('\n' + _czrc.bullet);
+	for(let i=0; i<authors.length; i++) {
+		try {
+			let author_split = authors[i].split(_czrc.authorEmailTag.start);
+			let author = _czrc.getAuthorByName(author_split[0]);
+			if(author.email != author_split[1].trimAny(_czrc.authorEmailTag.end)) {
+				throw new InvalidAuthor(authors[i], "Name and email does not match.");
+			}
+			authors[i] = new Author(author.name, author.email);
+		} catch (e) {
+			if (e instanceof InvalidAuthor) throw e;
+			else throw new InvalidAuthor(authors[i], "Not found.");
+		}
+	}
+	return authors;
+}
+
+module.exports = function(czrc) {
+    _czrc = czrc;
+    _headers = czrc.sectionHeaders;
+    return format;
+};

package/formatter/to_string.js

@@ -0,0 +1,105 @@
+const truncate = require('cli-truncate');
+const wrap = require('wrap-ansi');
+require('./helpers.js');
+
+let _czrc = null;
+let _message = null;
+
+let wrap_body = function(s) {
+	return wrap(s, _czrc.bodyMaxLength);
+};
+
+/**
+ * Format the git commit message from given answers.
+ *
+ * @param {Message} Message object containing message segments 
+ * @return {String} Formated git commit message
+ */
+function format(message) {
+    _message = message;
+    let message_segments = [];
+    let headers = _czrc.sectionHeaders;
+    message_segments.push(formatSubject());
+    message_segments.push(headers.types + formatTypes());
+    if(_message.scopes && _message.scopes.length) {
+        let s = formatScopes(); 
+        if(s) message_segments.push(headers.scopes + s);
+    }
+    if(_message.why) message_segments.push(headers.why + wrap_body(_message.why));
+    if(_message.what) message_segments.push(headers.what + wrap_body(_message.what));
+
+    if(_message.issues && _message.issues.length) {
+        let t = formatIssues();
+        if(t) message_segments.push(headers.issues.trimAny('\n') + t);
+    }
+    if(_message.references && _message.references.length) {
+        let r = formatReferences(); 
+        if(r) message_segments.push(headers.references.trimAny('\n') + r);
+    }
+    if(_message.coAuthors && _message.coAuthors.length) {
+        let a = formatCoAuthors(); 
+        if(a) message_segments.push(headers.co_authors.trimAny('\n') + a);
+    }
+    return message_segments.join('\n\n');
+}
+
+function formatSubject() {
+    let emojis = '';
+    _message.types.forEach(function(type) {
+        emojis += type.emoji + (type.emoji.length == 1 ? ' ' : '  ');
+    });
+    let subject = emojis + _message.subject.trimAny('. ').toLowerCase().ucFirst();
+    return truncate(subject, _czrc.subjectMaxLength);
+}
+
+function formatTypes() {
+    let types = '';
+    _message.types.forEach(function(type) {
+        types += type.name + _czrc.inlineSeparator;
+    });
+    return types.trimAny(_czrc.inlineSeparator);
+}
+
+function formatScopes() {
+	let scopes = '';
+	_message.scopes.forEach(function(scope) {
+        if(scope) scopes += scope + _czrc.inlineSeparator;
+    });
+	return scopes.trimAny(_czrc.inlineSeparator);
+}
+
+function formatIssues() {
+    let trackers = {};
+	_message.issues.forEach(function(issue) {
+        let tracker = issue.tracker;
+        if(!trackers.hasOwnProperty(tracker)) trackers[tracker] = '';
+        trackers[tracker] += issue.issueId + _czrc.inlineSeparator; 
+	});
+	let issues = '';
+    for(tracker in trackers) {
+        issues += '\n' + _czrc.bullet + tracker + _czrc.issueTrackerIdSeparator + trackers[tracker].trimAny(_czrc.inlineSeparator);
+    }
+	return issues;
+}
+
+function formatCoAuthors() {
+	let co_authors = '';
+    let email_tag = _czrc.authorEmailTag;
+	_message.coAuthors.forEach(function(author) {
+		co_authors += '\n' + _czrc.bullet + author.name + email_tag.start + author.email + email_tag.end;
+	});
+	return co_authors;
+}
+
+function formatReferences() {
+	let references = '';
+	_message.references.forEach(function(reference) {
+		references += '\n' + wrap_body(_czrc.bullet + reference);
+	});
+	return references;
+}
+
+module.exports = function(czrc) {
+    _czrc = czrc;
+    return format;
+};

package/index.js

@@ -0,0 +1,40 @@
+const commitTemplate = async function () {
+  let loader = new (require("./CZRCLoader.js"))();
+
+  let czrc = await loader.load();
+
+  let message = require("./dto/message.js")(czrc);
+  let type = require("./dto/type.js");
+  let author = require("./dto/author.js");
+  let issue = require("./dto/issue.js");
+
+  let format_string = require("./formatter/to_string.js")(czrc);
+  let format_object = require("./formatter/to_object.js")(czrc);
+
+  let DecomposingError = require("./formatter/errors/decomposing_error.js");
+  let ValidationError = require("./formatter/errors/validation_error.js");
+
+  return {
+    czrc: czrc,
+    dto: {
+      message: message,
+      type: type,
+      author: author,
+      issue: issue,
+    },
+    formatter: {
+      toString: format_string,
+      toObject: format_object,
+    },
+    errors: {
+      decompose: DecomposingError,
+      validation: ValidationError,
+    },
+  };
+};
+
+module.exports = commitTemplate;
+
+// commitTemplate().then(function (v) {
+//   console.dir(v);
+// });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@polygontech/commit-template",
+  "version": "1.0.0",
+  "description": "JS wrapper of https://github.com/ShafiqIslam/dotfiles/blob/master/git/.gitmessage.",
+  "homepage": "https://github.com/ShafiqIslam/commit-template",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ShafiqIslam/commit-template.git"
+  },
+  "author": "Shafiqul Islam <islamshafiq003@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "cli-truncate": "^1.0.0",
+    "compromise": "^13.11.4",
+    "download": "^8.0.0",
+    "fuse.js": "^3.2.0",
+    "fuzzy": "^0.1.3",
+    "home-dir": "^1.0.0",
+    "pad": "^2.0.1",
+    "wrap-ansi": "^3.0.0"
+  },
+  "czrcScopes": [
+    "czrc",
+    "formatting"
+  ]
+}