@alexlit/lint-kit 102.3.0 → 104.0.0

package/packages/config-commitlint/node_modules/conventional-commits-parser/cli.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict'
+const conventionalCommitsParser = require('./')
+const fs = require('fs')
+const { Transform } = require('stream')
+const isTextPath = require('is-text-path')
+const JSONStream = require('JSONStream')
+const meow = require('meow')
+const readline = require('readline')
+const split = require('split2')
+
+const filePaths = []
+let separator = '\n\n\n'
+
+const cli = meow(`
+    Practice writing commit messages or parse messages from files.
+    If used without specifying a text file path, you will enter an interactive shell.
+    Otherwise the commit messages in the files are parsed and printed
+    By default, commits will be split by three newlines ('\\n\\n\\n') or you can specify a separator.
+
+    Usage
+      conventional-commits-parser [<commit-separator>]
+      conventional-commits-parser [<commit-separator>] <path> [<path> ...]
+      cat <path> | conventional-commits-parser [<commit-separator>]
+
+    Example
+      conventional-commits-parser
+      conventional-commits-parser log.txt
+      cat log.txt | conventional-commits-parser
+      conventional-commits-parser log2.txt '===' >> parsed.txt
+
+    Options
+      -p, --header-pattern              Regex to match header pattern
+      -c, --header-correspondence       Comma separated parts used to define what capturing group of 'headerPattern' captures what
+      -r, --reference-actions           Comma separated keywords that used to reference issues
+      -i, --issue-prefixes              Comma separated prefixes of an issue
+      --issue-prefixes-case-sensitive   Treat issue prefixes as case sensitive
+      -n, --note-keywords               Comma separated keywords for important notes
+      -f, --field-pattern               Regex to match other fields
+      --revert-pattern                  Regex to match revert pattern
+      --revert-correspondence           Comma separated fields used to define what the commit reverts
+      -v, --verbose                     Verbose output
+`, {
+  flags: {
+    'header-pattern': {
+      alias: 'p',
+      type: 'string'
+    },
+    'header-correspondence': {
+      alias: 'c',
+      type: 'string'
+    },
+    'reference-actions': {
+      alias: 'r',
+      type: 'string'
+    },
+    'issue-prefixes': {
+      alias: 'i',
+      type: 'string'
+    },
+    'issue-prefixes-case-sensitive': {
+      type: 'boolean'
+    },
+    'note-keywords': {
+      alias: 'n',
+      type: 'string'
+    },
+    'field-pattern': {
+      alias: 'f',
+      type: 'string'
+    },
+    'revert-pattern': {
+      type: 'string'
+    },
+    'revert-correspondence': {
+      type: 'string'
+    },
+    verbose: {
+      alias: 'v',
+      type: 'boolean'
+    }
+  }
+})
+
+cli.input.forEach(function (arg) {
+  if (isTextPath(arg)) {
+    filePaths.push(arg)
+  } else {
+    separator = arg
+  }
+})
+
+const length = filePaths.length
+const options = cli.flags
+
+if (options.verbose) {
+  options.warn = console.log.bind(console)
+}
+
+function processFile (fileIndex) {
+  const filePath = filePaths[fileIndex]
+  fs.createReadStream(filePath)
+    .on('error', function (err) {
+      console.warn('Failed to read file ' + filePath + '\n' + err)
+      if (++fileIndex < length) {
+        processFile(fileIndex)
+      }
+    })
+    .pipe(split(separator))
+    .pipe(conventionalCommitsParser(options))
+    .pipe(JSONStream.stringify())
+    .on('end', function () {
+      if (++fileIndex < length) {
+        processFile(fileIndex)
+      }
+    })
+    .pipe(process.stdout)
+}
+
+if (process.stdin.isTTY) {
+  if (length > 0) {
+    processFile(0)
+  } else {
+    let commit = ''
+    const stream = new Transform({
+      transform: (chunk, enc, cb) => cb(null, chunk)
+    })
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    })
+
+    stream.pipe(conventionalCommitsParser(options))
+      .pipe(JSONStream.stringify('', '', ''))
+      .pipe(
+        new Transform({
+          transform (chunk, enc, cb) {
+            if (chunk.toString() === '""') {
+              cb(null, 'Commit cannot be parsed\n')
+            } else {
+              cb(null, chunk + '\n')
+            }
+          }
+        })
+      )
+      .pipe(process.stdout)
+
+    rl.on('line', function (line) {
+      commit += line + '\n'
+      if (commit.indexOf(separator) === -1) {
+        return
+      }
+
+      stream.write(commit)
+      commit = ''
+    })
+  }
+} else {
+  options.warn = true
+  process.stdin
+    .pipe(split(separator))
+    .pipe(conventionalCommitsParser(options))
+    .on('error', function (err) {
+      console.error(err.toString())
+      process.exit(1)
+    })
+    .pipe(JSONStream.stringify())
+    .pipe(process.stdout)
+}

