Refactor tests to use improved types

Author: wooorm

.gitignore

@@ -5,3 +5,4 @@ coverage/
 node_modules/
 yarn.lock
 !/index.d.ts
+!/test/types.d.ts

lib/state.js

@@ -276,12 +276,12 @@ function applyData(from, to) {
 
         // To do: next major: take the children from the `root`, or inject the
         // raw/text/comment or so into the element?
-        // if ('children' in node) {
+        // if ('children' in from) {
         //   // @ts-expect-error: assume `children` are allowed in elements.
-        //   result.children = node.children
+        //   result.children = from.children
         // } else {
         //   // @ts-expect-error: assume `node` is allowed in elements.
-        //   result.children.push(node)
+        //   result.children.push(from)
         // }
       }
     }

test/core.js

@@ -19,8 +19,13 @@ test('toHast', async function (t) {
 
   await t.test('should throw on non-nodes', async function () {
     assert.throws(function () {
-      // @ts-expect-error: check that non-node children throw at runtime.
-      toHast({type: 'bar', children: [true]})
+      toHast({
+        type: 'paragraph',
+        children: [
+          // @ts-expect-error: check that non-node children throw at runtime.
+          true
+        ]
+      })
     })
   })
 
@@ -255,10 +260,8 @@ test('toHast', async function (t) {
   const customMdast = {
     type: 'paragraph',
     children: [
-      // @ts-expect-error: check how a custom literal is handled.
-      {type: 'a', value: 'alpha'},
-      // @ts-expect-error: check how a custom parent is handled.
-      {type: 'b', children: [{type: 'image', url: 'bravo'}]},
+      {type: 'alpha', value: 'alpha'},
+      {type: 'bravo', children: [{type: 'image', url: 'bravo'}]},
       {type: 'text', value: 'charlie'}
     ]
   }
@@ -297,29 +300,21 @@ test('toHast', async function (t) {
   await t.test('should support `unknownHandler`', async function () {
     assert.deepEqual(
       toHast(customMdast, {
-        // To do: improved test.
-        // @ts-expect-error `hast` expected, but this returns unknown mdast nodes.
-        unknownHandler(_, /** @type {Nodes} */ node) {
-          return node
+        unknownHandler() {
+          return {type: 'text', value: 'unknown!'}
         }
       }),
-      h('p', [
-        {type: 'a', value: 'alpha'},
-        // To do: register custom?
-        // @ts-expect-error: custom.
-        {type: 'b', children: [{type: 'image', url: 'bravo'}]},
-        'charlie'
-      ])
+      h('p', ['unknown!', 'unknown!', 'charlie'])
     )
   })
 
   await t.test('should support `passThrough`', async function () {
     assert.deepEqual(
-      toHast(customMdast, {passThrough: ['a', 'b']}),
+      toHast(customMdast, {passThrough: ['alpha', 'bravo']}),
       h('p', [
-        {type: 'a', value: 'alpha'},
-        // @ts-expect-error: custom.
-        {type: 'b', children: [h('img', {src: 'bravo'})]},
+        {type: 'alpha', value: 'alpha'},
+        // @ts-expect-error: to do: remove when `hastscript` is released.
+        {type: 'bravo', children: [h('img', {src: 'bravo'})]},
         'charlie'
       ])
     )

test/toml.js

@@ -4,12 +4,9 @@ import {toHast} from '../index.js'
 
 test('toml', async function (t) {
   await t.test('should ignore `toml`', async function () {
-    assert.deepEqual(
-      // To do: register in test types.
-      // @ts-expect-error: check how a `toml` node is handled (not registered
-      // normally, but supported here).
-      toHast({type: 'toml', value: 'alpha'}),
-      {type: 'root', children: []}
-    )
+    assert.deepEqual(toHast({type: 'toml', value: 'alpha'}), {
+      type: 'root',
+      children: []
+    })
   })
 })

test/types.d.ts

@@ -0,0 +1,73 @@
+import type {
+  Data as DataHast,
+  ElementContent as ElementContentHast,
+  Literal as LiteralHast,
+  Parent as ParentHast
+} from 'hast'
+import type {Data, Literal, Parent, PhrasingContent} from 'mdast'
+
+interface Alpha extends Literal {
+  type: 'alpha'
+  data?: AlphaData | undefined
+}
+
+interface AlphaData extends Data {}
+
+interface Bravo extends Parent {
+  type: 'bravo'
+  children: PhrasingContent[]
+  data?: BravoData | undefined
+}
+
+interface BravoData extends Data {}
+
+interface Toml extends Literal {
+  type: 'toml'
+  data?: TomlData | undefined
+}
+
+interface TomlData extends Data {}
+
+interface AlphaHast extends LiteralHast {
+  type: 'alpha'
+  data?: AlphaDataHast | undefined
+}
+
+interface AlphaDataHast extends DataHast {}
+
+interface BravoHast extends ParentHast {
+  type: 'bravo'
+  children: ElementContentHast[]
+  data?: BravoDataHast | undefined
+}
+
+interface BravoDataHast extends DataHast {}
+
+declare module 'hast' {
+  interface ElementContentMap {
+    alpha: AlphaHast
+    bravo: BravoHast
+  }
+
+  interface RootContentMap {
+    alpha: AlphaHast
+    bravo: BravoHast
+  }
+}
+
+declare module 'mdast' {
+  interface FrontmatterContentMap {
+    toml: Toml
+  }
+
+  interface PhrasingContentMap {
+    alpha: Alpha
+    bravo: Bravo
+  }
+
+  interface RootContentMap {
+    alpha: Alpha
+    bravo: Bravo
+    toml: Toml
+  }
+}

tsconfig.json

@@ -11,5 +11,5 @@
     "target": "es2020"
   },
   "exclude": ["coverage/", "node_modules/"],
-  "include": ["**/*.js", "index.d.ts"]
+  "include": ["**/*.js", "test/types.d.ts", "index.d.ts"]
 }