API

npm install --save @commitlint/format

type Problem = {
  /*
   * Уровень проблемы подсказка | предупреждение | ошибка
   */
  level: 0 | 1 | 2;
  /*
   * Название проблемы для аннотации сообщения
   */
  name: string;
  /*
   * Сообщение для вывода
   */
  message: string;
}

type Report = {
  results: ReportResult[];
}

type ReportResult = {
  errors: Problem[];
  warnings: Problem[];
}

type formatOptions = {
  /**
   * Окрашивать вывод
   **/
  color: boolean = true;

  /**
   * Символы для использования в качестве декорации для сообщений с уровнем серьезности 0, 1, 2
   **/
  signs: readonly [string; string; string] = [' ', '⚠', '✖'];

  /**
   * Цвета для использования в сообщениях с уровнем серьезности 0, 1, 2
   **/
  colors: readonly [string; string; string] = ['white', 'yellow', 'red'];

  /**
   * Выводить сводку и входные данные для отчетов без проблем
   **/
  verbose: boolean = false;

  /**
   * URL для вывода в качестве помощи для отчетов с проблемами
   **/
  helpUrl: string;
}

format(report?: Report = {}, options?: formatOptions = {}) => string[];

const format = require('@commitlint/format');

format(); // => [ '\u001b[1m\u001b[32m✔\u001b[39m   найдено 0 проблем, 0 предупреждений\u001b[22m' ]

format(
  {
    results: [
      {
        warnings: [
          {
            level: 0,
            name: 'some-hint',
            message: 'Это не будет отображаться, так как уровень 0'
          },
          {
            level: 1,
            name: 'some-warning',
            message: 'Это будет отображаться желтым, так как уровень 1'
          }
        ],
        errors: [
          {
            level: 2,
            name: 'some-error',
            message: 'Это будет отображаться красным, так как уровень 2'
          }
        ]
      }
    ]
  },
  {
    color: false
  }
);
/* => [
  '✖   Это будет отображаться красным, так как уровень 2 [some-error]',
  '    Это не будет отображаться, так как уровень 0 [some-hint]',
  '⚠   Это будет отображаться желтым, так как уровень 1 [some-warning]',
  '✖   найдено 1 проблема, 2 предупреждения'
] */

npm install --save @commitlint/load

/**
 * Как обрабатывать нарушение правила
 * 0 - игнорировать
 * 1 - предупреждать
 * 2 - выбрасывать исключение
 */
type RuleLevel = 0 | 1 | 2;

/*
 * Применение правила
 * always - положительное
 * never - отрицательное
 */
type RuleCondition = 'always' | 'never';

/*
 * Дополнительные, необязательные параметры для передачи правилу
 */
type RuleOption = any;

/**
 * Базовое полное определение правила
 */
type PrimitiveRule = [RuleLevel, RuleCondition, RuleOption?];

/*
 * Асинхронные правила разрешаются во время поиска конфигурации.
 * Они могут использоваться для настройки правил линтера на основе, например, файловой системы проекта
 */
type AsyncRule = Promise<PrimitiveRule>;

/*
 * Функциональные правила выполняются во время поиска конфигурации.
 * Они могут использоваться для настройки правил линтера на основе, например, файловой системы проекта
 */
type FunctionRule = () => PrimitiveRule;

/*
 * Асинхронные функциональные правила выполняются и ожидают завершения во время поиска конфигурации.
 * Они могут использоваться для настройки правил линтера на основе, например, файловой системы проекта
 */
type AsyncFunctionRule () => Promise<PrimitiveRule>;

/*
 * Полиморфная структура правила
 */
type Rule = PrimitiveRule | FunctionRule | AsyncFunctionRule;

/*
 * Предустановка парсера для конвенциональных коммитов
 */
type ParserPreset = {
  name: string;
  path: string;
  opts: any;
};

type Seed = {
  /*
   * Идентификаторы, разрешаемые из текущей рабочей директории или файла конфигурации.
   * Импортируются и объединяются в конфигурацию с увеличивающейся приоритетностью, с верхним уровнем конфигурации имеющим наивысший приоритет.
   */
  extends?: string[];
  /*
   * Идентификатор, разрешаемый из текущей рабочей директории или файла конфигурации.
   * Импортируется и расширяется до {ParserPreset}.
   * Предустановки парсера верхнего уровня переопределяют предустановки в расширенной конфигурации.
   */
  parserPreset?: string;
  /**
   * Начальная карта правил для проверки
   */
  rules?: {[ruleName: string]: Rule};
};

type Config = {
  /*
   * Относительные пути ко всем расширенным конфигурациям.
   */
  extends: string[];
  /*
   * Расширенная предустановка парсера, если таковая имеется
   */
  parserPreset?: ParserPreset;
  /*
   * Объединенная карта правил для проверки
   */
  rules: {[ruleName: string]: Rule};
};

type LoadOptions = {
  /*
   * Путь к файлу конфигурации для загрузки.
   */
  file?: string;
  /*
   * Текущая рабочая директория для использования при загрузке конфигурации из файла.
   */
  cwd: string;
};

