Spaces:
Build error
Build error
File size: 7,436 Bytes
c211499 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 |
/**
* @typedef {import('unist').Parent} Parent
* @typedef {import('hast').Element} Element
*/
/**
* @typedef {null | undefined | string | TestFunctionAnything | Array<string | TestFunctionAnything>} Test
* Check for an arbitrary element, unaware of TypeScript inferral.
*
* @callback TestFunctionAnything
* Check if an element passes a test, unaware of TypeScript inferral.
* @param {Element} element
* An element.
* @param {number | null | undefined} [index]
* The element’s position in its parent.
* @param {Parent | null | undefined} [parent]
* The element’s parent.
* @returns {boolean | void}
* Whether this element passes the test.
*/
/**
* @template {Element} T
* Element type.
* @typedef {T['tagName'] | TestFunctionPredicate<T> | Array<T['tagName'] | TestFunctionPredicate<T>>} PredicateTest
* Check for an element that can be inferred by TypeScript.
*/
/**
* Check if an element passes a certain node test.
*
* @template {Element} T
* Element type.
* @callback TestFunctionPredicate
* Complex test function for an element that can be inferred by TypeScript.
* @param {Element} element
* An element.
* @param {number | null | undefined} [index]
* The element’s position in its parent.
* @param {Parent | null | undefined} [parent]
* The element’s parent.
* @returns {element is T}
* Whether this element passes the test.
*/
/**
* @callback AssertAnything
* Check that an arbitrary value is an element, 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 an element and passes a test.
*/
/**
* Check if a node is an element and passes a certain node test
*
* @template {Element} T
* Element type.
* @callback AssertPredicate
* Check that an arbitrary value is a specific element, 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 T}
* Whether this is an element and passes a test.
*/
/**
* Check if `node` is an `Element` and whether it passes the given test.
*
* @param node
* Thing to check, typically `Node`.
* @param test
* A check for a specific element.
* @param index
* The node’s position in its parent.
* @param parent
* The node’s parent.
* @returns
* Whether `node` is an element and passes a test.
*/
export const isElement =
/**
* @type {(
* (() => false) &
* (<T extends Element = Element>(node: unknown, test?: PredicateTest<T>, index?: number, parent?: Parent, context?: unknown) => node is T) &
* ((node: unknown, test: Test, index?: number, parent?: Parent, context?: unknown) => boolean)
* )}
*/
(
/**
* @param {unknown} [node]
* @param {Test | undefined} [test]
* @param {number | null | undefined} [index]
* @param {Parent | null | undefined} [parent]
* @param {unknown} [context]
* @returns {boolean}
*/
// eslint-disable-next-line max-params
function (node, test, index, parent, context) {
const check = convertElement(test)
if (
index !== undefined &&
index !== null &&
(typeof index !== 'number' ||
index < 0 ||
index === Number.POSITIVE_INFINITY)
) {
throw new Error('Expected positive finite index for child node')
}
if (
parent !== undefined &&
parent !== null &&
(!parent.type || !parent.children)
) {
throw new Error('Expected parent node')
}
// @ts-expect-error Looks like a node.
if (!node || !node.type || typeof node.type !== 'string') {
return false
}
if (
(parent === undefined || parent === null) !==
(index === undefined || index === null)
) {
throw new Error('Expected both parent and index')
}
return check.call(context, node, index, parent)
}
)
/**
* 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 an `Element`.
* * When `string`, works like passing `(element) => element.tagName === test`.
* * When `function` checks if function passed the element is true.
* * When `array`, checks any one of the subtests pass.
* @returns
* An assertion.
*/
export const convertElement =
/**
* @type {(
* (<T extends Element>(test: T['tagName'] | TestFunctionPredicate<T>) => AssertPredicate<T>) &
* ((test?: Test) => AssertAnything)
* )}
*/
(
/**
* @param {Test | null | undefined} [test]
* @returns {AssertAnything}
*/
function (test) {
if (test === undefined || test === null) {
return element
}
if (typeof test === 'string') {
return tagNameFactory(test)
}
if (typeof test === 'object') {
return anyFactory(test)
}
if (typeof test === 'function') {
return castFactory(test)
}
throw new Error('Expected function, string, or array as test')
}
)
/**
* Handle multiple tests.
*
* @param {Array<string | TestFunctionAnything>} tests
* @returns {AssertAnything}
*/
function anyFactory(tests) {
/** @type {Array<AssertAnything>} */
const checks = []
let index = -1
while (++index < tests.length) {
checks[index] = convertElement(tests[index])
}
return castFactory(any)
/**
* @this {unknown}
* @param {Array<unknown>} parameters
* @returns {boolean}
*/
function any(...parameters) {
let index = -1
while (++index < checks.length) {
if (checks[index].call(this, ...parameters)) {
return true
}
}
return false
}
}
/**
* Turn a string into a test for an element with a certain tag name.
*
* @param {string} check
* @returns {AssertAnything}
*/
function tagNameFactory(check) {
return tagName
/**
* @param {unknown} node
* @returns {boolean}
*/
function tagName(node) {
return element(node) && node.tagName === check
}
}
/**
* Turn a custom test into a test for an element that passes that test.
*
* @param {TestFunctionAnything} check
* @returns {AssertAnything}
*/
function castFactory(check) {
return assertion
/**
* @this {unknown}
* @param {unknown} node
* @param {Array<unknown>} parameters
* @returns {boolean}
*/
function assertion(node, ...parameters) {
// @ts-expect-error: fine.
return element(node) && Boolean(check.call(this, node, ...parameters))
}
}
/**
* Make sure something is an element.
*
* @param {unknown} node
* @returns {node is Element}
*/
function element(node) {
return Boolean(
node &&
typeof node === 'object' &&
// @ts-expect-error Looks like a node.
node.type === 'element' &&
// @ts-expect-error Looks like an element.
typeof node.tagName === 'string'
)
}
|