Add capacitorjs runtime

node_modules/conventional-changelog-writer/index.js

@@ -0,0 +1,204 @@
+'use strict'
+
+const dateFormat = require('dateformat')
+const join = require('path').join
+const readFileSync = require('fs').readFileSync
+const semverValid = require('semver').valid
+const through = require('through2')
+const util = require('./lib/util')
+const _ = require('lodash')
+
+function conventionalChangelogWriterInit (context, options) {
+  context = _.extend({
+    commit: 'commits',
+    issue: 'issues',
+    date: dateFormat(new Date(), 'yyyy-mm-dd', true)
+  }, context)
+
+  if (!_.isBoolean(context.linkReferences) && (context.repository || context.repoUrl) && context.commit && context.issue) {
+    context.linkReferences = true
+  }
+
+  options = _.assign({
+    groupBy: 'type',
+    commitsSort: 'header',
+    noteGroupsSort: 'title',
+    notesSort: 'text',
+    generateOn: function (commit) {
+      return semverValid(commit.version)
+    },
+    finalizeContext: function (context) {
+      return context
+    },
+    debug: function () {},
+    reverse: false,
+    includeDetails: false,
+    ignoreReverted: true,
+    doFlush: true,
+    mainTemplate: readFileSync(join(__dirname, 'templates/template.hbs'), 'utf-8'),
+    headerPartial: readFileSync(join(__dirname, 'templates/header.hbs'), 'utf-8'),
+    commitPartial: readFileSync(join(__dirname, 'templates/commit.hbs'), 'utf-8'),
+    footerPartial: readFileSync(join(__dirname, 'templates/footer.hbs'), 'utf-8')
+  }, options)
+
+  if ((!_.isFunction(options.transform) && _.isObject(options.transform)) || _.isUndefined(options.transform)) {
+    options.transform = _.assign({
+      hash: function (hash) {
+        if (_.isString(hash)) {
+          return hash.substring(0, 7)
+        }
+      },
+      header: function (header) {
+        return header.substring(0, 100)
+      },
+      committerDate: function (date) {
+        if (!date) {
+          return
+        }
+
+        return dateFormat(date, 'yyyy-mm-dd', true)
+      }
+    }, options.transform)
+  }
+
+  let generateOn = options.generateOn
+  if (_.isString(generateOn)) {
+    generateOn = function (commit) {
+      return !_.isUndefined(commit[options.generateOn])
+    }
+  } else if (!_.isFunction(generateOn)) {
+    generateOn = function () {
+      return false
+    }
+  }
+
+  options.commitGroupsSort = util.functionify(options.commitGroupsSort)
+  options.commitsSort = util.functionify(options.commitsSort)
+  options.noteGroupsSort = util.functionify(options.noteGroupsSort)
+  options.notesSort = util.functionify(options.notesSort)
+
+  return { context, options, generateOn }
+}
+
+function conventionalChangelogWriterParseStream (context, options) {
+  let generateOn
+  ({ context, options, generateOn } = conventionalChangelogWriterInit(context, options))
+  let commits = []
+  let neverGenerated = true
+  let savedKeyCommit
+  let firstRelease = true
+  return through.obj(function (chunk, _enc, cb) {
+    try {
+      let result
+      const commit = util.processCommit(chunk, options.transform, context)
+      const keyCommit = commit || chunk
+
+      // previous blocks of logs
+      if (options.reverse) {
+        if (commit) {
+          commits.push(commit)
+        }
+
+        if (generateOn(keyCommit, commits, context, options)) {
+          neverGenerated = false
+          result = util.generate(options, commits, context, keyCommit)
+          if (options.includeDetails) {
+            this.push({
+              log: result,
+              keyCommit: keyCommit
+            })
+          } else {
+            this.push(result)
+          }
+
+          commits = []
+        }
+      } else {
+        if (generateOn(keyCommit, commits, context, options)) {
+          neverGenerated = false
+          result = util.generate(options, commits, context, savedKeyCommit)
+
+          if (!firstRelease || options.doFlush) {
+            if (options.includeDetails) {
+              this.push({
+                log: result,
+                keyCommit: savedKeyCommit
+              })
+            } else {
+              this.push(result)
+            }
+          }
+
+          firstRelease = false
+          commits = []
+          savedKeyCommit = keyCommit
+        }
+
+        if (commit) {
+          commits.push(commit)
+        }
+      }
+
+      cb()
+    } catch (err) {
+      cb(err)
+    }
+  }, function (cb) {
+    if (!options.doFlush && (options.reverse || neverGenerated)) {
+      cb(null)
+      return
+    }
+
+    try {
+      const result = util.generate(options, commits, context, savedKeyCommit)
+
+      if (options.includeDetails) {
+        this.push({
+          log: result,
+          keyCommit: savedKeyCommit
+        })
+      } else {
+        this.push(result)
+      }
+
+      cb()
+    } catch (err) {
+      cb(err)
+    }
+  })
+}
+
+/*
+ * Given an array of commits, returns a string representing a CHANGELOG entry.
+ */
+conventionalChangelogWriterParseStream.parseArray = (rawCommits, context, options) => {
+  let generateOn
+  rawCommits = [...rawCommits];
+  ({ context, options, generateOn } = conventionalChangelogWriterInit(context, options))
+  let commits = []
+  let savedKeyCommit
+  if (options.reverse) {
+    rawCommits.reverse()
+  }
+  const entries = []
+  for (const rawCommit of rawCommits) {
+    const commit = util.processCommit(rawCommit, options.transform, context)
+    const keyCommit = commit || rawCommit
+    if (generateOn(keyCommit, commits, context, options)) {
+      entries.push(util.generate(options, commits, context, savedKeyCommit))
+      savedKeyCommit = keyCommit
+      commits = []
+    }
+    if (commit) {
+      commits.push(commit)
+    }
+  }
+  if (options.reverse) {
+    entries.reverse()
+    return util.generate(options, commits, context, savedKeyCommit) + entries.join('')
+  } else {
+    return entries.join('') + util.generate(options, commits, context, savedKeyCommit)
+  }
+}
+
+module.exports = conventionalChangelogWriterParseStream