Change to remove complex-types.d.ts

All types are now exposed from regular files (`index.js`).

Author: wooorm

complex-types.d.ts

@@ -3,7 +3,11 @@ export type {
   Action,
   ActionTuple,
   BuildVisitor,
+  // Used in `unist-util-visit`:
+  InclusiveDescendant,
   Index,
+  // Used in `unist-util-visit`:
+  Matches,
   Visitor,
   VisitorResult
 } from './lib/index.js'

index.d.ts

@@ -4,6 +4,91 @@
  * @typedef {import('unist-util-is').Test} Test
  */
 
+/**
+ * @typedef {(
+ *   Fn extends (value: any) => value is infer Thing
+ *   ? Thing
+ *   : Fallback
+ * )} Predicate
+ *   Get the value of a type guard `Fn`.
+ * @template Fn
+ *   Value; typically function that is a type guard (such as `(x): x is Y`).
+ * @template Fallback
+ *   Value to yield if `Fn` is not a type guard.
+ */
+
+/**
+ * @typedef {(
+ *   Value extends Node
+ *   ? Check extends null | undefined // No test.
+ *     ? Value
+ *     : Check extends Function // Function test.
+ *     ? Extract<Value, Predicate<Check, Value>>
+ *     : Value['type'] extends Check // String (type) test.
+ *     ? Value
+ *     : Value extends Check // Partial test.
+ *     ? Value
+ *     : never
+ *   : never
+ * )} MatchesOne
+ *   Check whether a node matches a primitive check in the type system.
+ * @template Value
+ *   Value; typically unist `Node`.
+ * @template Check
+ *   Value; typically `unist-util-is`-compatible test, but not arrays.
+ */
+
+/**
+ * @typedef {(
+ *   Check extends Array<any>
+ *   ? MatchesOne<Value, Check[keyof Check]>
+ *   : MatchesOne<Value, Check>
+ * )} Matches
+ *   Check whether a node matches a check in the type system.
+ * @template Value
+ *   Value; typically unist `Node`.
+ * @template Check
+ *   Value; typically `unist-util-is`-compatible test.
+ */
+
+/**
+ * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint
+ *   Number; capped reasonably.
+ */
+
+/**
+ * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment
+ *   Increment a number in the type system.
+ * @template {Uint} [I=0]
+ *   Index.
+ */
+
+/**
+ * @typedef {(
+ *   Tree extends Parent
+ *     ? Depth extends Max
+ *       ? Tree
+ *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>
+ *     : Tree
+ * )} InclusiveDescendant
+ *   Collect all (inclusive) descendants of `Tree`.
+ *
+ *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to
+ *   > recurse without actually running into an infinite loop, which the
+ *   > previous version did.
+ *   >
+ *   > Practically, a max of `2` is typically enough assuming a `Root` is
+ *   > passed, but it doesn’t improve performance.
+ *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.
+ *   > Using up to `10` doesn’t hurt or help either.
+ * @template {Node} Tree
+ *   Tree type.
+ * @template {Uint} [Max=10]
+ *   Max; searches up to this depth.
+ * @template {Uint} [Depth=0]
+ *   Current depth.
+ */
+
 /**
  * @typedef {'skip' | boolean} Action
  *   Union of the action types.
@@ -25,10 +110,6 @@
  */
 
 /**
- * @template {Node} [Visited=Node]
- *   Visited node type.
- * @template {Parent} [Ancestor=Parent]
- *   Ancestor type.
  * @callback Visitor
  *   Handle a node (matching `test`, if given).
  *
@@ -59,17 +140,21 @@
  *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
  *   When the `Action` is `EXIT`, that action can be returned.
  *   When the `Action` is `CONTINUE`, `Index` can be returned.
+ * @template {Node} [Visited=Node]
+ *   Visited node type.
+ * @template {Parent} [Ancestor=Parent]
+ *   Ancestor type.
  */
 
 /**
+ * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Extract<InclusiveDescendant<Tree>, Parent>>} BuildVisitor
+ *   Build a typed `Visitor` function from a tree and a test.
+ *
+ *   It will infer which values are passed as `node` and which as `parents`.
  * @template {Node} [Tree=Node]
  *   Tree type.
  * @template {Test} [Check=Test]
  *   Test type.
- * @typedef {Visitor<import('./complex-types.js').Matches<import('./complex-types.js').InclusiveDescendant<Tree>, Check>, Extract<import('./complex-types.js').InclusiveDescendant<Tree>, Parent>>} BuildVisitor
- *   Build a typed `Visitor` function from a tree and a test.
- *
- *   It will infer which values are passed as `node` and which as `parents`.
  */
 
 import {convert} from 'unist-util-is'
@@ -111,9 +196,6 @@ export const SKIP = 'skip'
  * You can change the tree.
  * See `Visitor` for more info.
  *
- * @template {Node} Tree
- * @template {Test} Check
- *
  * @overload
  * @param {Tree} tree
  * @param {Check} check
@@ -137,6 +219,11 @@ export const SKIP = 'skip'
  *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
  * @returns {undefined}
  *   Nothing.
+ *
+ * @template {Node} Tree
+ *   Node type.
+ * @template {Test} Check
+ *   `unist-util-is`-compatible test.
  */
 export function visitParents(tree, test, visitor, reverse) {
   /** @type {Test} */

lib/complex-types.d.ts

@@ -39,7 +39,6 @@
   "types": "index.d.ts",
   "files": [
     "lib/",
-    "complex-types.d.ts",
     "index.d.ts",
     "index.js"
   ],
@@ -91,7 +90,7 @@
     "detail": true,
     "#": "needed `any`s",
     "ignoreFiles": [
-      "lib/complex-types.d.ts"
+      "lib/index.d.ts"
     ],
     "ignoreCatch": true,
     "strict": true

lib/index.js

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