markdown-magic 2.6.1 → 3.0.1

package/lib/utils/fs.test.js

@@ -0,0 +1,267 @@
+const path = require('path')
+const { test } = require('uvu') 
+const assert = require('uvu/assert')
+const { glob, globWithGit } = require('smart-glob')
+const GREEN = '\x1b[32m%s\x1b[0m';
+const { findUp, getFilePaths, getGitignoreContents, convertToRelativePath } = require('./fs')
+
+const ROOT_DIR = path.resolve(__dirname, '../../')
+
+test('Exports API', () => {
+  assert.equal(typeof findUp, 'function', 'undefined val')
+})
+
+test('Finds file from file', async () => {
+  const startDir = path.resolve(__dirname, '../index.js')
+  const file = await findUp(startDir, 'README.md')
+  assert.ok(file)
+  assert.equal(path.basename(file || ''), 'README.md')
+})
+
+test('Finds file from dir', async () => {
+  const startDir = path.resolve(__dirname, '../')
+  const file = await findUp(startDir, 'README.md')
+  assert.ok(file)
+  assert.equal(path.basename(file || ''), 'README.md')
+})
+
+test('getFilePaths /\.test\.js?$/', async () => {
+  const files = await getFilePaths(ROOT_DIR, {
+    patterns: [
+      /\.test\.js?$/,
+    ],
+    ignore: [
+      /node_modules/,
+    ],
+  })
+  const foundFiles = convertToRelative(files, ROOT_DIR)
+  console.log('foundFiles', foundFiles)
+  assert.is(Array.isArray(files), true)
+  assert.equal(foundFiles, [
+    'lib/block-parser-js.test.js',
+    'lib/block-parser.test.js',
+    'lib/cli.test.js',
+    'lib/index.test.js',
+    'lib/utils/fs.test.js',
+    "lib/utils/md/find-frontmatter.test.js",
+    "lib/utils/md/md.test.js",
+    "lib/utils/text.test.js",
+    'test/errors.test.js',
+    'test/transforms.test.js'
+  ])
+})
+
+test('getFilePaths /\.mdx?$/, /\.test\.js?$/', async () => {
+  const files = await getFilePaths(ROOT_DIR, {
+    patterns: [
+      /fixtures\/md\/(.*)\.mdx?$/,
+      // /\.js$/,
+      /\.test\.js?$/,
+    ],
+    ignore: [
+      // /^node_modules\//,
+      /node_modules/,
+      // /\.git/, 
+      // /NOTES\.md/
+    ],
+    //excludeGitIgnore: true,
+    excludeHidden: true,
+  })
+  const foundFiles = convertToRelative(files, ROOT_DIR)
+  //console.log('foundFiles', foundFiles)
+  assert.is(Array.isArray(files), true)
+  assert.equal(foundFiles, [
+    'lib/block-parser-js.test.js',
+    'lib/block-parser.test.js',
+    'lib/cli.test.js',
+    'lib/index.test.js',
+    'lib/utils/fs.test.js',
+    "lib/utils/md/find-frontmatter.test.js",
+    "lib/utils/md/md.test.js",
+    "lib/utils/text.test.js",
+    'test/errors.test.js',
+    'test/fixtures/md/basic.md',
+    "test/fixtures/md/broken-inline.md",
+    'test/fixtures/md/error-missing-transforms-two.md',
+    'test/fixtures/md/error-missing-transforms.md',
+    'test/fixtures/md/error-no-block-transform-defined.md',
+    'test/fixtures/md/error-unbalanced.md',
+    'test/fixtures/md/format-inline.md',
+    'test/fixtures/md/format-with-wacky-indentation.md',
+    'test/fixtures/md/inline-two.md',
+    'test/fixtures/md/inline.md',
+    'test/fixtures/md/mdx-file.mdx',
+    'test/fixtures/md/missing-transform.md',
+    'test/fixtures/md/mixed.md',
+    'test/fixtures/md/nested/nested.md',
+    'test/fixtures/md/no-transforms.md',
+    'test/fixtures/md/string.md',
+    'test/fixtures/md/syntax-legacy-colon.md',
+    'test/fixtures/md/syntax-legacy-query.md',
+    'test/fixtures/md/syntax-mixed.md',
+    'test/fixtures/md/transform-code.md',
+    'test/fixtures/md/transform-custom.md',
+    'test/fixtures/md/transform-file.md',
+    'test/fixtures/md/transform-remote.md',
+    'test/fixtures/md/transform-toc.md',
+    'test/fixtures/md/transform-wordCount.md',
+    'test/transforms.test.js'
+  ])
+})
+
+test('getFilePaths glob', async () => {
+  /*
+  const x = await glob('**.md')
+  console.log(x)
+  process.exit(1)
+  /** */
+
+  const files = await getFilePaths(ROOT_DIR, {
+    patterns: [
+      /\.test\.js?$/,
+      // /(.*)\.mdx?$/,
+      'test/fixtures/md/**.{md,mdx}'
+      // /^[^\/]+\.md?$/,
+      // '**.json',
+      // '**/**.js',
+      // '**.md',
+      //'/(.*).md$/',
+      // '/^test/',
+      // 'test/**'
+      ///(.*)\.md/g
+    ],
+    ignore: [
+      // /^node_modules\//,
+      /node_modules/,
+      // /(.*)\.js$/,
+      // /\.git/,
+      // /NOTES\.md/
+    ],
+    excludeGitIgnore: true,
+    excludeHidden: true,
+  })
+  const foundFiles = convertToRelative(files, ROOT_DIR)
+  console.log('foundFiles', foundFiles)
+  /*
+  aggregateReports()
+  process.exit(1)
+  /** */
+  assert.is(Array.isArray(files), true)
+  assert.equal(foundFiles, [
+    'lib/block-parser-js.test.js',
+    'lib/block-parser.test.js',
+    'lib/cli.test.js',
+    'lib/index.test.js',
+    'lib/utils/fs.test.js',
+    "lib/utils/md/find-frontmatter.test.js",
+    "lib/utils/md/md.test.js",
+    'lib/utils/text.test.js',
+    // 'misc/old-test/main.test.js',
+    'test/errors.test.js',
+    'test/fixtures/md/basic.md',
+    "test/fixtures/md/broken-inline.md",
+    'test/fixtures/md/error-missing-transforms-two.md',
+    'test/fixtures/md/error-missing-transforms.md',
+    'test/fixtures/md/error-no-block-transform-defined.md',
+    'test/fixtures/md/error-unbalanced.md',
+    'test/fixtures/md/format-inline.md',
+    'test/fixtures/md/format-with-wacky-indentation.md',
+    'test/fixtures/md/inline-two.md',
+    'test/fixtures/md/inline.md',
+    'test/fixtures/md/mdx-file.mdx',
+    'test/fixtures/md/missing-transform.md',
+    'test/fixtures/md/mixed.md',
+    'test/fixtures/md/no-transforms.md',
+    'test/fixtures/md/string.md',
+    'test/fixtures/md/syntax-legacy-colon.md',
+    'test/fixtures/md/syntax-legacy-query.md',
+    'test/fixtures/md/syntax-mixed.md',
+    'test/fixtures/md/transform-code.md',
+    'test/fixtures/md/transform-custom.md',
+    'test/fixtures/md/transform-file.md',
+    'test/fixtures/md/transform-remote.md',
+    'test/fixtures/md/transform-toc.md',
+    'test/fixtures/md/transform-wordCount.md',
+    'test/transforms.test.js'
+  ])
+})
+
+test('getGitignoreContents', async () => {
+  const files = await getGitignoreContents()
+  console.log('files', files)
+  assert.is(Array.isArray(files), true)
+  assert.equal(files, [
+    'logs',
+    '*.log',
+    'npm-debug.log*',
+    'yarn-debug.log*',
+    'yarn-error.log*',
+    'test/fixtures/output',
+    '_out.md',
+    'misc',
+    'misc/**/**.js',
+    '**/old-test/cool.md',
+    'pids',
+    '*.pid',
+    '*.seed',
+    '*.pid.lock',
+    'lib-cov',
+    'coverage',
+    '.nyc_output',
+    '.grunt',
+    'bower_components',
+    '.lock-wscript',
+    'build/Release',
+    'node_modules',
+    'jspm_packages',
+    'typings',
+    '.npm',
+    '.eslintcache',
+    '.node_repl_history',
+    '*.tgz',
+    '.yarn-integrity',
+    '.env',
+    '.env.test',
+    '.cache',
+    '.next',
+    '.nuxt',
+    '.vuepress/dist',
+    '.serverless',
+    '.fusebox',
+    '.dynamodb',
+    '.DS_Store',
+    '.AppleDouble',
+    '.LSOverride',
+    'Icon',
+    '._*',
+    '.DocumentRevisions-V100',
+    '.fseventsd',
+    '.Spotlight-V100',
+    '.TemporaryItems',
+    '.Trashes',
+    '.VolumeIcon.icns',
+    '.com.apple.timemachine.donotpresent',
+    '.AppleDB',
+    '.AppleDesktop',
+    'Network Trash Folder',
+    'Temporary Items',
+    '.apdisk'
+  ])
+})
+
+async function aggregateReports() {
+  console.log(GREEN, `Done.`);
+}
+
+function convertToRelative(files, dir) {
+  return files.map((f) => convertToRelativePath(f, dir)).sort()
+}
+
+async function getIgnores(dir){
+  const files = await getGitignoreContents()
+  console.log('files', files)
+}
+
+//getIgnores(process.cwd())
+
+test.run()

