markdown-magic 2.6.1 → 3.0.0

package/{cli-utils.js → lib/utils/load-config.js}

@@ -1,11 +1,7 @@
-const resolve = require('path').resolve
+const path = require('path')
 
 const loadJSConfig = getAttemptModuleRequireFn(function onFail(configPath, requirePath) {
   console.log(`Unable to find JS config at "${configPath}". Attempted to require as "${requirePath}"`)
-  // log.error({
-  //   message: colors.red(`Unable to find JS config at "${configPath}". Attempted to require as "${requirePath}"`),
-  //   ref: 'unable-to-find-config',
-  // })
   return undefined
 })
 
@@ -15,7 +11,7 @@ const loadJSConfig = getAttemptModuleRequireFn(function onFail(configPath, requi
  * @return {String} the module path to require
  */
 function getModuleRequirePath(moduleName) {
-  return moduleName[0] === '.' ? resolve(process.cwd(), moduleName) : moduleName
+  return moduleName[0] === '.' ? path.resolve(process.cwd(), moduleName) : moduleName
 }
 
 function getAttemptModuleRequireFn(onFail) {

package/lib/utils/logs.js

@@ -0,0 +1,89 @@
+const util = require('util')
+const ansi = require('ansi-styles') // https://github.com/chalk/ansi-styles/blob/main/index.js
+const process = require('process')
+
+// via https://github.com/sindresorhus/is-unicode-supported/blob/main/index.js
+function isUnicodeSupported() {
+  if (process.platform !== 'win32') return process.env.TERM !== 'linux' // Linux console (kernel)
+  return Boolean(process.env.CI)
+    || Boolean(process.env.WT_SESSION) // Windows Terminal
+    || process.env.ConEmuTask === '{cmd::Cmder}' // ConEmu and cmder
+    || process.env.TERM_PROGRAM === 'vscode' || process.env.TERM === 'xterm-256color' || process.env.TERM === 'alacritty'
+}
+
+const isObject = (obj) => obj !== null && typeof obj === 'object'
+function neverNull(obj) {
+  const match = (some, none = () => {}) => (obj !== null) ? some(obj) : none()
+  return new Proxy((some, none) => {
+    if (some) return some === 'string' ? '' : some
+    if (!some && !none) return obj
+    return match(some, none)
+  },
+  {
+    get: (target, key) => {
+      const obj = target()
+      if (isObject(obj)) return neverNull(obj[key])
+      return neverNull()
+    },
+    set: (target, key, val) => {
+      const obj = target()
+      if (isObject(obj)) obj[key] = val
+      return true
+    },
+  })
+}
+
+function safeColors(disableColors) {
+  return (disableColors) ? neverNull(ansi) : ansi
+}
+
+const allowed = isUnicodeSupported()
+const styles = safeColors(process.env.DISABLE_COLOR)
+const SPACES = '  '
+const SUCCESS = allowed ? '✔' : '√'
+const INFO = allowed ? 'ℹ' : 'i'
+const WARNING = allowed ? '⚠' : '‼'
+const ERROR = allowed ? '✖' : '×'
+
+const colors = {
+  default: ['white', ''],
+  success: ['greenBright', `${SUCCESS}${SPACES}`],
+  info: ['cyanBright', `${INFO}${SPACES}`],
+  warning: ['yellowBright', `${WARNING}${SPACES}`],
+  error: ['redBright', `${ERROR}${SPACES}`]
+}
+
+function log(type, msg, customPrefix, noLog) {
+  const [color, prefix] = colors[type] || colors.default
+  const finalPrefix = typeof customPrefix !== 'undefined' ? customPrefix : prefix
+  const logMsg = `${styles[color].open}${finalPrefix}${msg}${styles[color].close}`
+  if (noLog) return logMsg
+  console.log(logMsg)
+}
+
+function deepLog(myObject) {
+  console.log(util.inspect(myObject, false, null, true /* enable colors */))
+}
+
+const success = log.bind(null, 'success')
+const info = log.bind(null, 'info')
+const warning = log.bind(null, 'warning')
+const error = log.bind(null, 'error')
+
+/*
+// Usage:
+console.log('Nice logs')
+deepLog({ deep: {object }})
+success('Success! Yay it worked')
+info('Info: Additional details here')
+warning('Warning: Watch out')
+error('Error: Oh no!')
+/**/
+
+module.exports = {
+  deepLog,
+  success,
+  info,
+  warning,
+  error,
+}

package/lib/utils/md/filters.js

@@ -0,0 +1,20 @@
+
+const RELATIVE_LINK_REGEX = /^(?!(?:(?:https?|ftp):\/\/|data:))((?:\.\.?\/)*)*([\w\d\-_./?=#%:+&]+)/
+
+function onlyUnique(value, index, self) {
+  return self.indexOf(value) === index;
+}
+
+function isImage(link) {
+  return link.match(/(png|jpe?g|gif|webp|svg)$/)
+}
+
+function isRelative(filepath) {
+  return RELATIVE_LINK_REGEX.test(filepath)
+}
+
+module.exports = {
+  onlyUnique,
+  isImage,
+  isRelative
+}

package/lib/utils/md/find-code-blocks.js

@@ -0,0 +1,80 @@
+const { getLineCount, getLineNumberFromMatch } = require('./utils')
+
+// https://regex101.com/r/nIlW1U/6
+const CODE_BLOCK_REGEX = /^([A-Za-z \t]*)```([A-Za-z]*)?\n([\s\S]*?)```([A-Za-z \t]*)*$/gm
+// https://regex101.com/r/oPKKoC/1
+const REMOVE_CODE_BLOCK_REGEX = /^(?:[A-Za-z \t]*)?(```(?:[A-Za-z]*)?\n(?:[\s\S]*?)```)([A-Za-z \t]*)*$/gm
+
+/**
+ * Parse code blocks out of markdown
+ * @param {string} block 
+ * @returns {Object}
+ * @example
+ * const { blocks, errors } = findCodeBlocks(content)
+ * console.log('blocks', blocks)
+ * console.log('errors', errors)
+ */
+function findCodeBlocks(block, filePath = '') {
+  let matches
+  let errors = []
+  let blocks = []
+  const msg = (filePath) ? ` in ${filePath}` : ''
+  while ((matches = CODE_BLOCK_REGEX.exec(block)) !== null) {
+    if (matches.index === CODE_BLOCK_REGEX.lastIndex) {
+      CODE_BLOCK_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
+    }
+    const [ match, prefix, syntax, content, postFix ] = matches
+    const lineNumber = getLineNumberFromMatch(block, matches)
+    let hasError = false
+    /* // debug
+    console.log(`prefix: "${prefix}"`)
+    console.log(`postFix: "${postFix}"`)
+    console.log('syntax:', lang)
+    console.log('Content:')
+    console.log(content.trim())
+    console.log('───────────────────────')
+    /** */
+
+    /* Validate code blocks */
+    if (prefix && prefix.match(/\S/)) {
+      hasError = true
+      errors.push({
+        line: lineNumber,
+        index: matches.index,
+        message: `Prefix "${prefix}" not allowed on line ${lineNumber}. Fix the code block${msg}.`,
+        block: match
+      })
+    }
+    if (postFix && postFix.match(/\S/)) {
+      hasError = true
+      const line = lineNumber + (getLineCount(match) - 1)
+      errors.push({
+        line,
+        index: matches.index + match.length,
+        message: `Postfix "${postFix}" not allowed on line ${line}. Fix the code block${msg}.`,
+        block: match
+      })
+    }
+
+    if (!hasError) {
+      blocks.push({
+        line: lineNumber,
+        index: matches.index,
+        syntax: syntax || '',
+        block: match,
+        code: content.trim()
+      })
+    }
+  }
+
+  return {
+    errors,
+    blocks
+  }
+}
+
+module.exports = {
+  findCodeBlocks,
+  CODE_BLOCK_REGEX,
+  REMOVE_CODE_BLOCK_REGEX
+}

package/lib/utils/md/find-date.js

@@ -0,0 +1,32 @@
+const DATE_FORMAT_REGEX = /(([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]))-?/g
+
+function findDate({
+  frontmatter = {},
+  dateKey = 'date',
+  filePath
+}) {
+  let date = frontmatter[dateKey]
+  if (!date && filePath) {
+    const dateFromFile = filePath.match(DATE_FORMAT_REGEX)
+    if (dateFromFile) {
+      date = dateFromFile[0].replace(/-$/, '')
+    }
+  }
+  return convertDateToString(date)
+}
+
+function convertDateToString(dateValue) {
+  let date = dateValue
+  if (typeof dateValue === 'string') {
+    date = dateValue
+  } else if (dateValue instanceof Date) {
+    var newDate = new Date(dateValue.toString())
+    date = newDate.toISOString().substring(0, 10)
+  }
+  return date
+}
+
+module.exports = {
+  findDate,
+  convertDateToString
+}

package/lib/utils/md/find-frontmatter.js

@@ -0,0 +1,94 @@
+const matter = require('gray-matter')
+/* Match <!-- frontmatter --> */
+// https://regex101.com/r/Q9bBxC/1
+const HIDDEN_FRONTMATTER_REGEX = /^<!--+(?:\r\n|\r|\n)([\w\W]*?)--+>/g
+// const HIDDEN_FRONTMATTER_REGEX = /^<!--.*((.|\r?\n)*?.*-->)/g
+
+/* Match --- frontmatter --- */
+// https://regex101.com/r/d7eAw4/1
+const FRONTMATTER_REGEX = /(^--+(?:\r\n|\r|\n)([\w\W]*?)--+)/
+// const FRONTMATTER_REGEX = /^---.*((.|\r?\n)*?.*---)/gm
+
+function removeConflictingContent(str) {
+  return str
+    .replace(/[\t ]{1}---/g, '__LINE_BREAK__')
+    .replace(/[\t ]--+>/g, '__CLOSE_COMMENT__')
+    // TODO also handle nested <!-- comments -->
+}
+
+function replaceConflictingContent(str) {
+  return str
+    .replace(/__LINE_BREAK__/g, ' ---')
+    .replace(/__CLOSE_COMMENT__/g, ' -->')
+}
+
+function findFrontmatterRaw(content = '') {
+  const text = removeConflictingContent(content.trim())
+  const hasFrontMatter = text.match(FRONTMATTER_REGEX)
+  const hasHiddenFrontMatter = text.match(HIDDEN_FRONTMATTER_REGEX)
+  let raw = ''
+  let match = ''
+  let isHidden = false
+  // console.log('hasFrontMatter', hasFrontMatter)
+  // console.log('hasHiddenFrontMatter', hasHiddenFrontMatter)
+  if (hasFrontMatter) {
+    raw = hasFrontMatter[1]
+    match = raw.trim()
+      // Fix Leading frontmatter brackets
+      .replace(/^---+/, '---')
+      // Trailing frontmatter brackets
+      .replace(/--+$/, `---`)
+  } else if (hasHiddenFrontMatter) {
+    isHidden = true
+    raw = hasHiddenFrontMatter[1]
+    match = raw.trim()
+      // Leading frontmatter brackets
+      .replace(/<!--+/, '---')
+      // Trailing frontmatter brackets
+      .replace(/--+>/, `---`)
+  }
+  return {
+    rawFrontMatter: replaceConflictingContent(raw),
+    frontMatter: replaceConflictingContent(match),
+    isHidden
+  }
+}
+
+function findFrontmatter(text) {
+  const { frontMatter, rawFrontMatter } = findFrontmatterRaw(text)
+  // console.log('frontMatter', frontMatter)
+  let frontmatter = { data: {}, content: '' }
+  /* Missing all frontmatter */
+  if (!frontMatter) {
+    // throw new Error(`Missing or broken frontmatter in ${filePath}. Double check file for --- frontmatter tags in files`)
+    return frontmatter
+  }
+
+  let mdContent = text
+  if (rawFrontMatter) {
+    mdContent = text
+    // Replace frontmatter brackets
+    .replace(rawFrontMatter, frontMatter)
+    // Replace leading lines
+    // .replace(/---+\s+\n/g, '---\n')
+  }
+
+  try {
+    frontmatter = matter(mdContent)
+  } catch (err) {
+    /* Add line numbers to output */
+    const formattedError = rawFrontMatter.split('\n').map((line, i) => {
+      return `${i + 1}. ${line}`
+    })
+    throw new Error(`Frontmatter error:\n${err.message}\n${formattedError.join('\n')}`)
+  }
+  // console.log('frontMatter', frontmatter)
+  return Object.assign(frontmatter, { rawFrontMatter })
+}
+
+module.exports = {
+  findFrontmatter,
+  findFrontmatterRaw,
+  HIDDEN_FRONTMATTER_REGEX,
+  FRONTMATTER_REGEX
+}

package/lib/utils/md/find-frontmatter.test.js

@@ -0,0 +1,17 @@
+const path = require('path')
+const fs = require('fs')
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { findLinks } = require('./find-links')
+const { findFrontmatter } = require('./find-frontmatter')
+
+const FILE_PATH = path.join(__dirname, 'fixtures/file-with-frontmatter.md')
+const fileWithLinks = fs.readFileSync(FILE_PATH, 'utf-8')
+
+test('Find frontmatter', async () => {
+  const frontmatter = findFrontmatter(fileWithLinks, FILE_PATH)
+  console.log('frontmatter', frontmatter)
+  assert.is(typeof frontmatter.data, 'object')
+})
+
+test.run()

package/lib/utils/md/find-html-tags.js

@@ -0,0 +1,105 @@
+
+// Might need ([\s\S]*?) instead of '*' in between tags
+const HTML_TAG = /<([a-zA-Z1-6]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)/gim
+
+const MATCH_HTML_TAGS_REGEX = /<([a-zA-Z1-6]+)\b([^>]*)>*(?:>([\s\S]*?)<\/\1>|\s?\/?>)/gm
+// old forces closes / - /<([a-zA-Z1-6]+)\b([^>]*)>*(?:>([\s\S]*?)<\/\1>|\s?\/>)/gm
+
+function findHtmlTags(mdContents) {
+  const parents = mdContents
+    /* Fix non terminating <tags> */
+    .replace(/(['"`]<(.*)>['"`])/gm, '_$2_')
+    .match(MATCH_HTML_TAGS_REGEX)
+  // console.log('parents', parents)
+
+  if (parents) {
+    // const children = parents.filter(Boolean).map((p) => {
+    //   return p.match(HTML_TAG)
+    // })
+    // console.log('children', children)
+  }
+
+  const htmlTags = mdContents
+    /* Fix non terminating <tags> */
+    .replace(/(['"`]<(.*)>['"`])/gm, '_$2_')
+    .match(MATCH_HTML_TAGS_REGEX)
+  // console.log('htmlTags', htmlTags)
+
+  let tags = []
+  if (htmlTags) {
+    let propsValues = {}
+    // var regexSingleTag = /<([a-zA-Z1-6]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)/
+    // var regexSingleTag = /<([a-zA-Z1-6]+)([^<]+)*(?:>([\s\S]*?)<\/\1>|\s*\/>)/
+    var regexSingleTag = /<([a-zA-Z1-6]+)\b([^>]*)>*(?:>([\s\S]*?)<\/\1>|\s?\/?>)/
+    for (var i = 0; i < htmlTags.length; i++) {
+      // console.log('htmlTags[i]', htmlTags[i])
+      var tagMatches = regexSingleTag.exec(htmlTags[i])
+      // console.log('tagMatches', tagMatches)
+      var [ match, tag, props ] = tagMatches
+      // console.log(`Tag #${i} ${tag}`)
+      if (props) {
+        const cleanProps = props
+          // Remove new lines and tabs
+          .replace(/\n\t/g, '')
+          // Remove extra spaces
+          .replace(/\s\s+/g, ' ')
+          .trim()
+
+        propsValues = cleanProps.split(" ").reduce((acc, curr) => {
+          const hasQuotes = curr.match(/=['"]/)
+          // Check key="value" | key='value' |  key={value}
+          const propWithValue = /([A-Za-z-_$]+)=['{"](.*)['}"]/g.exec(curr)
+          if (propWithValue && propWithValue[1]) {
+            return {
+              ...acc,
+              [`${propWithValue[1]}`]: (hasQuotes) ? propWithValue[2] : convert(propWithValue[2])
+            }
+          }
+          // Check isLoading boolean props
+          const booleanProp = curr.match(/([A-Za-z]*)/)
+          if (booleanProp && booleanProp[1]) {
+            return {
+              ...acc,
+              [`${booleanProp[1]}`]: true
+            }
+          }
+          return acc
+        }, {})
+      }
+
+      tags.push({
+        tag: tag,
+        props: propsValues,
+        raw: match
+      })
+    }
+  }
+  return tags
+}
+
+function convert(value) {
+  if (value === 'false') {
+    return false
+  }
+  if (value === 'true') {
+    return true
+  }
+  const isNumber = Number(value)
+  if (typeof isNumber === 'number' && !isNaN(isNumber)) {
+    return isNumber
+  }
+
+  try {
+    const val = JSON.parse(value)
+    return val
+  } catch (err) {
+    
+  }
+
+  return value
+}
+
+module.exports = {
+  findHtmlTags,
+  MATCH_HTML_TAGS_REGEX
+}

package/lib/utils/md/find-images.js

@@ -0,0 +1,102 @@
+const { onlyUnique, isImage, isRelative } = require('./filters')
+const { findLinks, findLiveLinks } = require('./find-links')
+
+// https://regex101.com/r/u2DwY2/2/
+const MARKDOWN_IMAGE_REGEX = /!\[[^\]]*\]\((.*?)\s*("(?:.*[^"])")?\s*\)/g
+// https://regex101.com/r/Uxgu3P/1
+const RELATIVE_IMAGES_REGEX = /(<img.*?src=['"])(?!(?:(?:https?|ftp):\/\/|data:))(\.?\/)?(.*?)(['"].*?\/?>)/gim
+
+/**
+ * Get image links from content
+ * @param {string} content
+ * @param {array} [links] - optional links to use to avoid re-parse
+ * @returns {array}
+ */
+function findImages(content = '', opts = {}) {
+  const { links, unique = true } = opts
+  const foundLinks = (links && Array.isArray(links)) ? links : findLinks(content).all
+  const imageLinks = foundLinks.filter(isImage)
+  const mdLinks = findMarkdownImages(content)
+  const allImageLinks = imageLinks.concat(mdLinks)
+  const all = (!unique) ? allImageLinks : allImageLinks.filter(onlyUnique)
+  return {
+    all,
+    live: all.filter((link) => !isRelative(link)),
+    relative: all.filter((link) => isRelative(link)),
+    md: mdLinks
+  }
+}
+
+/**
+ * Get live url image links
+ * @param {string} content
+ * @param {array} [links] - optional links to use to avoid re-parse
+ * @returns {array}
+ */
+ function findLiveImages(content = '', links) {
+  const foundLinks = (links && Array.isArray(links)) ? links : findLiveLinks(content)
+  const imageLinks = foundLinks.filter((link) => {
+    return link.match(/(png|jpe?g|gif|webp|svg)$/)
+  })
+  const mdLinks = findMarkdownImages(content)
+  const allImageLinks = imageLinks.concat(mdLinks)
+
+  return allImageLinks
+    .filter(onlyUnique)
+    .filter((link) => !isRelative(link))
+}
+
+function findMarkdownImages(text) {
+  let matches
+  let imageLinks = []
+  while ((matches = MARKDOWN_IMAGE_REGEX.exec(text)) !== null) {
+    if (matches.index === MARKDOWN_IMAGE_REGEX.lastIndex) {
+      MARKDOWN_IMAGE_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
+    }
+    const [ match, image, altText ] = matches
+    imageLinks.push(image)
+  }
+  return imageLinks.filter(onlyUnique)
+}
+
+/**
+ * Get relative image links from content
+ * @param {string} content
+ * @returns {array}
+ */
+function findRelativeImages(text) {
+  const imgTags = findRelativeImgTags(text) || []
+  const mdTags = findMarkdownImages(text).filter(isRelative)
+  return imgTags.concat(mdTags)
+}
+
+/*
+// https://regex101.com/r/SvMfme/1
+<img src="img/deploy/button.svg" />
+<img src="/img/deploy/button.svg" />
+<img src='/img/deploy/button.svg' />
+<img src='./img/deploy/button.svg' />
+<img src='../img/deploy/button.svg' />
+<img src='../../img/deploy/button.svg' />
+*/
+function findRelativeImgTags(block) {
+  let matches
+  let relLinks = []
+  while ((matches = RELATIVE_IMAGES_REGEX.exec(block)) !== null) {
+    if (matches.index === RELATIVE_IMAGES_REGEX.lastIndex) {
+      RELATIVE_IMAGES_REGEX.lastIndex++ // avoid infinite loops with zero-width matches
+    }
+    const [ match, _, start, link ] = matches
+    relLinks.push(`${start || ''}${link}`)
+  }
+  return relLinks.filter(onlyUnique)
+}
+
+module.exports = {
+  findImages,
+  findLiveImages,
+  findRelativeImages,
+  findMarkdownImages,
+  MARKDOWN_IMAGE_REGEX,
+  RELATIVE_IMAGES_REGEX
+}