package/packages/config-commitlint/node_modules/conventional-commits-parser/index.js

@@ -0,0 +1,105 @@
+'use strict'
+
+const { Transform } = require('stream')
+const parser = require('./lib/parser')
+const regex = require('./lib/regex')
+
+function assignOpts (options) {
+  options = {
+    headerPattern: /^(\w*)(?:\(([\w$.\-*/ ]*)\))?: (.*)$/,
+    headerCorrespondence: ['type', 'scope', 'subject'],
+    referenceActions: [
+      'close',
+      'closes',
+      'closed',
+      'fix',
+      'fixes',
+      'fixed',
+      'resolve',
+      'resolves',
+      'resolved'
+    ],
+    issuePrefixes: ['#'],
+    noteKeywords: ['BREAKING CHANGE', 'BREAKING-CHANGE'],
+    fieldPattern: /^-(.*?)-$/,
+    revertPattern: /^Revert\s"([\s\S]*)"\s*This reverts commit (\w*)\./,
+    revertCorrespondence: ['header', 'hash'],
+    warn: function () {},
+    mergePattern: null,
+    mergeCorrespondence: null,
+    ...options
+  }
+
+  if (typeof options.headerPattern === 'string') {
+    options.headerPattern = new RegExp(options.headerPattern)
+  }
+
+  if (typeof options.headerCorrespondence === 'string') {
+    options.headerCorrespondence = options.headerCorrespondence.split(',')
+  }
+
+  if (typeof options.referenceActions === 'string') {
+    options.referenceActions = options.referenceActions.split(',')
+  }
+
+  if (typeof options.issuePrefixes === 'string') {
+    options.issuePrefixes = options.issuePrefixes.split(',')
+  }
+
+  if (typeof options.noteKeywords === 'string') {
+    options.noteKeywords = options.noteKeywords.split(',')
+  }
+
+  if (typeof options.fieldPattern === 'string') {
+    options.fieldPattern = new RegExp(options.fieldPattern)
+  }
+
+  if (typeof options.revertPattern === 'string') {
+    options.revertPattern = new RegExp(options.revertPattern)
+  }
+
+  if (typeof options.revertCorrespondence === 'string') {
+    options.revertCorrespondence = options.revertCorrespondence.split(',')
+  }
+
+  if (typeof options.mergePattern === 'string') {
+    options.mergePattern = new RegExp(options.mergePattern)
+  }
+
+  return options
+}
+
+function conventionalCommitsParser (options) {
+  options = assignOpts(options)
+  const reg = regex(options)
+
+  return new Transform({
+    objectMode: true,
+    highWaterMark: 16,
+    transform (data, enc, cb) {
+      let commit
+
+      try {
+        commit = parser(data.toString(), options, reg)
+        cb(null, commit)
+      } catch (err) {
+        if (options.warn === true) {
+          cb(err)
+        } else {
+          options.warn(err.toString())
+          cb(null, '')
+        }
+      }
+    }
+  })
+}
+
+function sync (commit, options) {
+  options = assignOpts(options)
+  const reg = regex(options)
+
+  return parser(commit, options, reg)
+}
+
+module.exports = conventionalCommitsParser
+module.exports.sync = sync

