Add quoteSmart option

Related-to: GH-12.

Author: wooorm

index.d.ts

@@ -12,6 +12,11 @@ export {directiveFromMarkdown, directiveToMarkdown} from './lib/index.js'
  * Configuration.
  */
 export interface ToMarkdownOptions {
+  /**
+   * Use the other quote if that results in less bytes
+   * (default: `false`).
+   */
+  quoteSmart?: boolean | null | undefined
   /**
    * Preferred quote to use around attribute values
    * (default: the `quote` used by `mdast-util-to-markdown` for titles).

lib/index.js

@@ -15,6 +15,7 @@
  * @import {Nodes, Paragraph} from 'mdast'
  */
 
+import {ccount} from 'ccount'
 import {ok as assert} from 'devlop'
 import {parseEntities} from 'parse-entities'
 import {stringifyEntitiesLight} from 'stringify-entities'
@@ -88,6 +89,16 @@ export function directiveFromMarkdown() {
  */
 export function directiveToMarkdown(options) {
   const settings = options || emptyOptions
+  if (
+    settings.quote !== '"' &&
+    settings.quote !== "'" &&
+    settings.quote !== null &&
+    settings.quote !== undefined
+  ) {
+    throw new Error(
+      'Invalid quote `' + settings.quote + '`, expected `\'` or `"`'
+    )
+  }
 
   handleDirective.peek = peekDirective
 
@@ -181,12 +192,6 @@ export function directiveToMarkdown(options) {
    * @returns {string}
    */
   function attributes(node, state) {
-    // If the alternative is less common than `quote`, switch.
-    const appliedQuote = settings.quote || state.options.quote || '"'
-    const subset =
-      node.type === 'textDirective'
-        ? [appliedQuote]
-        : [appliedQuote, '\n', '\r']
     const attributes = node.attributes || {}
     /** @type {Array<string>} */
     const values = []
@@ -208,7 +213,9 @@ export function directiveToMarkdown(options) {
         const value = String(attributes[key])
 
         if (key === 'id') {
-          id = shortcut.test(value) ? '#' + value : quoted('id', value)
+          id = shortcut.test(value)
+            ? '#' + value
+            : quoted('id', value, node, state)
         } else if (key === 'class') {
           const list = value.split(/[\t\n\r ]+/g)
           /** @type {Array<string>} */
@@ -225,11 +232,11 @@ export function directiveToMarkdown(options) {
 
           classesFull =
             classesFullList.length > 0
-              ? quoted('class', classesFullList.join(' '))
+              ? quoted('class', classesFullList.join(' '), node, state)
               : ''
           classes = classesList.length > 0 ? '.' + classesList.join('.') : ''
         } else {
-          values.push(quoted(key, value))
+          values.push(quoted(key, value, node, state))
         }
       }
     }
@@ -247,23 +254,39 @@ export function directiveToMarkdown(options) {
     }
 
     return values.length > 0 ? '{' + values.join(' ') + '}' : ''
+  }
 
-    /**
-     * @param {string} key
-     * @param {string} value
-     * @returns {string}
-     */
-    function quoted(key, value) {
-      return (
-        key +
-        (value
-          ? '=' +
-            appliedQuote +
-            stringifyEntitiesLight(value, {subset}) +
-            appliedQuote
-          : '')
-      )
-    }
+  /**
+   * @param {string} key
+   * @param {string} value
+   * @param {Directives} node
+   * @param {State} state
+   * @returns {string}
+   */
+  function quoted(key, value, node, state) {
+    if (!value) return key
+
+    // If the alternative is less common than `quote`, switch.
+    const preferred = settings.quote || state.options.quote || '"'
+    const alternative = preferred === '"' ? "'" : '"'
+    // If the alternative is less common than `quote`, switch.
+    const appliedQuote =
+      settings.quoteSmart &&
+      ccount(value, preferred) > ccount(value, alternative)
+        ? alternative
+        : preferred
+    const subset =
+      node.type === 'textDirective'
+        ? [appliedQuote]
+        : [appliedQuote, '\n', '\r']
+
+    return (
+      key +
+      ('=' +
+        appliedQuote +
+        stringifyEntitiesLight(value, {subset}) +
+        appliedQuote)
+    )
   }
 }
 

package.json

@@ -7,6 +7,7 @@
   "dependencies": {
     "@types/mdast": "^4.0.0",
     "@types/unist": "^3.0.0",
+    "ccount": "^2.0.0",
     "devlop": "^1.0.0",
     "mdast-util-from-markdown": "^2.0.0",
     "mdast-util-to-markdown": "^2.0.0",

readme.md

@@ -264,6 +264,9 @@ Configuration.
 
 ###### Parameters
 
+* `quoteSmart`
+  (`boolean`, default: `false`)
+  — use the other quote if that results in less bytes
 * `quote`
   (`'"'` or `"'"`,
   default: the [`quote`][quote] used by `mdast-util-to-markdown` for titles)

test.js

@@ -1132,12 +1132,169 @@ test('directiveToMarkdown()', async function (t) {
             attributes: {title: 'a'},
             children: []
           },
-          {
-            extensions: [directiveToMarkdown({quote: "'"})]
-          }
+          {extensions: [directiveToMarkdown({quote: "'"})]}
         ),
         ":i{title='a'}\n"
       )
     }
   )
+
+  await t.test(
+    "should quote attribute values with double quotes if `quote: '\\\"'`",
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: 'a'},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quote: '"'})]}
+        ),
+        ':i{title="a"}\n'
+      )
+    }
+  )
+
+  await t.test(
+    "should quote attribute values with single quotes if `quote: '\\''` even if they occur in value",
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: "'a'"},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quote: "'"})]}
+        ),
+        ":i{title=''a''}\n"
+      )
+    }
+  )
+
+  await t.test(
+    "should quote attribute values with double quotes if `quote: '\\\"'` even if they occur in value",
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: '"a"'},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quote: '"'})]}
+        ),
+        ':i{title=""a""}\n'
+      )
+    }
+  )
+
+  await t.test('should throw on invalid quotes', async function () {
+    assert.throws(function () {
+      toMarkdown(
+        {
+          type: 'textDirective',
+          name: 'i',
+          attributes: {},
+          children: []
+        },
+        // @ts-expect-error: check how the runtime handles an incorrect `quote`
+        {extensions: [directiveToMarkdown({quote: '`'})]}
+      )
+    }, /Invalid quote ```, expected `'` or `"`/)
+  })
+
+  await t.test(
+    'should quote attribute values with primary quotes if they occur less than the alternative',
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: "'\"a'"},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quoteSmart: true})]}
+        ),
+        ':i{title="\'"a\'"}\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should quote attribute values with primary quotes if they occur as much as alternatives (#1)',
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: '"a\''},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quoteSmart: true})]}
+        ),
+        ':i{title=""a\'"}\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should quote attribute values with primary quotes if they occur as much as alternatives (#2)',
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: '"\'a\'"'},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quoteSmart: true})]}
+        ),
+        ':i{title=""\'a\'""}\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should quote attribute values with alternative quotes if the primary occurs',
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: '"a"'},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quoteSmart: true})]}
+        ),
+        ':i{title=\'"a"\'}\n'
+      )
+    }
+  )
+
+  await t.test(
+    'should quote attribute values with alternative quotes if they occur less than the primary',
+    async function () {
+      assert.deepEqual(
+        toMarkdown(
+          {
+            type: 'textDirective',
+            name: 'i',
+            attributes: {title: '"\'a"'},
+            children: []
+          },
+          {extensions: [directiveToMarkdown({quoteSmart: true})]}
+        ),
+        ':i{title=\'"'a"\'}\n'
+      )
+    }
+  )
 })