markdown-magic 2.6.0 → 3.0.0

package/lib/utils/new-parser.js

@@ -1,412 +0,0 @@
-
-const weirdParse = require('./weird-parse')
-
-const html = {
-  tags: ['<!--', '-->'],
-  pattern: ['<!--+', '-->'],
-}
-
-const jsx = {
-  tags: ['{/*', '*/}'],
-  pattern: [
-    '\{\/\\*+',
-    '\\*+/\}'
-  ]
-}
-
-const yaml = {
-  tags: ['##', '##'],
-  pattern: [
-    '##+',
-    '##+'
-  ],
-  converter: (str) => {
-    return str.split('\n').map((line) => {
-      return line[0] === '#' ? line : `#${line}`
-    }).join()
-  }
-}
-
-const syntaxMap = {
-  // <!-- x -->
-  md: html,
-  // <!-- x -->
-  html: html,
-  // /* x */
-  js: {
-    tags: ['/*', '*/'],
-    pattern: [
-      '\/\\*+', // '\/\*[\*\n\s\t]+', // 
-      '\\*+/'
-    ],
-  },
-  // {/* x */}
-  jsx: jsx,
-  mdx: jsx,
-  // ## x ##
-  yaml: yaml,
-  yml: yaml
-}
-
-function convertCommentSyntax({
-  str, 
-  from, 
-  to
-}) {
-  const [ openPattern, closePattern ] = syntaxMap[from].pattern
-  const [ openTag, closeTag ] = syntaxMap[to].tags
-  const match = ` *?\\${openPattern}([\\s\\S]*?)?${closePattern}\\n\\n*?`
-  // const match = `${openPattern}(.*|\\r?|\\n?|\\s*)*${closePattern}`
-  const regexToUse = new RegExp(match, 'g')
-  // console.log('regexToUse', regexToUse)
-  const found = str.match(regexToUse)
-  if (!found) {
-    return str
-  }
-  const newComment = found[0].replace(regexToUse, `${openTag}$1${closeTag}`)
-  const converter = syntaxMap[to].converter
-  const newText = (converter) ? converter(newComment) : newComment
-  return str.replace(regexToUse, newText)
-}
-
-const defaultOptions = {
-  syntax: 'md',
-  open: `DOCS:START`,
-  close: `DOCS:END`,
-}
-
-function parseBlocks(contents, options = defaultOptions) {
-  const { syntax } = options
-  const transformsToRun = []
-  // const blockRegex = new RegExp(
-  //   `(.*)(?:\\<\\!--(?:.*|\r?|\n?|\\s*)${matchWord}:START(?:(?:.|\\r?\\n)*?(?:\\()(.*)\\))?(.|\\r?\\n)*?)?<\!--(?:.*|\r?|\n?|\\s*)${matchWord}:END(?:.|\\r?\\n)*?--\\>`,
-  //   'gm'
-  // )
-  //  `(?:.*)(?:\\<\\!--(?:.*|\\r?|\\n?|\\s*)${matchWord}:START\\s*([(\\[\\{]*[A-Za-z0-9_$-]*[)\\]\\}]*)\\s*)((?:.|\\r?\\n)*?)<\!--(?:.*|\\r?|\\n?|\\s*)${matchWord}:END(?:.|\\r?\\n)*?--\\>`,
-  const START = options.open
-  const END = options.close
-
-  const [ commentOpen, commentClose ] = syntaxMap[syntax].pattern
-  // const regexToUse = new RegExp(
-  //   `([ \\t]*)(?:\\<\\!--(?:.*|\\r?|\\n?|\\s*)${matchWord}:START\\s*([(\\[\\{]*[A-Za-z0-9_$-]*[)\\]\\}]*)\\s*)((?:.|\\r?\\n)*?)<\!--(?:.*|\\r?|\\n?|\\s*)${matchWord}:END(?:.|\\r?\\n)*?--\\>`,
-  //   'gmi'
-  // )
-  const regexToUse = new RegExp(
-    `([ \\t]*)(?:${commentOpen}(?:.*|\\r?|\\n?|\\s*)${START}\\s*([(\\[\\{]*[A-Za-z0-9_$-]*[)\\]\\}]*)\\s*)((?:.|\\r?\\n)*?)${commentOpen}(?:.*|\\r?|\\n?|\\s*)${END}(?:.|\\r?\\n)*?${commentClose}`,
-    'gmi'
-  )
-  const paramsRegex = new RegExp(`([\\s\\S]*?)${commentClose}`, 'gm')
-  const trimRegex = new RegExp(`${commentClose}$`)
-  
-  // console.log('paramsRegex', paramsRegex)
-  // ([ \t]*)(?:\/\*(?:.*|\r?|\n?|\s*)XYZ:START\s*([(\[\{]*[A-Za-z0-9_$-]*[)\]\}]*)\s*)((?:.|\r?\n)*?)\/\*(?:.*|\r?|\n?|\s*)XYZ:END(?:.|\r?\n)*?\*\/
-  // console.log('regexToUse', regexToUse)
-
-  let openTagRegex = matchOpeningCommentTag(START, commentOpen, commentClose)
-  let closeTagRegex = matchClosingCommentTag(END, commentOpen, commentClose)
-  while ((commentMatches = regexToUse.exec(contents)) !== null) {
-    let props = {}
-    let meta = {}
-    const [ block, spaces, action, params ] = commentMatches
-    const indentation = spaces || ''
-    /*
-    console.log('index', commentMatches.index)
-    console.log('block', block)
-    console.log('action', action)
-    console.log('params', params)
-    console.log('spaces', `"${spaces}"`)
-    /** */
-    // This is necessary to avoid infinite loops
-    if (commentMatches.index === regexToUse.lastIndex) {
-      regexToUse.lastIndex++
-    }
-
-    openTagRegex = matchOpeningCommentTag(START, commentOpen, commentClose)
-    const openingTag = getOpeningTags(block, {
-      pattern: openTagRegex, 
-      open: commentOpen, 
-      close: commentClose
-    })
-    closeTagRegex = matchClosingCommentTag(END, commentOpen, commentClose)
-    const closingTag = getClosingTags(block, {
-      pattern: closeTagRegex
-    })
-    /*
-    console.log('openingTag', openingTag)
-    console.log('closingTag', closingTag)
-    /** */
-    const openingTagLength = openingTag.length //+ indentation.length
-    const contentEndPosition = block.indexOf(closingTag.tag, openingTagLength)
-    const content = getTextBetween(block, openingTagLength, contentEndPosition)
-    // console.log('contentcontent', content)
-    let originalContent = content
-    const contentEndsWithNewLine = getLastCharacter(originalContent) === '\n'
-    const openEndsWithNewLine = getLastCharacter(openingTag.tag) === '\n'
-    const isMultiline = block.indexOf('\n') > -1
-    meta.isMultiline = isMultiline
-    const closeTag = (contentEndsWithNewLine) ? `\n${closingTag.tag}` : closingTag.tag
-
-    // Move new line to beginning of closing tag
-    // if (originalContent.match(/\n$/)) {
-    if (contentEndsWithNewLine) {
-      // originalContent = originalContent.replace(/\n$/, '')
-      originalContent = originalContent.slice(0, -1)
-    }
-
-    // Strip indentation
-    originalContent = stripIndent(originalContent, indentation.length)
-    // console.log('originalContent')
-    // console.log(`"${originalContent}"`)
-    // originalContent = originalContent.replace(/^\s+|\s+$/g, '')
-
-    // (functionName) or [functionName] or {functionName}
-    const transform = action.replace(/[(\[\{]*([A-Z-a-z0-9_$-]*)[)\]\}]*/, '$1')
-    // if (transform && !transform.match(/^-+/)) {
-    if (transform && getFirstCharacter(transform) !== '-') {
-      // console.log('params', params)
-      // const paramValue = params.match(/([\s\S]*?)-->/gm)
-      const paramValue = params.match(paramsRegex)
-      let paramString
-      if (paramValue) {
-        // paramString = paramValue[0].replace(/-*>$/, '').trim()
-        paramString = paramValue[0].replace(trimRegex, '').trim()
-        // console.log('paramString', paramString)
-        if (paramString) {
-          // Legacy v1 options parser
-          if (getFirstCharacter(paramString) === ':') {
-            meta.isLegacy = true
-            paramString = paramString.replace(/\s?\)\s?$/, '').substring(1)
-            props = legacyParseOptions(paramString)
-          } else {
-            props = weirdParse(paramString) 
-          }
-        }
-      }
-      /*
-      console.log(regexToUse)
-      console.log(`transform "${transform}" at ${regexToUse.lastIndex} using props:`)
-      console.log(props)
-      console.log('───────────────────────')
-      /** */
-      const shift = (openEndsWithNewLine) ? 1 : 0
-      const contentStart = commentMatches.index + openingTag.tag.length - shift //+ indentation.length
-      const contentEnd = contentStart + content.length + indentation.length + shift
-      //const addOne = (contentEndsWithNewLine) ? 1 : 0
-      transformsToRun.push({
-        transform,
-        args: props,
-        // content: originalContent,
-        block: {
-          indentation,
-          start: commentMatches.index,
-          end: regexToUse.lastIndex,
-          contentStart,
-          contentEnd,
-          contentIndent: minIndent(originalContent),
-          openTag: openingTag.tag,
-          content: originalContent,
-          closeTag: closeTag,
-          // full: `${openingTag.tag}${indentString(originalContent, indentation.length)}${closeTag}`,
-          // full: indentString(`${openingTag.tag}${originalContent}${closeTag}`, indentation.length),
-          // full: indentString(`${stripIndent(openingTag.tag, indentation.length)}${originalContent}${stripIndent(closeTag, indentation.length)}`, indentation.length)
-        },
-        raw: {
-          transform: (meta.isLegacy) ? action.replace(/^\s?\(/, '') : action,
-          args: paramString,
-          content: getTextBetween(contents, contentStart, contentEnd),
-          block: block,
-        },
-        meta,
-      })
-    }
-  }
-
-  // const newer =
-  //   /(?:.*)(?:\<\!--(?:.*|\r?|\n?|\s*)DOCS:START\s*([(\[\{][A-Z-a-z_$-]*[)\]\}])\s*)((?:.|\r?\n)*?)<\!--(?:.*|\r?|\n?|\s*)DOCS:END(?:.|\r?\n)*?--\>/gmi
-  // // console.log('newera', newer)
-  /*
-  const comments = content.match(newerString)
-  console.log('comments', comments)
-  const commentRegexInside = /<\!-*\s*([\s\S]*?) ?-*\>\n*?/g
-  if (comments) {
-    // console.log('comments', comments)
-    // console.log(comments.length)
-    comments.forEach((text) => {
-      console.log('text', text)
-      const inside = commentRegexInside.exec(text)
-      console.log('inside', inside)
-      if (inside) {
-        const config = inside[1].replace(`${matchWord}:START`, '').trim()
-        // console.log(formatProps(config))
-      }
-    })
-  }*/
-
-  return {
-    pattern: regexToUse,
-    commentOpen: openTagRegex,
-    commentClose: closeTagRegex,
-    transforms: transformsToRun
-  }
-}
-
-function replaceTextBetween(origin, startIndex, endIndex, insertion) {
-  return origin.substring(0, startIndex) + insertion + origin.substring(endIndex)
-}
-
-function replaceContent(origin, insertion, data) {
-  return replaceTextBetween(origin, data.block.contentStart, data.block.contentEnd, insertion)
-}
-
-function getFirstCharacter(str) {
-  return str.charAt(0)
-}
-
-function getLastCharacter(str) {
-  return str.substr(-1)
-}
-
-function getLeadingSpaces(text) {
-  return text.match(/^\s/) ? text : ''
-}
-
-function getTextBetween(text, start, end) {
-  return text.slice(start, end)
-}
-
-function stripIndent(string, indentation) {
-  const indent = typeof indentation !== 'undefined' ? indentation : minIndent(string);
-	if (indent === 0) {
-		return string
-	}
-	const regex = new RegExp(`^[ \\t]{${indent}}`, 'gm')
-	return string.replace(regex, '')
-}
-
-// https://github.com/jamiebuilds/min-indent/blob/master/index.js
-function minIndent(string) {
-	const match = string.match(/^[ \t]*(?=\S)/gm)
-	if (!match) return 0
-	return match.reduce((r, a) => Math.min(r, a.length), Infinity)
-}
-
-function indentString(string, count = 1, options = {}) {
-	const {
-		indent = ' ',
-		includeEmptyLines = false
-	} = options;
-	if (count === 0) return string
-	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm
-	return string.replace(regex, indent.repeat(count))
-}
-
-function getOpeningTags(block, {
-  pattern, 
-  open,
-  close
-}) {
-  // console.log(block.match(/^\/\*+(.*)\*\//))
-  // console.log('openTagRegex', pattern)
-  let matches
-  while ((matches = pattern.exec(block)) !== null) {
-    if (matches.index === pattern.lastIndex) {
-      pattern.lastIndex++  // avoid infinite loops with zero-width matches
-    }
-    const [ tag, spaces, tagStart, tagEnd ] = matches
-    /*
-    console.log('FULL Open Tag >>>>>', tag)
-    console.log('openTag Start', "'"+tagStart+"'");
-    console.log('openTag End', "'"+tagEnd+"'");
-    /**/
-    return {
-      tag,
-      spaces: spaces || '',
-      length: tag.length,
-      tagStart,
-      tagEnd,
-    }
-  }
-  // Fallthrough
-  const fallbackRegex = new RegExp(`^([ \\t]*)(${open}([\\s\\S]*?)${close})\\n?`)
-  // const xyz = block.match(/^([ \t]*)(\/\*+([\s\S]*?)\*+\/)/)
-  const xyz = block.match(fallbackRegex)
-  /*
-  console.log('fallbackRegex', fallbackRegex)
-  console.log('fall through', `"${block}"`)
-  console.log('xyz', xyz)
-  /** */
-  return {
-    tag: xyz[0],
-    spaces: xyz[1] || '',
-    length: xyz[0].length,
-  }
-}
-
-function getClosingTags(block, {
-  pattern, 
-  // open,
-  // close
-}) {
-  // console.log('closeTagRegex', closeTagRegex)
-  let matches
-  while ((matches = pattern.exec(block)) !== null) {
-    if (matches.index === pattern.lastIndex) {
-      pattern.lastIndex++ // avoid infinite loops with zero-width matches
-    }
-    const [ _tag, spaces, tagStart, tagEnd] = matches
-    /*
-    console.log('FULL CLOSE Tag >>>>>', matches[0])
-    console.log('closeTag Start', "'"+matches[1]+"'");
-    console.log('closeTag End', "'"+matches[2]+"'");
-    /**/
-    const tag = spaces + tagStart + tagEnd
-    return {
-      tag: tag,
-      length: tag.length,
-      spaces: spaces || '',
-      tagStart,
-      tagEnd
-    }
-  }
-}
-
-function removeComments(str) {
-  // /([^\s]*)?([ \\t]*)\<\!-+\s?([\s\S]*?)?-+\>\n*?([^\s]*)?/gi
-  const pattern = new RegExp(`([^\\s]*)?([ \\t]*)<!-+\\s?([\\s\\S]*?)?-+>\n*?([^\\s]*)?`, 'gi')
-  return str.replace(pattern, '')
-}
-
-function matchOpeningCommentTag(word, open, close) {
-  // console.log('open', open)
-  // return new RegExp(`(\\<\\!--(?:.|\\r?\\n)*?${matchWord}:START)((?:.|\\r?\\n)*?--\\>)`, 'g')
-  return new RegExp(`([ \\t]*)(${open}(?:.|\r?|\n?|\\s*)\\b${word}\\b)((?:.|\\r?\\n)*?${close}\n?)`, 'gi')
-  // return new RegExp(`([ \\t]*)(\\<\\!--(?:.*|\r?|\n?|\s*)${word}:START)((?:.|\\r?\\n)*?--\\>\n?)`, 'gi')
-}
-
-function matchClosingCommentTag(word, open, close) {
-  return new RegExp(`${close}(?:.|\\r?\\n)*?([ \t]*)((?:${open}(?:.*|\\r?\\n)(?:.*|\\r?\\n))*?\\b${word}\\b)((?:.|\\r?\\n)*?${close})`, 'gi')
-  // return new RegExp(`--\\>(?:.|\\r?\\n)*?([ \t]*)((?:\\<\\!--(?:.*|\\r?\\n)(?:.*|\\r?\\n))*?${word}:END)((?:.|\\r?\\n)*?--\\>)`, 'gi')
-}
-
-
-function legacyParseOptions(options) {
-  const returnOptions = {}
-  if (!options) {
-    return returnOptions
-  }
-  options.split('&').map((opt, i) => { // eslint-disable-line
-    const getValues = opt.split(/=(.+)/)
-    if (getValues[0] && getValues[1]) {
-      returnOptions[getValues[0]] = getValues[1]
-    }
-  })
-  return returnOptions
-}
-
-
-module.exports = {
-  getTextBetween,
-  replaceTextBetween,
-  replaceContent,
-  parseBlocks,
-}