package/packages/config-commitlint/node_modules/conventional-commits-parser/lib/parser.js

@@ -0,0 +1,316 @@
+'use strict'
+
+const CATCH_ALL = /()(.+)/gi
+const SCISSOR = '# ------------------------ >8 ------------------------'
+
+function trimOffNewlines (input) {
+  const result = input.match(/[^\r\n]/)
+  if (!result) {
+    return ''
+  }
+  const firstIndex = result.index
+  let lastIndex = input.length - 1
+  while (input[lastIndex] === '\r' || input[lastIndex] === '\n') {
+    lastIndex--
+  }
+  return input.substring(firstIndex, lastIndex + 1)
+}
+
+function append (src, line) {
+  if (src) {
+    src += '\n' + line
+  } else {
+    src = line
+  }
+
+  return src
+}
+
+function getCommentFilter (char) {
+  return function (line) {
+    return line.charAt(0) !== char
+  }
+}
+
+function truncateToScissor (lines) {
+  const scissorIndex = lines.indexOf(SCISSOR)
+
+  if (scissorIndex === -1) {
+    return lines
+  }
+
+  return lines.slice(0, scissorIndex)
+}
+
+function getReferences (input, regex) {
+  const references = []
+  let referenceSentences
+  let referenceMatch
+
+  const reApplicable = input.match(regex.references) !== null
+    ? regex.references
+    : CATCH_ALL
+
+  while ((referenceSentences = reApplicable.exec(input))) {
+    const action = referenceSentences[1] || null
+    const sentence = referenceSentences[2]
+
+    while ((referenceMatch = regex.referenceParts.exec(sentence))) {
+      let owner = null
+      let repository = referenceMatch[1] || ''
+      const ownerRepo = repository.split('/')
+
+      if (ownerRepo.length > 1) {
+        owner = ownerRepo.shift()
+        repository = ownerRepo.join('/')
+      }
+
+      const reference = {
+        action: action,
+        owner: owner,
+        repository: repository || null,
+        issue: referenceMatch[3],
+        raw: referenceMatch[0],
+        prefix: referenceMatch[2]
+      }
+
+      references.push(reference)
+    }
+  }
+
+  return references
+}
+
+function passTrough () {
+  return true
+}
+
+function parser (raw, options, regex) {
+  if (!raw || !raw.trim()) {
+    throw new TypeError('Expected a raw commit')
+  }
+
+  if (!options || (typeof options === 'object' && !Object.keys(options).length)) {
+    throw new TypeError('Expected options')
+  }
+
+  if (!regex) {
+    throw new TypeError('Expected regex')
+  }
+
+  let currentProcessedField
+  let mentionsMatch
+  const otherFields = {}
+  const commentFilter = typeof options.commentChar === 'string'
+    ? getCommentFilter(options.commentChar)
+    : passTrough
+  const gpgFilter = line => !line.match(/^\s*gpg:/)
+
+  const rawLines = trimOffNewlines(raw).split(/\r?\n/)
+  const lines = truncateToScissor(rawLines).filter(commentFilter).filter(gpgFilter)
+
+  let continueNote = false
+  let isBody = true
+  const headerCorrespondence = options.headerCorrespondence?.map(function (part) {
+    return part.trim()
+  }) || []
+  const revertCorrespondence = options.revertCorrespondence?.map(function (field) {
+    return field.trim()
+  }) || []
+  const mergeCorrespondence = options.mergeCorrespondence?.map(function (field) {
+    return field.trim()
+  }) || []
+
+  let body = null
+  let footer = null
+  let header = null
+  const mentions = []
+  let merge = null
+  const notes = []
+  const references = []
+  let revert = null
+
+  if (lines.length === 0) {
+    return {
+      body: body,
+      footer: footer,
+      header: header,
+      mentions: mentions,
+      merge: merge,
+      notes: notes,
+      references: references,
+      revert: revert,
+      scope: null,
+      subject: null,
+      type: null
+    }
+  }
+
+  // msg parts
+  merge = lines.shift()
+  const mergeParts = {}
+  const headerParts = {}
+  body = ''
+  footer = ''
+
+  const mergeMatch = merge.match(options.mergePattern)
+  if (mergeMatch && options.mergePattern) {
+    merge = mergeMatch[0]
+
+    header = lines.shift()
+    while (header !== undefined && !header.trim()) {
+      header = lines.shift()
+    }
+    if (!header) {
+      header = ''
+    }
+
+    mergeCorrespondence.forEach(function (partName, index) {
+      const partValue = mergeMatch[index + 1] || null
+      mergeParts[partName] = partValue
+    })
+  } else {
+    header = merge
+    merge = null
+
+    mergeCorrespondence.forEach(function (partName) {
+      mergeParts[partName] = null
+    })
+  }
+
+  const headerMatch = header.match(options.headerPattern)
+  if (headerMatch) {
+    headerCorrespondence.forEach(function (partName, index) {
+      const partValue = headerMatch[index + 1] || null
+      headerParts[partName] = partValue
+    })
+  } else {
+    headerCorrespondence.forEach(function (partName) {
+      headerParts[partName] = null
+    })
+  }
+
+  references.push(...getReferences(header, {
+    references: regex.references,
+    referenceParts: regex.referenceParts
+  }))
+
+  // body or footer
+  lines.forEach(function (line) {
+    if (options.fieldPattern) {
+      const fieldMatch = options.fieldPattern.exec(line)
+
+      if (fieldMatch) {
+        currentProcessedField = fieldMatch[1]
+
+        return
+      }
+
+      if (currentProcessedField) {
+        otherFields[currentProcessedField] = append(otherFields[currentProcessedField], line)
+
+        return
+      }
+    }
+
+    let referenceMatched
+
+    // this is a new important note
+    const notesMatch = line.match(regex.notes)
+    if (notesMatch) {
+      continueNote = true
+      isBody = false
+      footer = append(footer, line)
+
+      const note = {
+        title: notesMatch[1],
+        text: notesMatch[2]
+      }
+
+      notes.push(note)
+
+      return
+    }
+
+    const lineReferences = getReferences(line, {
+      references: regex.references,
+      referenceParts: regex.referenceParts
+    })
+
+    if (lineReferences.length > 0) {
+      isBody = false
+      referenceMatched = true
+      continueNote = false
+    }
+
+    Array.prototype.push.apply(references, lineReferences)
+
+    if (referenceMatched) {
+      footer = append(footer, line)
+
+      return
+    }
+
+    if (continueNote) {
+      notes[notes.length - 1].text = append(notes[notes.length - 1].text, line)
+      footer = append(footer, line)
+
+      return
+    }
+
+    if (isBody) {
+      body = append(body, line)
+    } else {
+      footer = append(footer, line)
+    }
+  })
+
+  if (options.breakingHeaderPattern && notes.length === 0) {
+    const breakingHeader = header.match(options.breakingHeaderPattern)
+    if (breakingHeader) {
+      const noteText = breakingHeader[3] // the description of the change.
+      notes.push({
+        title: 'BREAKING CHANGE',
+        text: noteText
+      })
+    }
+  }
+
+  while ((mentionsMatch = regex.mentions.exec(raw))) {
+    mentions.push(mentionsMatch[1])
+  }
+
+  // does this commit revert any other commit?
+  const revertMatch = raw.match(options.revertPattern)
+  if (revertMatch) {
+    revert = {}
+    revertCorrespondence.forEach(function (partName, index) {
+      const partValue = revertMatch[index + 1] || null
+      revert[partName] = partValue
+    })
+  } else {
+    revert = null
+  }
+
+  notes.forEach(function (note) {
+    note.text = trimOffNewlines(note.text)
+  })
+
+  const msg = {
+    ...headerParts,
+    ...mergeParts,
+    merge: merge,
+    header: header,
+    body: body ? trimOffNewlines(body) : null,
+    footer: footer ? trimOffNewlines(footer) : null,
+    notes: notes,
+    references: references,
+    mentions: mentions,
+    revert: revert,
+    ...otherFields
+  }
+
+  return msg
+}
+
+module.exports = parser