load(seed: Seed = {}, options?: LoadOptions = {cwd: process.cwd()}) => Promise<Config>;

const load = require('@commitlint/load');

load({
  rules: {
    'body-leading-blank': [2, 'always']
  }
}).then(config => console.log(config));
// => { extends: [], rules: { 'body-leading-blank': [ 2, 'always' ] } }

load({extends: ['./package']}).then(config => console.log(config));
// => { extends: ['./package', './package-b'], rules: {} }

load({parserPreset: './parser-preset.js'}).then(config => console.log(config));
// => { extends: [], rules: {}, parserPreset: {name: './parser-preset.js', path: './parser-preset.js', opts: {}}}

load({}, {file: '.commitlintrc.yml', cwd: process.cwd()}).then(config =>
  console.log(config)
);
// => { extends: [], rules: { 'body-leading-blank': [ 1, 'always' ] }, formatter: '@commitlint/format', plugins: {} }

npm install --save @commitlint/read

type Range = {
  /* Нижняя граница диапазона коммитов для чтения */
  from: string;
  /* Верхняя граница диапазона коммитов для чтения */
  to: string;
  /* Читать ли из ./.git/COMMIT_EDITMSG (логическое значение) или откуда читать (строка) */
  edit?: boolean | string;
};

read(range: Range) => Promise<string[]>

// git commit -m "I did something"
const read = require('@commitlint/read');

read({edit: true}).then(messages => console.log(messages));
// => ['I did something\n\n']

read({edit: './git/GITGUI_EDITMESSAGE'}).then(messages =>
  console.log(messages)
);
// => ['I did something via git gui\n\n']

read({from: 'HEAD~2'}).then(messages => console.log(messages));
// => ['I did something\n\n', 'Initial commit\n\n']

read({from: 'HEAD~2', to: 'HEAD~1'}).then(messages => console.log(messages));
// => ['Initial commit\n\n']

npm install --save @commitlint/lint

type RuleLevel = 0 | 1 | 2;
type RuleCondition = 'always' | 'never';
type RuleOption = any;
type PrimitiveRule = [RuleLevel, RuleCondition, RuleOption?];
type AsyncRule = Promise<PrimitiveRule>;
type FunctionRule = () => PrimitiveRule;
type AsyncFunctionRule () => Promise<PrimitiveRule>;
type Rule = PrimitiveRule | FunctionRule | AsyncFunctionRule;

type Problem = {
  level: number;
  valid: boolean;
  name: string;
  message: string;
}

type Report = {
  valid: boolean;
  errors: Problem[];
  warnings: Problem[];
}

type Options = {
  parserOpts?: any;
};

lint(message: string, rules: {[ruleName: string]: Rule}, opts?: Options) => Promise<Report>;

const lint = require('@commitlint/lint');

lint('foo: bar').then(report => console.log(report));
// => { valid: true, errors: [], warnings: [] }

lint('foo: bar', {'type-enum': [1, 'always', ['foo']]}).then(report =>
  console.log(report)
);
// => { valid: true, errors: [], warnings: [] }

lint('foo: bar', {'type-enum': [1, 'always', ['bar']]}).then(report =>
  console.log(report)
);
/* =>
    { valid: true,
      errors: [],
      warnings:
      [ { level: 1,
          valid: false,
          name: 'type-enum',
          message: 'тип должен быть одним из [bar]' } ] }
  */

const opts = {
  parserOpts: {
    headerPattern: /^(\w*)-(\w*)/,
    headerCorrespondence: ['type', 'scope']
  }
};

lint('foo-bar', {'type-enum': [2, 'always', ['foo']]}, opts).then(report =>
  console.log(report)
);
// => { valid: true, errors: [], warnings: [] }

const load = require('@commitlint/load');
const lint = require('@commitlint/lint');

const CONFIG = {
  extends: ['@commitlint/config-conventional']
};

load(CONFIG)
  .then(opts =>
    lint(
      'foo: bar',
      opts.rules,
      opts.parserPreset ? {parserOpts: opts.parserPreset.parserOpts} : {}
    )
  )
  .then(report => console.log(report));
/* =>
    { valid: false,
      errors:
      [ { level: 2,
          valid: false,
          name: 'type-enum',
          message: 'тип должен быть одним из [build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test]' } ],
      warnings: [] }
    */

const lint = require('@commitlint/lint');
const read = require('@commitlint/read');

const RULES = {
  'type-enum': [2, 'always', ['foo']]
};

const check = commit => lint(commit, RULES);

read({to: 'HEAD', from: 'HEAD~2'}).then(commits =>
  Promise.all(commits.map(check))
);

const load = require('@commitlint/load');
const read = require('@commitlint/read');
const lint = require('@commitlint/lint');

Promise.all([load(), read({from: 'HEAD~1'})])
  .then(tasks => {
    const [{rules, parserPreset}, [commit]] = tasks;
    return lint(
      commit,
      rules,
      parserPreset ? {parserOpts: parserPreset.parserOpts} : {}
    );
  })
  .then(report => console.log(JSON.stringify(result.valid)));