package/lib/utils/weird-parse.js

@@ -1,230 +0,0 @@
-const { parseJSON } = require('json-alexander')
-
-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
-  }
-
-  // console.log(typeof value)
-  // console.log('value', value)
-  try {
-    const val = parseJSON(value) // last attempt to format an array like [ one, two ]
-    if (typeof val === 'string' && val.match(/^\[/) && val.match(/\]$/)) {
-      const inner = val.match(/^\[(.*)\]/)
-      if (inner && inner[1]) {
-        const newVal = inner[1].split(', ').map((x) => {
-          return convert(x.trim())
-        })
-        return newVal
-      }
-    }
-    return val
-  } catch (err) {
-    console.log('val', value)
-    console.log('err', err)
-  }
-  return value
-}
-
-const RESERVED = '__private'
-
-function doWeirdParse(x) {
-  // https://regex101.com/r/bx8DXm/1/ Match everything but spaces/newlines
-  var y = /("|'|{)[^"}]+("|'|})|(\S+)/g
-
-  const cleanLines = x
-    .split(/\n/)
-    .filter((line) => {
-      // Trim all comment blocks
-      return !line.trim().match(/^(\/\/+|\/\*+|#+)/gm)
-    })
-    .join('\n')
-
-  var lines = cleanLines.match(y)
-  // console.log('lines', lines.length)
-  // console.log('lines', lines)
-  var isEnding = /(['"}\]]|true,?|false,?)$/
-
-  const values = lines.reduce((acc, curr, i) => {
-    const isLastLoop = lines.length === (i + 1)
-    const nextItem = lines[i + 1] || '' 
-    const hasText = curr.match(/^[A-Za-z]/)
-    let alreadyAdded = false
-
-    /*
-    console.log('isLastLoop', isLastLoop)
-    console.log('RESERVED', acc[RESERVED]) 
-    console.log("current item", curr) 
-    console.log('next item   ', nextItem) 
-    /** */
-
-    // If has no = its a true boolean. e.g isThingy
-    if (hasText && acc[RESERVED].match(/^[A-Za-z]/) && !isValuePair(acc[RESERVED])) {
-      // console.log('xxxxxxx', acc[RESERVED])
-      acc[trimTrailingComma(acc[RESERVED])] = true
-      acc[RESERVED] = ''
-    } 
-    // If has no = its a true boolean
-    if (hasText && !curr.match(isEnding) && acc[RESERVED].match(isEnding)) {
-      // console.log('end', curr)
-      const kv = getKeyAndValueFromString(acc[RESERVED])
-      if (kv) {
-        acc[kv.key] = kv.value
-      }
-      acc[RESERVED] = ''
-    }
-
-    if (!acc[RESERVED].match(/^[A-Za-z]+={+/) && isValuePair(curr) && curr.match(isEnding)) {
-      const kv = getKeyAndValueFromString(curr)
-      if (kv) {
-        // console.log(`ADDED`, kv)
-        acc[kv.key] = kv.value
-      }
-    } else {
-      // console.log('Add', curr)
-      alreadyAdded = true
-      acc[RESERVED] = acc[RESERVED] + curr
-    }
-
-
-    if (acc[RESERVED].match(isEnding) && nextItem.match(/^[A-Za-z0-9_-]/)) {
-      const kv = getKeyAndValueFromString(acc[RESERVED])
-      if (kv) {
-        // console.log(`acc[RESERVED].match(isEnding)`, kv)
-        acc[kv.key] = kv.value
-      }
-      acc[RESERVED] = ''
-    }
-
-    // If ends in number foo=2 or bar=3,
-    if (isValuePair(curr) && curr.match(/\d,?$/)) {
-      const kv = getKeyAndValueFromString(acc[RESERVED])
-      if (kv) {
-        // console.log(`acc[RESERVED].match(isEnding)`, kv)
-        acc[kv.key] = kv.value
-      }
-      acc[RESERVED] = ''
-    }
-
-    // If last loop and still no match and looks like KV. Parse it
-    if (isLastLoop) {
-      // If single isCool boolean
-      if (hasText && !curr.match(/=/)) {
-        // console.log(`ADDED`, kv)
-        // acc[curr] = true
-        // acc[RESERVED] = ''
-      }
-      // console.log('currrrrr', curr)
-      // console.log("acc[RESERVED]", acc[RESERVED])
-      // console.log('combined', acc[RESERVED] + curr)
-      // If value empty but __private have accumulated values
-      if (acc[RESERVED]) {
-      // if (acc[RESERVED] && (acc[RESERVED].match(isEnding) || isValuePair(acc[RESERVED]))) {
-        const valueToCheck = (curr.match(isEnding) && !alreadyAdded) ? acc[RESERVED] + curr : acc[RESERVED]
-        // console.log('valueToCheck', valueToCheck)
-        const kv = getKeyAndValueFromString(valueToCheck)
-        if (kv) {
-          // console.log(`acc[RESERVED].match(isEnding)`, kv)
-          acc[kv.key] = kv.value
-        }
-        acc[RESERVED] = ''
-      }
-    }
-
-    return acc
-  }, {
-    [RESERVED]: '',
-  })
-
-  delete values[RESERVED]
-
-  /* // If no keys last attempt to parse
-  if (!Object.keys(values).length) {
-    const kv = getKeyAndValueFromString(x)
-    if (kv) {
-      return {  
-        [`${kv.key}`]: kv.value
-      }
-    }
-  }
-  */
-
-  return values
-}
-
-function isValuePair(str) {
-  return str.match(/=/)
-}
-
-// https://melvingeorge.me/blog/check-if-string-contain-emojis-javascript OR https://www.npmjs.com/package/emoji-regex
-function hasEmoji(str) {
-  const regexExp = /^(\u00a9|\u00ae|[\u2000-\u3300]|\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/gi;
-  return regexExp.test(str)
-}
-
-function getKeyAndValueFromString(string) {
-  if (!string) return
-  // const keyValueRegex = /([A-Za-z-_$]+)=['{"]?(.*)['}"]?/g
-  // const match = keyValueRegex.exec(string)
-  // if (!match) {
-  //   return
-  // }
-  // console.log('getKeyAndValueFromString')
-
-  const [key, ...values] = string.split('=')
-  /* If no key or key starts with --- */
-  if (!key || key.charAt(0) === '-' || hasEmoji(key)) {
-    return
-  }
-  // console.log('string', string)
-  // console.log('key', key)
-  // console.log('values', values)
-  /* If no value, isThing === true */
-  if (!values.length) {
-    return {
-      key: key,
-      value: true,
-    }
-  }
-
-  const value = values.join('')
-
-  let cleanValue = value
-    .replace(/^{{2,}/, '{')
-    .replace(/}{2,}$/, '}')
-    .replace(/^\[{2,}/, '[')
-    .replace(/\]{2,}$/, ']')
-    // Trim trailing commas
-    .replace(/,$/, '')
-
-  if (value.match(/^{[^:,]*}/)) {
-    cleanValue = removeSurroundingBrackets(cleanValue)
-  } else if (value.match(/^{\s*\[\s*[^:]*\s*\]\s*\}/)) {
-    // Match { [ one, two ,3,4 ]   }
-    cleanValue = removeSurroundingBrackets(cleanValue)
-  }
-
-  return {
-    key: key,
-    value: convert(cleanValue),
-  }
-}
-
-function trimTrailingComma(str = '') {
-  // Trim trailing commas
-  return str.replace(/,$/, '')
-}
-
-function removeSurroundingBrackets(val) {
-  return val.replace(/^{/, '').replace(/}$/, '')
-}
-
-module.exports = doWeirdParse