Add support for options in extensions

Author: wooorm

lib/index.js

@@ -2,27 +2,39 @@ module.exports = toMarkdown
 
 var zwitch = require('zwitch')
 var defaultHandlers = require('./handle')
-var defaultUnsafePatterns = require('./unsafe')
+var defaultUnsafe = require('./unsafe')
 var defaultJoin = require('./join')
 
 function toMarkdown(tree, options) {
   var settings = options || {}
-  var extensions = configure(settings)
-  var stack = []
-  var handle = zwitch('type', {
-    invalid: invalid,
-    unknown: unknown,
-    handlers: extensions.handlers
-  })
   var context = {
-    handle: handle,
-    stack: stack,
     enter: enter,
-    options: settings,
-    unsafePatterns: extensions.unsafe,
-    join: extensions.join
+    stack: [],
+    unsafe: [],
+    join: [],
+    handlers: {},
+    options: {}
+  }
+  var result
+
+  configure(context, {
+    unsafe: defaultUnsafe,
+    join: defaultJoin,
+    handlers: defaultHandlers
+  })
+  configure(context, settings)
+
+  if (context.options.tightDefinitions) {
+    context.join = [joinDefinition].concat(context.join)
   }
-  var result = handle(tree, null, context, {before: '\n', after: '\n'})
+
+  context.handle = zwitch('type', {
+    invalid: invalid,
+    unknown: unknown,
+    handlers: context.handlers
+  })
+
+  result = context.handle(tree, null, context, {before: '\n', after: '\n'})
 
   if (
     result &&
@@ -35,11 +47,11 @@ function toMarkdown(tree, options) {
   return result
 
   function enter(name) {
-    stack.push(name)
+    context.stack.push(name)
     return exit
 
     function exit() {
-      stack.pop()
+      context.stack.pop()
     }
   }
 }
@@ -52,26 +64,30 @@ function unknown(node) {
   throw new Error('Cannot handle unknown node `' + node.type + '`')
 }
 
-function configure(settings) {
-  var extensions = [
-    {unsafe: settings.unsafe, handlers: settings.handlers, join: settings.join}
-  ].concat(settings.extensions || [])
-  var unsafe = defaultUnsafePatterns
-  var join = defaultJoin
-  var handlers = Object.assign({}, defaultHandlers)
+function configure(base, extension) {
   var index = -1
+  var key
 
-  if (settings.tightDefinitions) {
-    join = [joinDefinition].concat(join)
+  // First do subextensions.
+  if (extension.extensions) {
+    while (++index < extension.extensions.length) {
+      configure(base, extension.extensions[index])
+    }
   }
 
-  while (++index < extensions.length) {
-    unsafe = unsafe.concat(extensions[index].unsafe || [])
-    join = join.concat(extensions[index].join || [])
-    Object.assign(handlers, extensions[index].handlers || {})
+  for (key in extension) {
+    if (key === 'extensions') {
+      // Empty.
+    } else if (key === 'unsafe' || key === 'join') {
+      base[key] = base[key].concat(extension[key] || [])
+    } else if (key === 'handlers') {
+      base[key] = Object.assign(base[key], extension[key] || {})
+    } else {
+      base.options[key] = extension[key]
+    }
   }
 
-  return {unsafe: unsafe, join: join, handlers: handlers}
+  return base
 }
 
 function joinDefinition(left, right) {

lib/util/safe.js

@@ -15,8 +15,8 @@ function safe(context, input, config) {
   var start
   var end
 
-  while (++index < context.unsafePatterns.length) {
-    pattern = context.unsafePatterns[index]
+  while (++index < context.unsafe.length) {
+    pattern = context.unsafe[index]
 
     if (
       !inScope(context.stack, pattern.inConstruct, true) ||

readme.md

@@ -146,15 +146,6 @@ function (left, right) {
 }
 ```
 
-##### Extension options
-
-###### `options.extensions`
-
-List of extensions (`Array.<ToMarkdownExtension>`).
-Each `ToMarkdownExtension` is an object with optional `handlers`, `join`, and
-`unsafe` keys, mapping to the values which can also be passed in directly,
-documented below.
-
 ###### `options.handlers`
 
 Object mapping node types to custom handlers.
@@ -188,6 +179,14 @@ List of patterns to escape.
 Useful for syntax extensions.
 Take a look at [`lib/unsafe.js`][unsafe] for examples.
 
+##### Extension options
+
+###### `options.extensions`
+
+List of extensions (`Array.<ToMarkdownExtension>`).
+Each `ToMarkdownExtension` is an object with the same interface as `options`
+here.
+
 ##### Returns
 
 `string` — Serialized markdown.

test.js

@@ -2530,6 +2530,61 @@ test('escape', function (t) {
     'should not escape what can’t be a list (dot)'
   )
 
+  t.equal(
+    to(
+      {
+        type: 'root',
+        children: [
+          {type: 'definition', label: 'a'},
+          {type: 'definition', label: 'b'}
+        ]
+      },
+      {extensions: [{tightDefinitions: true}]}
+    ),
+    '[a]: <>\n[b]: <>\n',
+    'should support options in extensions'
+  )
+
+  t.equal(
+    to(
+      {
+        type: 'root',
+        children: [{type: 'strong', children: [{type: 'text', value: 'a'}]}]
+      },
+      {
+        extensions: [
+          {strong: '_', join: null, handlers: null, extensions: null}
+        ]
+      }
+    ),
+    '__a__\n',
+    'should support empty `join`, `handlers`, `extensions` in an extension (coverage)'
+  )
+
+  t.equal(
+    to(
+      {
+        type: 'root',
+        children: [{type: 'strong', children: [{type: 'text', value: 'a'}]}]
+      },
+      {strong: '*', extensions: [{strong: '_'}]}
+    ),
+    '**a**\n',
+    'should prefer main options over extension options'
+  )
+
+  t.equal(
+    to(
+      {
+        type: 'root',
+        children: [{type: 'strong', children: [{type: 'text', value: 'a'}]}]
+      },
+      {extensions: [{strong: '*', extensions: [{strong: '_'}]}]}
+    ),
+    '**a**\n',
+    'should prefer extension options over subextension options'
+  )
+
   t.end()
 })
 

types/index.d.ts

@@ -20,7 +20,7 @@ declare namespace toMarkdown {
     stack: string[]
     enter: (type: string) => () => void
     options: Options
-    unsafePatterns: Unsafe[]
+    unsafe: Unsafe[]
     join: Join[]
     handle: Handle
   }
@@ -55,12 +55,6 @@ declare namespace toMarkdown {
     context: Context
   ) => boolean | null | void
 
-  interface Extension {
-    handlers?: Handlers
-    join?: Join[]
-    unsafe?: Unsafe[]
-  }
-
   interface Options {
     bullet?: '-' | '*' | '+'
     closeAtx?: boolean
@@ -77,7 +71,7 @@ declare namespace toMarkdown {
     strong?: '_' | '*'
     tightDefinitions?: boolean
 
-    extensions?: Extension[]
+    extensions?: Options[]
     handlers?: Handlers
     join?: Join[]
     unsafe?: Unsafe[]