208 lines
6.0 KiB
Plaintext
208 lines
6.0 KiB
Plaintext
/**
|
||
* @typedef {import('unist').Node} Node
|
||
* @typedef {import('unist').Parent} Parent
|
||
*/
|
||
/**
|
||
* @typedef {Record<string, unknown>} Props
|
||
* @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test
|
||
* Check for an arbitrary node, unaware of TypeScript inferral.
|
||
*
|
||
* @callback TestFunctionAnything
|
||
* Check if a node passes a test, unaware of TypeScript inferral.
|
||
* @param {unknown} this
|
||
* The given context.
|
||
* @param {Node} node
|
||
* A node.
|
||
* @param {number | null | undefined} [index]
|
||
* The node’s position in its parent.
|
||
* @param {Parent | null | undefined} [parent]
|
||
* The node’s parent.
|
||
* @returns {boolean | void}
|
||
* Whether this node passes the test.
|
||
*/
|
||
/**
|
||
* @template {Node} Kind
|
||
* Node type.
|
||
* @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest
|
||
* Check for a node that can be inferred by TypeScript.
|
||
*/
|
||
/**
|
||
* Check if a node passes a certain test.
|
||
*
|
||
* @template {Node} Kind
|
||
* Node type.
|
||
* @callback TestFunctionPredicate
|
||
* Complex test function for a node that can be inferred by TypeScript.
|
||
* @param {Node} node
|
||
* A node.
|
||
* @param {number | null | undefined} [index]
|
||
* The node’s position in its parent.
|
||
* @param {Parent | null | undefined} [parent]
|
||
* The node’s parent.
|
||
* @returns {node is Kind}
|
||
* Whether this node passes the test.
|
||
*/
|
||
/**
|
||
* @callback AssertAnything
|
||
* Check that an arbitrary value is a node, unaware of TypeScript inferral.
|
||
* @param {unknown} [node]
|
||
* Anything (typically a node).
|
||
* @param {number | null | undefined} [index]
|
||
* The node’s position in its parent.
|
||
* @param {Parent | null | undefined} [parent]
|
||
* The node’s parent.
|
||
* @returns {boolean}
|
||
* Whether this is a node and passes a test.
|
||
*/
|
||
/**
|
||
* Check if a node is a node and passes a certain node test.
|
||
*
|
||
* @template {Node} Kind
|
||
* Node type.
|
||
* @callback AssertPredicate
|
||
* Check that an arbitrary value is a specific node, aware of TypeScript.
|
||
* @param {unknown} [node]
|
||
* Anything (typically a node).
|
||
* @param {number | null | undefined} [index]
|
||
* The node’s position in its parent.
|
||
* @param {Parent | null | undefined} [parent]
|
||
* The node’s parent.
|
||
* @returns {node is Kind}
|
||
* Whether this is a node and passes a test.
|
||
*/
|
||
/**
|
||
* Check if `node` is a `Node` and whether it passes the given test.
|
||
*
|
||
* @param node
|
||
* Thing to check, typically `Node`.
|
||
* @param test
|
||
* A check for a specific node.
|
||
* @param index
|
||
* The node’s position in its parent.
|
||
* @param parent
|
||
* The node’s parent.
|
||
* @returns
|
||
* Whether `node` is a node and passes a test.
|
||
*/
|
||
export const is: (() => false) &
|
||
(<
|
||
Kind extends import('unist').Node<
|
||
import('unist').Data
|
||
> = import('unist').Node<import('unist').Data>
|
||
>(
|
||
node: unknown,
|
||
test: PredicateTest<Kind>,
|
||
index: number,
|
||
parent: Parent,
|
||
context?: unknown
|
||
) => node is Kind) &
|
||
(<
|
||
Kind_1 extends import('unist').Node<
|
||
import('unist').Data
|
||
> = import('unist').Node<import('unist').Data>
|
||
>(
|
||
node: unknown,
|
||
test: PredicateTest<Kind_1>,
|
||
index?: null | undefined,
|
||
parent?: null | undefined,
|
||
context?: unknown
|
||
) => node is Kind_1) &
|
||
((
|
||
node: unknown,
|
||
test: Test,
|
||
index: number,
|
||
parent: Parent,
|
||
context?: unknown
|
||
) => boolean) &
|
||
((
|
||
node: unknown,
|
||
test?: Test,
|
||
index?: null | undefined,
|
||
parent?: null | undefined,
|
||
context?: unknown
|
||
) => boolean)
|
||
/**
|
||
* Generate an assertion from a test.
|
||
*
|
||
* Useful if you’re going to test many nodes, for example when creating a
|
||
* utility where something else passes a compatible test.
|
||
*
|
||
* The created function is a bit faster because it expects valid input only:
|
||
* a `node`, `index`, and `parent`.
|
||
*
|
||
* @param test
|
||
* * when nullish, checks if `node` is a `Node`.
|
||
* * when `string`, works like passing `(node) => node.type === test`.
|
||
* * when `function` checks if function passed the node is true.
|
||
* * when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
|
||
* * when `array`, checks if any one of the subtests pass.
|
||
* @returns
|
||
* An assertion.
|
||
*/
|
||
export const convert: (<
|
||
Kind extends import('unist').Node<import('unist').Data>
|
||
>(
|
||
test: PredicateTest<Kind>
|
||
) => AssertPredicate<Kind>) &
|
||
((test?: Test) => AssertAnything)
|
||
export type Node = import('unist').Node
|
||
export type Parent = import('unist').Parent
|
||
export type Props = Record<string, unknown>
|
||
/**
|
||
* Check for an arbitrary node, unaware of TypeScript inferral.
|
||
*/
|
||
export type Test =
|
||
| null
|
||
| undefined
|
||
| string
|
||
| Props
|
||
| TestFunctionAnything
|
||
| Array<string | Props | TestFunctionAnything>
|
||
/**
|
||
* Check if a node passes a test, unaware of TypeScript inferral.
|
||
*/
|
||
export type TestFunctionAnything = (
|
||
this: unknown,
|
||
node: Node,
|
||
index?: number | null | undefined,
|
||
parent?: Parent | null | undefined
|
||
) => boolean | void
|
||
/**
|
||
* Check for a node that can be inferred by TypeScript.
|
||
*/
|
||
export type PredicateTest<
|
||
Kind extends import('unist').Node<import('unist').Data>
|
||
> =
|
||
| Kind['type']
|
||
| Partial<Kind>
|
||
| TestFunctionPredicate<Kind>
|
||
| Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>
|
||
/**
|
||
* Complex test function for a node that can be inferred by TypeScript.
|
||
*/
|
||
export type TestFunctionPredicate<
|
||
Kind extends import('unist').Node<import('unist').Data>
|
||
> = (
|
||
node: Node,
|
||
index?: number | null | undefined,
|
||
parent?: Parent | null | undefined
|
||
) => node is Kind
|
||
/**
|
||
* Check that an arbitrary value is a node, unaware of TypeScript inferral.
|
||
*/
|
||
export type AssertAnything = (
|
||
node?: unknown,
|
||
index?: number | null | undefined,
|
||
parent?: Parent | null | undefined
|
||
) => boolean
|
||
/**
|
||
* Check that an arbitrary value is a specific node, aware of TypeScript.
|
||
*/
|
||
export type AssertPredicate<
|
||
Kind extends import('unist').Node<import('unist').Data>
|
||
> = (
|
||
node?: unknown,
|
||
index?: number | null | undefined,
|
||
parent?: Parent | null | undefined
|
||
) => node is Kind
|