Refactor some more code

Author: wooorm

lib/state.js

@@ -134,14 +134,14 @@ export function createState(tree, options) {
 
   /** @type {State} */
   const state = {
-    all: allBound,
+    all,
     applyData,
     definitionById,
     footnoteById,
     footnoteCounts,
     footnoteOrder: [],
     handlers,
-    one: oneBound,
+    one,
     options: settings,
     patch,
     wrap
@@ -173,8 +173,22 @@ export function createState(tree, options) {
    * @returns {Array<HastElementContent> | HastElementContent | undefined}
    *   Resulting hast node.
    */
-  function oneBound(node, parent) {
-    return one(state, node, parent)
+  function one(node, parent) {
+    const type = node.type
+
+    if (own.call(state.handlers, type)) {
+      return state.handlers[type](state, node, parent)
+    }
+
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      // To do: next major: deep clone.
+      // @ts-expect-error: types of passed through nodes are expected to be added manually.
+      return 'children' in node ? {...node, children: state.all(node)} : node
+    }
+
+    const unknown = state.options.unknownHandler || defaultUnknownHandler
+
+    return unknown(state, node, parent)
   }
 
   /**
@@ -185,8 +199,42 @@ export function createState(tree, options) {
    * @returns {Array<HastElementContent>}
    *   Resulting hast nodes.
    */
-  function allBound(parent) {
-    return all(state, parent)
+  function all(parent) {
+    /** @type {Array<HastElementContent>} */
+    const values = []
+
+    if ('children' in parent) {
+      const nodes = parent.children
+      let index = -1
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent)
+
+        // To do: see if we van clean this? Can we merge texts?
+        if (result) {
+          if (index && nodes[index - 1].type === 'break') {
+            if (!Array.isArray(result) && result.type === 'text') {
+              result.value = result.value.replace(/^\s+/, '')
+            }
+
+            if (!Array.isArray(result) && result.type === 'element') {
+              const head = result.children[0]
+
+              if (head && head.type === 'text') {
+                head.value = head.value.replace(/^\s+/, '')
+              }
+            }
+          }
+
+          if (Array.isArray(result)) {
+            values.push(...result)
+          } else {
+            values.push(result)
+          }
+        }
+      }
+    }
+
+    return values
   }
 }
 
@@ -237,12 +285,7 @@ function applyData(from, to) {
       // The intent is likely to keep the content around (otherwise: pass
       // `hChildren`).
       else {
-        result = {
-          type: 'element',
-          tagName: hName,
-          properties: {},
-          children: []
-        }
+        result = {type: 'element', tagName: hName, properties: {}, children: []}
 
         // To do: next major: take the children from the `root`, or inject the
         // raw/text/comment or so into the element?
@@ -274,86 +317,6 @@ function applyData(from, to) {
   return result
 }
 
-/**
- * Transform an mdast node into a hast node.
- *
- * @param {State} state
- *   Info passed around.
- * @param {MdastNodes} node
- *   mdast node.
- * @param {MdastParents | undefined} [parent]
- *   Parent of `node`.
- * @returns {Array<HastElementContent> | HastElementContent | undefined}
- *   Resulting hast node.
- */
-// To do: next major: do not expose, keep bound.
-export function one(state, node, parent) {
-  const type = node.type
-
-  if (own.call(state.handlers, type)) {
-    return state.handlers[type](state, node, parent)
-  }
-
-  if (state.options.passThrough && state.options.passThrough.includes(type)) {
-    // To do: next major: deep clone.
-    // @ts-expect-error: types of passed through nodes are expected to be added manually.
-    return 'children' in node ? {...node, children: all(state, node)} : node
-  }
-
-  const unknown = state.options.unknownHandler || defaultUnknownHandler
-
-  return unknown(state, node, parent)
-}
-
-/**
- * Transform the children of an mdast node into hast nodes.
- *
- * @param {State} state
- *   Info passed around.
- * @param {MdastNodes} parent
- *   mdast node to compile
- * @returns {Array<HastElementContent>}
- *   Resulting hast nodes.
- */
-// To do: next major: do not expose, keep bound.
-export function all(state, parent) {
-  /** @type {Array<HastElementContent>} */
-  const values = []
-
-  if ('children' in parent) {
-    const nodes = parent.children
-    let index = -1
-    while (++index < nodes.length) {
-      const result = one(state, nodes[index], parent)
-
-      // To do: see if we van clean this? Can we merge texts?
-      if (result) {
-        if (index && nodes[index - 1].type === 'break') {
-          if (!Array.isArray(result) && result.type === 'text') {
-            result.value = result.value.replace(/^\s+/, '')
-          }
-
-          if (!Array.isArray(result) && result.type === 'element') {
-            const head = result.children[0]
-
-            if (head && head.type === 'text') {
-              head.value = head.value.replace(/^\s+/, '')
-            }
-          }
-        }
-
-        if (Array.isArray(result)) {
-          values.push(...result)
-        } else {
-          values.push(result)
-        }
-      }
-    }
-  }
-
-  return values
-}
-
 /**
  * Transform an unknown node.
  *
@@ -375,7 +338,7 @@ function defaultUnknownHandler(state, node) {
           type: 'element',
           tagName: 'div',
           properties: {},
-          children: all(state, node)
+          children: state.all(node)
         }
 
   state.patch(node, result)