package/lib/utils/index.js

@@ -0,0 +1,19 @@
+
+function onlyUnique(value, index, self) {
+  return self.indexOf(value) === index
+}
+
+function getCodeLocation(srcPath, line, column = '0') {
+  return `${srcPath}:${line}:${column}`
+}
+
+function pluralize(thing, single = '', plural = '') {
+  const count = Array.isArray(thing) ? thing.length : Number(thing)
+  return count === 1 ? single : plural
+}
+
+module.exports = {
+  pluralize,
+  onlyUnique,
+  getCodeLocation
+}

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,94 @@
+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, myObjectTwo) {
+  let obj = myObject
+  if (typeof myObject === 'string') {
+    obj = myObjectTwo
+    console.log(myObject)
+  }
+  console.log(util.inspect(obj, 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 IMAGE_POSTFIX_REGEX = /\.(png|apng|jpe?g|gif|webp|svg|avif)$/
+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(IMAGE_POSTFIX_REGEX)
+}
+
+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,88 @@
+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 
+ * @param {Object} opts 
+ * @returns {Object}
+ * @example
+ * const { blocks, errors } = findCodeBlocks(content)
+ * console.log('blocks', blocks)
+ * console.log('errors', errors)
+ */
+function findCodeBlocks(block, opts = {}) {
+  const { filePath = '', includePositions } = opts
+  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('───────────────────────')
+    /** */
+    const codeBlock = {}
+    if (includePositions) {
+      codeBlock.line = lineNumber
+      codeBlock.index = matches.index
+    }
+
+    if (syntax) {
+      codeBlock.syntax = syntax
+    }
+    
+    codeBlock.block = match
+
+    /* 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) {
+      codeBlock.code = content.trim()
+      blocks.push(codeBlock)
+    }
+  }
+
+  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,92 @@
+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 findFrontmatter(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 {
+    frontMatterRaw: replaceConflictingContent(raw),
+    frontMatter: replaceConflictingContent(match),
+    isHidden
+  }
+}
+
+function parseFrontmatter(text) {
+  const { frontMatter, frontMatterRaw } = findFrontmatter(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 (frontMatterRaw) {
+    mdContent = text
+    // Replace frontmatter brackets
+    .replace(frontMatterRaw, frontMatter)
+    // Replace leading lines
+    // .replace(/---+\s+\n/g, '---\n')
+  }
+
+  try {
+    frontmatter = matter(mdContent)
+  } catch (err) {
+    /* Add line numbers to output */
+    const formattedError = frontMatterRaw.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, { frontMatterRaw })
+}
+
+module.exports = {
+  parseFrontmatter,
+  findFrontmatter,
+  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 { parseFrontmatter } = 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 = parseFrontmatter(fileWithLinks)
+  console.log('frontmatter', frontmatter)
+  assert.is(typeof frontmatter.data, 'object')
+})
+
+test.run()