markdown-magic 3.0.0 → 3.0.2

package/lib/process-contents.js

@@ -23,6 +23,13 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
     debug = false,
   } = config
 
+  /*
+  console.log('OPEN_WORD', open)
+  console.log('CLOSE_WORD', close)
+  console.log('syntax', syntax)
+  // console.log('text', text)
+  /** */
+
   let foundBlocks = {}
   try {
     foundBlocks = parseBlocks(text, {
@@ -86,9 +93,9 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
     /* Run transform plugins */
     let tempContent = content.value
     // console.log('transform', transform)
-    const currentTransform = getTransform(transform, transforms)
+    const currentTransformFn = getTransform(transform, transforms)
     /* Run each transform */
-    if (currentTransform) {
+    if (currentTransformFn) {
       // console.log('context', context)
       let returnedContent
       /* DISABLED legacy syntax */
@@ -97,11 +104,11 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
         console.log(`CALL legacy ${transform}`, srcPath)
         // backward compat maybe
         // CODE(content, options, config)
-        returnedContent = await currentTransform(content.value, options, { 
+        returnedContent = await currentTransformFn(content.value, options, { 
           originalPath: srcPath
         })
       } else {
-        returnedContent = await currentTransform(transformApi({
+        returnedContent = await currentTransformFn(transformApi({
           srcPath,
           ...match,
           regex: regexInfo,
@@ -111,13 +118,15 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
       }
       /** */
 
-      returnedContent = await currentTransform(transformApi({
-        srcPath,
-        ...match,
-        regex: regexInfo,
-        originalContents: text,
-        currentContents: md,
-      }, config))
+      returnedContent = await currentTransformFn(
+        transformApi({
+          srcPath,
+          ...match,
+          regex: regexInfo,
+          originalContents: text,
+          currentContents: md,
+        }, config)
+      )
 
       /* Run each transform */
       // console.log('config', config)
@@ -143,7 +152,7 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
       console.log('afterContent', afterContent)
     }
 
-    if (!currentTransform) {
+    if (!currentTransformFn) {
       missingTransforms.push(afterContent)
       // console.log(`Missing "${transform}" transform`)
     }
@@ -211,48 +220,74 @@ const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
 function transformApi(stuff, opts) {
   const { transforms, srcPath, outputPath, ...rest } = opts
   return {
-    srcPath: stuff.srcPath,
-    outputPath: outputPath,
     transform: stuff.transform,
+    content: stuff.content.value,
     options: stuff.options || {},
-    blockContent: stuff.content.value,
-    fileContent: stuff.currentContents,
-    originalFileContent: stuff.originalContents,
+    srcPath: stuff.srcPath,
+    outputPath: outputPath,
     settings: {
       ...rest,
       regex: stuff.regex,
     },
+
+    // blockContent: stuff.content.value,
+    fileContent: stuff.currentContents,
+    originalFileContent: stuff.originalContents,
+    /* Methods */
     getOriginalContent: () => stuff.originalContents,
     getOriginalBlock: () => stuff,
-    getCurrentBlock: () => {
+    getBlockDetails: (content) => {
       /* Re-parse current file for updated positions */
-      const updatedBlocks = parseBlocks(stuff.currentContents, {
-        syntax: opts.syntax,
-        open: opts.open,
-        close: opts.close,
-      })
-
-   
-      const matchingBlocks = updatedBlocks.blocks.filter((block) => {
-        return block.open.value === stuff.open.value
+      return getDetails({
+        contents: content || stuff.currentContents,
+        openValue: stuff.open.value,
+        srcPath: stuff.srcPath,
+        index: stuff.index,
+        opts: opts
       })
+    },
+    // getOriginalBlockDetails: () => {
+    //   return getDetails({
+    //     contents: stuff.originalContents,
+    //     openValue: stuff.open.value,
+    //     srcPath: stuff.srcPath,
+    //     index: stuff.index,
+    //     opts: opts
+    //   })
+    // },
+  }
+}
 
-      if (!matchingBlocks.length) {
-        return {}
-      }
-      let foundBlock = matchingBlocks[0]
+function getDetails({
+  contents,
+  openValue,
+  srcPath,
+  index,
+  opts
+}) {
+  /* Re-parse current file for updated positions */
+  const blockData = parseBlocks(contents, opts)
+
+  const matchingBlocks = blockData.blocks.filter((block) => {
+    return block.open.value === openValue
+  })
 
-      if (matchingBlocks.length > 1) {
-        foundBlock = matchingBlocks.filter((block) => {
-          return block.index === stuff.index
-        })[0]
-      }
+  if (!matchingBlocks.length) {
+    return {}
+  }
 
-      const location = getCodeLocation(stuff.srcPath, foundBlock.block.lines[0])
+  let foundBlock = matchingBlocks[0]
+  if (matchingBlocks.length > 1 && index) {
+    foundBlock = matchingBlocks.filter((block) => {
+      return block.index === index
+    })[0]
+  }
 
-      return [ foundBlock, location ]
-    },
+  if (srcPath) {
+    const location = getCodeLocation(srcPath, foundBlock.block.lines[0])
+    foundBlock.sourceLocation = location
   }
+  return foundBlock
 }
 
 /**
@@ -299,6 +334,12 @@ function applyMiddleware(data, md, middlewares) {
   }, Promise.resolve(data))
 }
 
+/**
+ * Get Transform function
+ * @param {string} name - transform name
+ * @param {object} transforms - transform fns
+ * @returns {function}
+ */
 function getTransform(name, transforms = {}) {
   return transforms[name] || transforms[name.toLowerCase()]
 }

package/lib/process-file.js

@@ -2,11 +2,14 @@ const path = require('path')
 const isValidFile = require('is-valid-path')
 const { readFile } = require('./utils/fs')
 const { processContents } = require('./process-contents')
+// const { OPEN_WORD, CLOSE_WORD } = require('./defaults')
 
 async function processFile(opts = {}) {
   const { content, syntax } = opts
   let srcPath = opts.srcPath
-  if (srcPath && content) throw new Error(`Can't set both "srcPath" & "content"`)
+  if (srcPath && content) {
+    throw new Error(`Can't set both "srcPath" & "content"`) 
+  }
   let fileContents
   if (content) {
     const isFile = isValidFile(content)

package/lib/transforms/code.js

@@ -11,11 +11,12 @@ const { getLineCount, getTextBetweenLines } = require('../utils/text')
 // usage https://github.com/linear/linear/blame/93981d3a3db571e2f8efdce9f5271ea678941c43/packages/sdk/README.md#L1
 
 module.exports = function CODE(api) {
-  const { options = {}, blockContent, srcPath } = api
+  const { content, options, srcPath } = api
   // console.log('CODE API', api)
+  // process.exit(1)
   // console.log('options', options)
   const { src, lines } = options
-  const originalContent = blockContent
+  const originalContent = content
   let code
   let syntax = options.syntax
   if (!src) {
@@ -27,14 +28,7 @@ module.exports = function CODE(api) {
     const fileDir = (srcPath) ? path.dirname(srcPath) : process.cwd()
     codeFilePath = path.resolve(fileDir, src)
     try {
-      code = fs.readFileSync(codeFilePath, 'utf8', (err, contents) => {
-        if (err) {
-          console.log(`FILE NOT FOUND ${codeFilePath}`)
-          console.log(err)
-           // throw err
-        }
-        return contents
-      })
+      code = fs.readFileSync(codeFilePath, 'utf8')
     } catch (e) {
       console.log(`FILE NOT FOUND ${codeFilePath}`)
       throw e

package/lib/transforms/file.js

@@ -3,24 +3,21 @@ const fs = require('fs')
 const isLocalPath = require('is-local-path')
 
 module.exports = function FILE(api) {
+  /*
+  console.log('FILE API', api)
+  console.log(api.getBlockDetails())
+  process.exit(1)
+  /** */
   const { options, srcPath } = api
-  // console.log('FILE API', api)
-  let fileContents
   if (!options.src) {
     return false
   }
+  let fileContents = ''
   if (isLocalPath(options.src)) {
     const fileDir = path.dirname(srcPath)
     const resolvedFilePath = path.resolve(fileDir, options.src)
     try {
-      fileContents = fs.readFileSync(resolvedFilePath, 'utf8', (err, contents) => {
-        if (err) {
-          console.log(`FILE NOT FOUND ${resolvedFilePath}`)
-          console.log(err)
-           // throw err
-        }
-        return contents
-      })
+      fileContents = fs.readFileSync(resolvedFilePath, 'utf8')
     } catch (e) {
       console.log(`FILE NOT FOUND ${resolvedFilePath}`)
       throw e

package/lib/transforms/remote.js

@@ -1,14 +1,13 @@
-const regexUtils = require('../utils/regex')
 const remoteRequest = require('../utils/remoteRequest')
 
 module.exports = function REMOTE(api) {
   // console.log('REMOTE api', api)
-  const { options, blockContent, settings } = api
+  const { options, content, settings } = api
   const { regex } = settings
   // console.log('MAKE REMOTE REQUEST')
   const remoteContent = remoteRequest(options.url)
   if (!remoteContent) {
-    return blockContent
+    return content
   }
   if (options.keepComments) {
     return remoteContent

package/lib/transforms/sectionToc.js

@@ -0,0 +1,18 @@
+const { generateToc } = require('../utils/toc')
+
+module.exports = async function sectionToc(api) {
+  // console.log("sectionToc", api)
+  const { options, fileContent, srcPath, getBlockDetails } = api
+  const opts = options || {}
+  const subToc = await generateToc({
+    options: {
+      ...opts,
+      // Set sub table of contents
+      sub: true
+    },
+    fileContent,
+    srcPath,
+    getBlockDetails: getBlockDetails
+  })
+  return subToc
+}

package/lib/transforms/toc.js

@@ -1,338 +1,13 @@
-const { transform } = require('@technote-space/doctoc')
-const { removeLeadingAndTrailingLineBreaks, escapeRegexString } = require('../utils/regex')
-const { findMinIndent } = require('../utils/text')
+const { generateToc } = require('../utils/toc')
 
 module.exports = async function TOC(api) {
   // console.log("TOC API", api)
-  const { options, fileContent, originalFileContent } = api
-  //const currentBlock = api.getCurrentBlock()
-  const originalBlock = api.getOriginalBlock()
-  const { block } = originalBlock
-  // console.log('originalBlock', originalBlock)
-  const originalContents = originalFileContent
-  const opts = options || {}
-  const isSub = opts.sub
-  opts.firsth1 = (opts.firsth1) ? true : false
-  let contents = fileContent
-  // console.log('contents', contents)
-
-  let debugFileMatch
-  // console.log('config', config.originalPath)
-  // debugFileMatch = config.originalPath.match(/packages\/analytics\/README\.md/)
-
-  // https://www.npmjs.com/package/@technote-space/toc-generator
-  const tocOptions = {
-    // mode: 'github.com', // github.com | bitbucket.org | gitlab.com | nodejs.org | ghost.org (default: github.com)
-    isNotitle: true,
-    //isCustomMode: true,
-    openingComment: '',
-    closingComment: '', 
-    maxHeaderLevel: (opts.maxDepth) ? Number(opts.maxDepth) : 4,
-    // maxHeaderLevel: 2, // default: 4
-    // title: '**Table of Contents**',
-    // isNotitle: true,
-    // isFolding: true,
-    // entryPrefix: '*',
-    // processAll: true,
-    // updateOnly: true,
-    // openingComment: '<!-- toc -->',
-    // closingComment: '<!-- tocstop --> ',
-    // checkOpeningComments: ['<!-- toc '],
-    // checkClosingComments: ['<!-- tocstop '],
-    // isCustomMode: false,
-    // customTemplate: '<p align="center">${ITEMS}</p>',
-    // itemTemplate: '<a href="${LINK}">${TEXT}</a>',
-    // separator: '<span>|</span>',
-    // footer: 'end',
-  }
-  const t = await transform(contents, tocOptions)
-  let outputText = t.wrappedToc || ''
-
-  if (debugFileMatch) {
-    console.log('before firsth1 removal', outputText)
-  }
-
-  /* remove first h1 */
-  if (!opts.firsth1) {
-    // console.log('outputText', outputText)
-    const lines = outputText.split('\n')
-    let firstH1
-    let firstLine
-    const countOfH1s = lines.reduce((acc, line, index) => {
-      if (line !== '' && !firstLine) {
-        firstLine = index
-      }
-      if (line.match(/^-\s+/)) {
-        if (!firstH1) {
-          const rawText = line.match(/\[(.*)\]/)[1]
-          firstH1 = [line, index, firstLine === index, rawText]
-        }
-        acc = acc + 1
-      }
-      return acc
-    }, 0)
-
-    const firstHeadingData =  (firstH1 && Array.isArray(firstH1)) ? firstH1 : []
-    const [ lineText, lineIndex, isFirst, matchText ] = firstHeadingData
-    
-    let docHasHeading = false
-    if (matchText) {
-      // verify its h1
-      const matchTextEscaped = escapeRegexString(matchText)
-      // console.log('matchTextEscaped', matchTextEscaped)
-      // /^#{1}\s+(.*)/
-      const FIRST_H1_REGEX = new RegExp(`^#\\s*\\[?${matchTextEscaped}\\]?(?:.*)?`, 'gim')
-      // /^<h1\b[^>]*>([\s\S]*?)<\/h1>/
-      const FIRST_HTML_H1_REGEX = new RegExp(`^<h1\\b[^>]*>[\\s]*?(${matchTextEscaped})[\\s]*?<\\/h1>`, 'gim')
-      // /^(.*)\n={3,}/
-      const FIRST_UNDERSCORE_H1 = new RegExp(`^(${matchTextEscaped})\n={3,}`, 'gim')
-  
-      if (contents.match(FIRST_H1_REGEX)) {
-        docHasHeading = matchText
-      } else if (contents.match(FIRST_HTML_H1_REGEX)) {
-        docHasHeading = matchText
-      } else if (contents.match(FIRST_UNDERSCORE_H1)) {
-        docHasHeading = matchText
-      }
-    }
-  
-    if (debugFileMatch) {
-      console.log('matchText', matchText)
-      if (docHasHeading) {
-        console.log('Found heading 1', docHasHeading)
-      }
-    }
-
-    if (debugFileMatch) {
-      console.log('top level toc item count', countOfH1s)
-      if (docHasHeading) {
-        console.log('Found heading 1', docHasHeading)
-        console.log('firstH1', firstH1)
-      }
-    }
-
-    let firstItemWithContent
-    let foundFirstH1
-
-    if (docHasHeading) {
-      outputText = lines.reduce((acc, line, i) => {
-        const isLineEmpty = line === ''
-        if (!isLineEmpty && !firstItemWithContent) {
-          firstItemWithContent = i
-        }
-        if (!foundFirstH1 && (firstItemWithContent === i) && line.match(/^-\s+/)) {
-          foundFirstH1 = true
-          return acc
-        }
-        // Add back line and remove level
-        let newLineValue = line
-        if (lineText) {
-          // const untilFirstH1 = i < lineIndex
-          /* @TODO make option? flatten all non first h1 tags */
-          if (countOfH1s > 0 && !isLineEmpty && newLineValue.match(/^\s+-/)) {
-            newLineValue = line.substring(2)
-          }
-        }
-        
-        acc = acc.concat(newLineValue)
-        return acc
-      }, []).join('\n')
-    }
- 
-    // console.log('outputText', outputText)
-    if (debugFileMatch) {
-      console.log('after firsth1 removal', outputText)
-    }
-  }
-  // console.log(t)
-  // Fix <h1> with multiple lines
-  const spaces = outputText.match(/\[\n([\s\S]*?)\]/gm)
-  if (spaces) {
-    const fixed = spaces[0]
-      // all new lines
-      .replace(/\n/g, '')
-      // leading spaces
-      .replace(/\[\s+/, '[')
-      .trim()
-    outputText = outputText.replace(spaces[0], fixed)
-  }
-  // console.log(outputText)
-  outputText = outputText
-    .replace(/(.*)\[Table of Contents\]\(.*\)\n?/i, '')
-    .replace(/(.*)\[toc\]\(.*\)\n?/i, '')
-
-
-  if (opts.excludeText) {
-
-    outputText = excludeTocItem(outputText, opts.excludeText)
-    // // (\s+)?-(.*)\[Usage\]\(.*\)
-    // const regex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)`, 'i')
-    // // /(\s+)?-(.*)\[Usage\]\(.*\)(\n\s+(.*))+/im
-    // const nestedRegex = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s+\(.*\)\)+`, 'i')
-    
-    // const hasNested = nestedRegex.exec(outputText)
-    // if (hasNested) {
-    //   // Count indentation of spaces
-    //   const numberOfSpaces = hasNested[1].replace(/\n/g, '').length
-    //   const subItems = numberOfSpaces + 1
-    //   // Update regex to only remove sub items
-    //   const nestedRegexSpaces = new RegExp(`\(\\s+\)?-(.*)\\[${opts.excludeText}\\]\\(.*\\)\(\\n\\s{${subItems},}\(.*\)\)+`, 'i')
-    //   // console.log('nestedRegexSpaces', nestedRegexSpaces)
-    //   // If exclude value has nested sections remove them as well.
-    //   outputText = outputText.replace(nestedRegexSpaces, '')
-    //   outputText = outputText.replace(regex, '')
-    // } else {
-    //   outputText = outputText.replace(regex, '')
-    // }
-  }
-
-  /* Sub table of contents */
-  if (isSub) {
-    // const start = fileContent.indexOf(open.value)
-    // const linesBefore = fileContent.substr(0, start).split('\n')
-    // const closestHeading = linesBefore.reverse().find((line) => {
-    //   return line.match((/^#+/))
-    // })
-    const linesBefore = originalContents.substr(0, block.start).split('\n')
-    const closestHeading = linesBefore.reverse().find((line) => {
-      return line.match((/^#+/))
-    })
-
-    if (closestHeading) {
-      const headingText = closestHeading.replace(/^#*\s*/, '')
-      // console.log('BEFORE', linesBefore)
-      // console.log('closest parent heading', closestHeading)
-      // console.log('headingText', headingText)
-      // https://regex101.com/r/MB85zm/1
-
-      const findSubToc = new RegExp(`^\(\\s+\)?-(.*)\\[${headingText}\\]\\(.*\\)(\\n\\s.*)+`, 'gm')
-      // console.log('findSubToc', findSubToc)
-      const single = singleLinePattern(headingText)
-      // console.log('single', single)
-      const subItems = outputText.match(findSubToc)
-      if (subItems) {
-        const items = subItems[0].replace(single, '').split('\n')
-          .filter(Boolean)
-        // console.log('items', items)
-        const finalItems = items // .slice(1, items.length)
-        if (finalItems) {
-          const indent = findMinIndent(finalItems.join('\n'))
-          // console.log('min indent', indent)
-          // console.log('finalItems', finalItems)
-          outputText = finalItems.map((thing) => thing.substring(indent)).join('\n')
-        } else {
-          // console.log('No sub items')
-        }
-      }
-    }
-  }
-
-  // If collapse wrap in <details>
-  if (opts.collapse) {
-    const text = (opts.collapseText) ? opts.collapseText : 'Table of Contents'
-    return `<details>
-<summary>${text}</summary>
-${outputText   
-  // Replace leading double spaces
-  .replace(/^\n\n/, '\n')
-  // Replace trailing double spaces
-  .replace(/\n\n$/, '\n')}
-</details>`
-  }
-
-  return outputText.replace(removeLeadingAndTrailingLineBreaks, '')
-}
-
-const HTML_TAG = /<([a-zA-Z1-6]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)/gim
-
-function parseHtmlProps(mdContents) {
-  const htmlTags = mdContents
-    /* Fix non terminating <tags> */
-    .replace(/(['"`]<(.*)>['"`])/gm, '_$2_')
-    .match(HTML_TAG)
-  //console.log('htmlTags', htmlTags)
-
-  let tags = []
-  if (htmlTags) {
-    let propsValues = {}
-    var regexSingleTag = /<([a-zA-Z1-6]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)/
-    for (var i = 0; i < htmlTags.length; 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) {
-            return {
-              ...acc,
-              [`${propWithValue[1]}`]: (hasQuotes) ? propWithValue[2] : convert(propWithValue[2])
-            }
-          }
-          // Check isLoading boolean props
-          const booleanProp = curr.match(/([A-Za-z]*)/)
-          if (booleanProp) {
-            return {
-              ...acc,
-              [`${booleanProp[1]}`]: true
-            }
-          }
-          return acc
-        }, {})
-      }
-
-      tags.push({
-        tag: tag,
-        props: propsValues,
-        raw: match
-      })
-    }
-  }
-  return tags
-}
-
-function singleLinePattern(text) {
-  /* (\s+)?-(.*)\[Usage\]\(.*\) */
-  return new RegExp(`\(\\s+\)?-(.*)\\[${text}\\]\\(.*\\)`, 'i')
-}
-
-function excludeTocItem(str, excludeText) {
-  const matchTextEscaped = escapeRegexString(excludeText)
-  /* (\s+)?-(.*)\[Usage\]\(.*\) */
-  const regex = singleLinePattern(matchTextEscaped) // new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)`, 'i')
-  /* /(\s+)?-(.*)\[Usage\]\(.*\)(\n\s+(.*))+/im */
-  const nestedRegex = new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)\(\\n\\s+\(.*\)\)+`, 'i')
-  
-  const hasNested = nestedRegex.exec(str)
-  if (hasNested) {
-    // Count indentation of spaces
-    const numberOfSpaces = (hasNested[1] || '').replace(/\n/g, '').length
-    const subItems = numberOfSpaces + 1
-    // Update regex to only remove sub items
-    const nestedRegexSpaces = new RegExp(`\(\\s+\)?-(.*)\\[${matchTextEscaped}\\]\\(.*\\)\(\\n\\s{${subItems},}\(.*\)\)+`, 'i')
-    // console.log('nestedRegexSpaces', nestedRegexSpaces)
-    // If exclude value has nested sections remove them as well.
-    str = str.replace(nestedRegexSpaces, '')
-    str = str.replace(regex, '')
-  } else {
-    str = str.replace(regex, '')
-  }
-  return str
-}
-
-function removeUndefined(outputText) {
-  // remove undefined from new line and start of string if first H1 is missing
-  return outputText.replace(/\nundefined/g, '\n-').replace(/^undefined/g, '-')
-}
-
-// Alt https://github.com/thlorenz/doctoc
+  const { options, fileContent, srcPath, getBlockDetails } = api
+  const toc = await generateToc({
+    options: options || {},
+    fileContent,
+    srcPath,
+    getBlockDetails: getBlockDetails
+  })
+  return toc
+}

package/lib/types.js

@@ -0,0 +1,11 @@
+/**
+ * Allowed file syntaxes
+ * @typedef {'md' | 'js' | 'yml' | 'yaml'} SyntaxType
+ */
+
+/** @type {SyntaxType} */
+const syntaxType = 'md'
+
+module.exports = {
+  syntaxType
+}