Refactor code-style

Author: wooorm

index.js

@@ -1,6 +1,6 @@
 /**
- * @typedef {import('./lib/index.js').Props} Props
  * @typedef {import('./lib/index.js').ChildrenOrValue} ChildrenOrValue
+ * @typedef {import('./lib/index.js').Props} Props
  */
 
 export {u} from './lib/index.js'

index.test-d.ts

@@ -1,5 +1,5 @@
-import {expectType, expectAssignable} from 'tsd'
-import type {Text, List, ListItem, HTML} from 'mdast'
+import {expectAssignable, expectType} from 'tsd'
+import type {HTML, List, ListItem, Text} from 'mdast'
 import {u} from './index.js'
 
 expectType<{type: 'example'}>(u('example'))

lib/index.js

@@ -13,54 +13,70 @@
 /**
  * Build a node.
  *
- * @param type
+ * @template {string} T
+ * @template {Props} P
+ * @template {Array<Node>} C
+ *
+ * @overload
+ * @param {T} type
+ * @returns {{type: T}}
+ *
+ * @overload
+ * @param {T} type
+ * @param {P} props
+ * @returns {{type: T} & P}
+ *
+ * @overload
+ * @param {T} type
+ * @param {string} value
+ * @returns {{type: T, value: string}}
+ *
+ * @overload
+ * @param {T} type
+ * @param {P} props
+ * @param {string} value
+ * @returns {{type: T, value: string} & P}
+ *
+ * @overload
+ * @param {T} type
+ * @param {C} children
+ * @returns {{type: T, children: C}}
+ *
+ * @overload
+ * @param {T} type
+ * @param {P} props
+ * @param {C} children
+ * @returns {{type: T, children: C} & P}
+ *
+ * @param {string} type
  *   Node type.
- * @param props
- *   Fields assigned to node.
- * @param value
+ * @param {ChildrenOrValue | Props | null | undefined} [props]
+ *   Fields assigned to node (default: `undefined`).
+ * @param {ChildrenOrValue | null | undefined} [value]
  *   Children of node or value of `node` (cast to string).
- * @returns
+ * @returns {Node}
  *   Built node.
  */
-export const u =
-  /**
-   * @type {(
-   *   (<T extends string>(type: T) => {type: T}) &
-   *   (<T extends string, P extends Props>(type: T, props: P) => {type: T} & P) &
-   *   (<T extends string>(type: T, value: string) => {type: T, value: string}) &
-   *   (<T extends string, P extends Props>(type: T, props: P, value: string) => {type: T, value: string} & P) &
-   *   (<T extends string, C extends Array<Node>>(type: T, children: C) => {type: T, children: C}) &
-   *   (<T extends string, P extends Props, C extends Array<Node>>(type: T, props: P, children: C) => {type: T, children: C} & P)
-   * )}
-   */
-  (
-    /**
-     * @param {string} type
-     * @param {Props | ChildrenOrValue | null | undefined} [props]
-     * @param {ChildrenOrValue | null | undefined} [value]
-     * @returns {Node}
-     */
-    function (type, props, value) {
-      /** @type {Node} */
-      const node = {type: String(type)}
+export function u(type, props, value) {
+  /** @type {Node} */
+  const node = {type: String(type)}
 
-      if (
-        (value === undefined || value === null) &&
-        (typeof props === 'string' || Array.isArray(props))
-      ) {
-        value = props
-      } else {
-        Object.assign(node, props)
-      }
+  if (
+    (value === undefined || value === null) &&
+    (typeof props === 'string' || Array.isArray(props))
+  ) {
+    value = props
+  } else {
+    Object.assign(node, props)
+  }
 
-      if (Array.isArray(value)) {
-        // @ts-expect-error: create a parent.
-        node.children = value
-      } else if (value !== undefined && value !== null) {
-        // @ts-expect-error: create a literal.
-        node.value = String(value)
-      }
+  if (Array.isArray(value)) {
+    // @ts-expect-error: create a parent.
+    node.children = value
+  } else if (value !== undefined && value !== null) {
+    // @ts-expect-error: create a literal.
+    node.value = String(value)
+  }
 
-      return node
-    }
-  )
+  return node
+}

readme.md

@@ -78,10 +78,10 @@ const tree = u('root', [
   ])
 ])
 
-console.dir(tree, {depth: null})
+console.dir(tree, {depth: undefined})
 ```
 
-results in the following tree:
+…yields:
 
 ```js
 {

test.js

@@ -1,43 +1,42 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {u} from './index.js'
-import * as mod from './index.js'
 
-test('u', function () {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['u'],
-    'should expose the public api'
-  )
+test('u', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), ['u'])
+  })
 
-  assert.deepEqual(
-    u('root', [
-      u('subtree', {id: 1}),
-      u('subtree', {id: 2}, [
-        u('node', [u('leaf', 'leaf-1'), u('leaf', 'leaf-2'), u('leaf', '')]),
-        u('leaf', {id: 3}, 'leaf-3')
-      ])
-    ]),
-    {
-      type: 'root',
-      children: [
-        {type: 'subtree', id: 1},
-        {
-          type: 'subtree',
-          id: 2,
-          children: [
-            {
-              type: 'node',
-              children: [
-                {type: 'leaf', value: 'leaf-1'},
-                {type: 'leaf', value: 'leaf-2'},
-                {type: 'leaf', value: ''}
-              ]
-            },
-            {type: 'leaf', id: 3, value: 'leaf-3'}
-          ]
-        }
-      ]
-    }
-  )
+  await t.test('should work', async function () {
+    assert.deepEqual(
+      u('root', [
+        u('subtree', {id: 1}),
+        u('subtree', {id: 2}, [
+          u('node', [u('leaf', 'leaf-1'), u('leaf', 'leaf-2'), u('leaf', '')]),
+          u('leaf', {id: 3}, 'leaf-3')
+        ])
+      ]),
+      {
+        type: 'root',
+        children: [
+          {type: 'subtree', id: 1},
+          {
+            type: 'subtree',
+            id: 2,
+            children: [
+              {
+                type: 'node',
+                children: [
+                  {type: 'leaf', value: 'leaf-1'},
+                  {type: 'leaf', value: 'leaf-2'},
+                  {type: 'leaf', value: ''}
+                ]
+              },
+              {type: 'leaf', id: 3, value: 'leaf-3'}
+            ]
+          }
+        ]
+      }
+    )
+  })
 })