Change types to use mdast types

Author: wooorm

index.js

@@ -1,7 +1,6 @@
 /**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-visit').Visitor<Node>} Visitor
+ * @typedef {import('mdast').Root|import('mdast').Content} Node
+ * @typedef {Extract<Node, import('mdast').Parent>} Parent
  *
  * @typedef ZoneInfo
  * @property {number} start
@@ -32,50 +31,52 @@ export function zone(node, name, callback) {
   /** @type {Parent|undefined} */
   let scope
 
-  visit(node, gather)
+  visit(
+    node,
+    /**
+     * Gather one dimensional zones.
+     */
+    (node, index, parent) => {
+      const info = commentMarker(node)
+      const match =
+        info && info.name === name && info.attributes.match(/(start|end)\b/)
+      const type = match && match[0]
 
-  /**
-   * Gather one dimensional zones.
-   * @type {Visitor}
-   */
-  function gather(node, index, parent) {
-    const info = commentMarker(node)
-    const match =
-      info && info.name === name && info.attributes.match(/(start|end)\b/)
-    const type = match && match[0]
+      if (parent && index !== null && type) {
+        if (!scope && type === 'start') {
+          level = 0
+          marker = node
+          scope = /** @type {Parent} */ (parent)
+        }
 
-    if (parent && index !== null && type) {
-      if (!scope && type === 'start') {
-        level = 0
-        marker = node
-        scope = parent
-      }
+        if (typeof level === 'number' && marker && scope && parent === scope) {
+          if (type === 'start') {
+            level++
+          } else {
+            level--
+          }
 
-      if (typeof level === 'number' && marker && scope && parent === scope) {
-        if (type === 'start') {
-          level++
-        } else {
-          level--
-        }
+          if (type === 'end' && !level) {
+            // @ts-expect-error: Assume `scope` is a valid parent of `node`.
+            const start = scope.children.indexOf(marker)
 
-        if (type === 'end' && !level) {
-          const start = scope.children.indexOf(marker)
+            const result = callback(
+              marker,
+              scope.children.slice(start + 1, index),
+              node,
+              {start, end: index, parent: scope}
+            )
 
-          const result = callback(
-            marker,
-            scope.children.slice(start + 1, index),
-            node,
-            {start, end: index, parent}
-          )
+            if (result) {
+              // @ts-expect-error: Assume the correct children are passed.
+              scope.children.splice(start, index - start + 1, ...result)
+            }
 
-          if (result) {
-            scope.children.splice(start, index - start + 1, ...result)
+            marker = undefined
+            scope = undefined
           }
-
-          marker = undefined
-          scope = undefined
         }
       }
     }
-  }
+  )
 }

package.json

@@ -35,8 +35,8 @@
     "index.js"
   ],
   "dependencies": {
-    "@types/mdast": "^3.0.3",
-    "@types/unist": "^2.0.3",
+    "@types/mdast": "^3.0.0",
+    "@types/unist": "^2.0.0",
     "mdast-comment-marker": "^2.0.0",
     "unist-util-visit": "^3.0.0"
   },

test/fixtures/mismatched/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
   zone(tree, 'foo', handle)

test/fixtures/nodes/index.js

@@ -1,7 +1,9 @@
+import assert from 'assert'
+
 /**
  * @param {import('tape').Test} t
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(t, zone, tree) {
   let count = 0
@@ -16,12 +18,12 @@ export default function assertion(t, zone, tree) {
       st.equal(nodes.length, 1)
       const head = nodes[0]
       st.equal(head.type, 'paragraph')
-      // @ts-expect-error: too vague.
+      assert(head.type === 'paragraph')
       st.equal(head.children.length, 1)
-      // @ts-expect-error: too vague.
-      st.equal(head.children[0].type, 'text')
-      // @ts-expect-error: too vague.
-      st.equal(head.children[0].value, 'Foo.')
+      const headHead = head.children[0]
+      st.equal(headHead.type, 'text')
+      assert(headHead.type === 'text')
+      st.equal(headHead.value, 'Foo.')
       st.equal(++count, 1)
     }
   })

test/fixtures/non-marker/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
   zone(tree, 'foo', handle)

test/fixtures/range-children/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} t
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(t, zone, tree) {
   let count = 0

test/fixtures/remove-children/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
   zone(tree, 'foo', handle)

test/fixtures/remove/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
   zone(tree, 'foo', handle)

test/fixtures/replace-children/index.js

@@ -1,7 +1,7 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
   zone(tree, 'foo', handle)

test/fixtures/replace/index.js

@@ -1,18 +1,14 @@
 /**
  * @param {import('tape').Test} _
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(_, zone, tree) {
-  zone(tree, 'foo', handle)
-
-  function handle() {
-    return [
-      {
-        type: 'heading',
-        depth: 2,
-        children: [{type: 'text', value: 'Bar'}]
-      }
-    ]
-  }
+  zone(tree, 'foo', () => [
+    {
+      type: 'heading',
+      depth: 2,
+      children: [{type: 'text', value: 'Bar'}]
+    }
+  ])
 }

test/fixtures/simple/index.js

@@ -1,7 +1,9 @@
+import assert from 'assert'
+
 /**
  * @param {import('tape').Test} t
  * @param {import('../../../index.js').zone} zone
- * @param {import('unist').Node} tree
+ * @param {import('mdast').Root} tree
  */
 export default function assertion(t, zone, tree) {
   t.test('range', (st) => {
@@ -12,11 +14,11 @@ export default function assertion(t, zone, tree) {
     /** @type {import('../../../index.js').Handler} */
     function handle(start, nodes, end) {
       st.equal(start.type, 'html')
-      // @ts-expect-error: too vague.
+      assert(start.type === 'html')
       st.equal(start.value, '<!--foo start bar="baz"-->')
       st.deepEqual(nodes, [])
       st.equal(end.type, 'html')
-      // @ts-expect-error: too vague.
+      assert(end.type === 'html')
       st.equal(end.value, '<!--foo end qux="quux"-->')
     }
   })

test/index.js

@@ -1,6 +1,6 @@
 /**
  * @typedef {import('tape').Test} Test
- * @typedef {import('unist').Node} Node
+ * @typedef {import('mdast').Root} Root
  * @typedef {import('../index.js').zone} Zone
  */
 
@@ -28,7 +28,7 @@ test('mdast-zone', async (t) => {
     } catch {}
 
     /* eslint-disable no-await-in-loop */
-    /** @type {(t: Test, zone: Zone, node: Node) => void} */
+    /** @type {(t: Test, zone: Zone, node: Root) => void} */
     const mod =
       // @ts-ignore hush.
       (await import(new URL('fixtures/' + name + '/index.js', import.meta.url)))
@@ -37,7 +37,7 @@ test('mdast-zone', async (t) => {
 
     remark()
       .use(() => (tree) => {
-        mod(t, zone, tree)
+        mod(t, zone, /** @type {Root} */ (tree))
       })
       .process(
         fs.readFileSync(path.join(root, name, 'input.md')),