refactor: port rules to typescript

@commitlint/ensure/src/case.ts

@@ -2,7 +2,7 @@ import * as _ from 'lodash';
 
 export default ensureCase;
 
-type TargetCaseType =
+export type TargetCaseType =
 	| 'camel-case'
 	| 'kebab-case'
 	| 'snake-case'

@commitlint/ensure/src/index.ts

@@ -8,3 +8,4 @@ import notEmpty from './not-empty';
 export {ensureCase as case};
 export {ensureEnum as enum};
 export {maxLength, maxLineLength, minLength, notEmpty};
+export {TargetCaseType} from './case';

@commitlint/rules/package.json

@@ -3,20 +3,13 @@
   "version": "8.3.4",
   "description": "Lint your commit messages",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/"
   ],
   "scripts": {
-    "build": "cross-env NODE_ENV=production babel src --out-dir lib  --source-maps",
     "deps": "dep-check",
-    "pkg": "pkg-check --skip-import",
-    "start": "concurrently \"ava -c 4 --verbose --watch\" \"yarn run watch\"",
-    "watch": "babel src --out-dir lib --watch --source-maps"
-  },
-  "babel": {
-    "presets": [
-      "babel-preset-commitlint"
-    ]
+    "pkg": "pkg-check"
   },
   "engines": {
     "node": ">=4"

@commitlint/rules/src/body-case.test.js → @commitlint/rules/src/body-case.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import bodyCase from './body-case';
+import {bodyCase} from './body-case';
 
 const messages = {
 	empty: 'test: subject',

@commitlint/rules/src/body-case.js → @commitlint/rules/src/body-case.ts

@@ -1,7 +1,12 @@
 import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const bodyCase: Rule<ensure.TargetCaseType> = (
+	parsed,
+	when = 'always',
+	value = undefined
+) => {
 	const {body} = parsed;
 
 	if (!body) {

@commitlint/rules/src/body-empty.test.js → @commitlint/rules/src/body-empty.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import bodyEmpty from './body-empty';
+import {bodyEmpty} from './body-empty';
 
 const messages = {
 	empty: 'test: subject',

@commitlint/rules/src/body-empty.js → @commitlint/rules/src/body-empty.ts

@@ -1,9 +1,10 @@
 import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when) => {
+export const bodyEmpty: Rule = (parsed, when = 'always') => {
 	const negated = when === 'never';
-	const notEmpty = ensure.notEmpty(parsed.body);
+	const notEmpty = ensure.notEmpty(parsed.body || '');
 
 	return [
 		negated ? notEmpty : !notEmpty,

@commitlint/rules/src/body-leading-blank.test.js → @commitlint/rules/src/body-leading-blank.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import bodyLeadingBlank from './body-leading-blank';
+import {bodyLeadingBlank} from './body-leading-blank';
 
 const messages = {
 	simple: 'test: subject',

@commitlint/rules/src/body-leading-blank.js → @commitlint/rules/src/body-leading-blank.ts

@@ -1,7 +1,8 @@
 import toLines from '@commitlint/to-lines';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when) => {
+export const bodyLeadingBlank: Rule = (parsed, when) => {
 	// Flunk if no body is found
 	if (!parsed.body) {
 		return [true];

@commitlint/rules/src/body-max-length.test.js → @commitlint/rules/src/body-max-length.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import check from './body-max-length';
+import {bodyMaxLength} from './body-max-length';
 
 const short = 'a';
 const long = 'ab';
@@ -19,19 +19,19 @@ const parsed = {
 };
 
 test('with empty should succeed', async () => {
-	const [actual] = check(await parsed.empty, '', value);
+	const [actual] = bodyMaxLength(await parsed.empty, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with short should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = bodyMaxLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = bodyMaxLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });

@commitlint/rules/src/body-max-length.js → @commitlint/rules/src/body-max-length.ts

@@ -1,6 +1,11 @@
 import {maxLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const bodyMaxLength: Rule<number> = (
+	parsed,
+	when = undefined,
+	value = 0
+) => {
 	const input = parsed.body;
 
 	if (!input) {

@commitlint/rules/src/body-max-line-length.test.js → @commitlint/rules/src/body-max-line-length.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import check from './body-max-line-length';
+import {bodyMaxLineLength} from './body-max-line-length';
 
 const short = 'a';
 const long = 'ab';
@@ -21,31 +21,31 @@ const parsed = {
 };
 
 test('with empty should succeed', async () => {
-	const [actual] = check(await parsed.empty, '', value);
+	const [actual] = bodyMaxLineLength(await parsed.empty, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with short should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = bodyMaxLineLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = bodyMaxLineLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });
 
 test('with short with multiple lines should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = bodyMaxLineLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long with multiple lines should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = bodyMaxLineLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });

@commitlint/rules/src/body-max-line-length.js → @commitlint/rules/src/body-max-line-length.ts

@@ -1,6 +1,11 @@
 import {maxLineLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const bodyMaxLineLength: Rule<number> = (
+	parsed,
+	when = undefined,
+	value = 0
+) => {
 	const input = parsed.body;
 
 	if (!input) {

@commitlint/rules/src/body-min-length.test.js → @commitlint/rules/src/body-min-length.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import check from './body-min-length';
+import {bodyMinLength} from './body-min-length';
 
 const short = 'a';
 const long = 'ab';
@@ -19,19 +19,19 @@ const parsed = {
 };
 
 test('with simple should succeed', async () => {
-	const [actual] = check(await parsed.simple, '', value);
+	const [actual] = bodyMinLength(await parsed.simple, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with short should fail', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = bodyMinLength(await parsed.short, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });
 
 test('with long should succeed', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = bodyMinLength(await parsed.long, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });

@commitlint/rules/src/body-min-length.js → @commitlint/rules/src/body-min-length.ts

@@ -1,6 +1,11 @@
 import {minLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const bodyMinLength: Rule<number> = (
+	parsed,
+	when = undefined,
+	value = 0
+) => {
 	if (!parsed.body) {
 		return [true];
 	}

@commitlint/rules/src/footer-empty.test.js → @commitlint/rules/src/footer-empty.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import footerEmpty from './footer-empty';
+import {footerEmpty} from './footer-empty';
 
 const messages = {
 	simple: 'test: subject',

@commitlint/rules/src/footer-empty.js → @commitlint/rules/src/footer-empty.ts

@@ -1,9 +1,10 @@
 import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when) => {
+export const footerEmpty: Rule = (parsed, when = 'always') => {
 	const negated = when === 'never';
-	const notEmpty = ensure.notEmpty(parsed.footer);
+	const notEmpty = ensure.notEmpty(parsed.footer || '');
 
 	return [
 		negated ? notEmpty : !notEmpty,

@commitlint/rules/src/footer-leading-blank.test.js → @commitlint/rules/src/footer-leading-blank.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import footerLeadingBlank from './footer-leading-blank';
+import {footerLeadingBlank} from './footer-leading-blank';
 
 const messages = {
 	simple: 'test: subject',

@commitlint/rules/src/footer-leading-blank.js → @commitlint/rules/src/footer-leading-blank.ts

@@ -1,15 +1,16 @@
 import toLines from '@commitlint/to-lines';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when) => {
+export const footerLeadingBlank: Rule = (parsed, when = 'always') => {
 	// Flunk if no footer is found
 	if (!parsed.footer) {
 		return [true];
 	}
 
 	const negated = when === 'never';
 	const rawLines = toLines(parsed.raw);
-	const bodyLines = toLines(parsed.body);
+	const bodyLines = parsed.body ? toLines(parsed.body) : [];
 	const bodyOffset = bodyLines.length > 0 ? rawLines.indexOf(bodyLines[0]) : 1;
 	const [leading] = rawLines.slice(bodyLines.length + bodyOffset);
 

@commitlint/rules/src/footer-max-length.test.js → @commitlint/rules/src/footer-max-length.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import check from './footer-max-length';
+import {footerMaxLength} from './footer-max-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
@@ -21,25 +21,25 @@ const parsed = {
 };
 
 test('with simple should succeed', async () => {
-	const [actual] = check(await parsed.simple, '', value);
+	const [actual] = footerMaxLength(await parsed.simple, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with empty should succeed', async () => {
-	const [actual] = check(await parsed.empty, '', value);
+	const [actual] = footerMaxLength(await parsed.empty, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with short should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = footerMaxLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = footerMaxLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });

@commitlint/rules/src/footer-max-length.js → @commitlint/rules/src/footer-max-length.ts

@@ -1,6 +1,11 @@
 import {maxLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const footerMaxLength: Rule<number> = (
+	parsed,
+	when = undefined,
+	value = 0
+) => {
 	const input = parsed.footer;
 
 	if (!input) {

@commitlint/rules/src/footer-max-line-length.test.js → @commitlint/rules/src/footer-max-line-length.test.ts

@@ -1,5 +1,5 @@
 import parse from '@commitlint/parse';
-import check from './footer-max-line-length';
+import {footerMaxLineLength} from './footer-max-line-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
@@ -23,37 +23,37 @@ const parsed = {
 };
 
 test('with simple should succeed', async () => {
-	const [actual] = check(await parsed.simple, '', value);
+	const [actual] = footerMaxLineLength(await parsed.simple, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with empty should succeed', async () => {
-	const [actual] = check(await parsed.empty, '', value);
+	const [actual] = footerMaxLineLength(await parsed.empty, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with short should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = footerMaxLineLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = footerMaxLineLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });
 
 test('with short with multiple lines should succeed', async () => {
-	const [actual] = check(await parsed.short, '', value);
+	const [actual] = footerMaxLineLength(await parsed.short, undefined, value);
 	const expected = true;
 	expect(actual).toEqual(expected);
 });
 
 test('with long with multiple lines should fail', async () => {
-	const [actual] = check(await parsed.long, '', value);
+	const [actual] = footerMaxLineLength(await parsed.long, undefined, value);
 	const expected = false;
 	expect(actual).toEqual(expected);
 });

@commitlint/rules/src/footer-max-line-length.js → @commitlint/rules/src/footer-max-line-length.ts

@@ -1,6 +1,11 @@
 import {maxLineLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+export const footerMaxLineLength: Rule<number> = (
+	parsed,
+	when = undefined,
+	value = 0
+) => {
 	const input = parsed.footer;
 
 	if (!input) {