package/packages/config-commitlint/node_modules/conventional-commits-parser/lib/regex.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const reNomatch = /(?!.*)/
+
+function join (array, joiner) {
+  return array
+    .map(function (val) {
+      return val.trim()
+    })
+    .filter(function (val) {
+      return val.length
+    })
+    .join(joiner)
+}
+
+function getNotesRegex (noteKeywords, notesPattern) {
+  if (!noteKeywords) {
+    return reNomatch
+  }
+
+  const noteKeywordsSelection = join(noteKeywords, '|')
+
+  if (!notesPattern) {
+    return new RegExp('^[\\s|*]*(' + noteKeywordsSelection + ')[:\\s]+(.*)', 'i')
+  }
+
+  return notesPattern(noteKeywordsSelection)
+}
+
+function getReferencePartsRegex (issuePrefixes, issuePrefixesCaseSensitive) {
+  if (!issuePrefixes) {
+    return reNomatch
+  }
+
+  const flags = issuePrefixesCaseSensitive ? 'g' : 'gi'
+  return new RegExp('(?:.*?)??\\s*([\\w-\\.\\/]*?)??(' + join(issuePrefixes, '|') + ')([\\w-]*\\d+)', flags)
+}
+
+function getReferencesRegex (referenceActions) {
+  if (!referenceActions) {
+    // matches everything
+    return /()(.+)/gi
+  }
+
+  const joinedKeywords = join(referenceActions, '|')
+  return new RegExp('(' + joinedKeywords + ')(?:\\s+(.*?))(?=(?:' + joinedKeywords + ')|$)', 'gi')
+}
+
+module.exports = function (options) {
+  options = options || {}
+  const reNotes = getNotesRegex(options.noteKeywords, options.notesPattern)
+  const reReferenceParts = getReferencePartsRegex(options.issuePrefixes, options.issuePrefixesCaseSensitive)
+  const reReferences = getReferencesRegex(options.referenceActions)
+
+  return {
+    notes: reNotes,
+    referenceParts: reReferenceParts,
+    references: reReferences,
+    mentions: /@([\w-]+)/g
+  }
+}

package/packages/config-commitlint/node_modules/conventional-commits-parser/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "conventional-commits-parser",
+  "version": "4.0.0",
+  "description": "Parse raw conventional commits",
+  "bugs": {
+    "url": "https://github.com/conventional-changelog/conventional-changelog/issues"
+  },
+  "homepage": "https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-commits-parser#readme",
+  "author": {
+    "name": "Steve Mao",
+    "email": "maochenyan@gmail.com",
+    "url": "https://github.com/stevemao"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/conventional-changelog/conventional-changelog.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "index.js",
+    "cli.js",
+    "lib"
+  ],
+  "keywords": [
+    "conventional-commits-parser",
+    "changelog",
+    "conventional",
+    "parser",
+    "parsing",
+    "logs"
+  ],
+  "dependencies": {
+    "JSONStream": "^1.3.5",
+    "is-text-path": "^1.0.1",
+    "meow": "^8.1.2",
+    "split2": "^3.2.2"
+  },
+  "bin": {
+    "conventional-commits-parser": "cli.js"
+  },
+  "devDependencies": {
+    "forceable-tty": "^0.1.0"
+  },
+  "scripts": {
+    "test-windows": "echo 'make work on windows'"
+  }
+}