Commit ⋅ syntax-tree/unist-util-is

Showing 1 of 8 files from the diff.

100.00% 100.00% ø

index.js changed.

Other files ignored by Codecov

package.json has changed.

index.test-d.ts is new.

test/main.js has changed.

.gitignore has changed.

tsconfig.json has changed.

test/property.js has changed.

index.d.ts was deleted.

@@ -1,76 +1,159 @@

// Assert if `test` passes for `node`.
// When a `parent` node is known the `index` of node should also be given.
// eslint-disable-next-line max-params
export function is(node, test, index, parent, context) {
  var check = convert(test)

  if (
    index !== undefined &&
    index !== null &&
    (typeof index !== 'number' ||
      index < 0 ||
      index === Number.POSITIVE_INFINITY)
  ) {
    throw new Error('Expected positive finite index')
  }

  if (
    parent !== undefined &&
    parent !== null &&
    (!is(parent) || !parent.children)
  ) {
    throw new Error('Expected parent node')
  }

  if (
    (parent === undefined || parent === null) !==
    (index === undefined || index === null)
  ) {
    throw new Error('Expected both parent and index')
  }

  return node && node.type && typeof node.type === 'string'
    ? Boolean(check.call(context, node, index, parent))
    : false
}

export function convert(test) {
  if (test === undefined || test === null) {
    return ok
  }
/**
 * @typedef {import('unist').Node} Node
 * @typedef {import('unist').Parent} Parent
 *
 * @typedef {string} Type
 * @typedef {Object<string, unknown>} Props
 */

/**
 * Check if a node passes a test
 *
 * @callback TestFunctionAnything
 * @param {Node} node
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {boolean|void}
 */

/**
 * Check if a node passes a certain node test
 *
 * @template {Node} X
 * @callback TestFunctionPredicate
 * @param {Node} node
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {node is X}
 */

/**
 * @callback AssertAnything
 * @param {unknown} [node]
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {boolean}
 */

/**
 * Check if a node passes a certain node test
 *
 * @template {Node} Y
 * @callback AssertPredicate
 * @param {unknown} [node]
 * @param {number} [index]
 * @param {Parent} [parent]
 * @returns {node is Y}
 */

export var is =
  /**
   * Check if a node passes a test.
   * When a `parent` node is known the `index` of node should also be given.
   *
   * @type {(
   *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number, parent?: Parent, context?: unknown) => node is T) &
   *   ((node?: unknown, test?: null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>, index?: number, parent?: Parent, context?: unknown) => boolean)
   * )}
   */
  (
    /**
     * Check if a node passes a test.
     * When a `parent` node is known the `index` of node should also be given.
     *
     * @param {unknown} [node] Node to check
     * @param {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} [test]
     * When nullish, checks if `node` is a `Node`.
     * When `string`, works like passing `function (node) {return 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 any one of the subtests pass.
     * @param {number} [index] Position of `node` in `parent`
     * @param {Parent} [parent] Parent of `node`
     * @param {unknown} [context] Context object to invoke `test` with
     * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
     */
    // eslint-disable-next-line max-params
    function is(node, test, index, parent, context) {
      var check = convert(test)

      if (
        index !== undefined &&
        index !== null &&
        (typeof index !== 'number' ||
          index < 0 ||
          index === Number.POSITIVE_INFINITY)
      ) {
        throw new Error('Expected positive finite index')
      }

  if (typeof test === 'string') {
    return typeFactory(test)
  }
      if (
        parent !== undefined &&
        parent !== null &&
        (!is(parent) || !parent.children)
      ) {
        throw new Error('Expected parent node')
      }

  if (typeof test === 'object') {
    return 'length' in test ? anyFactory(test) : allFactory(test)
  }
      if (
        (parent === undefined || parent === null) !==
        (index === undefined || index === null)
      ) {
        throw new Error('Expected both parent and index')
      }

  if (typeof test === 'function') {
    return test
  }
      // @ts-ignore Looks like a node.
      return node && node.type && typeof node.type === 'string'
        ? Boolean(check.call(context, node, index, parent))
        : false
    }
  )

export var convert =
  /**
   * @type {(
   *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &
   *   ((test?: null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>) => AssertAnything)
   * )}
   */
  (
    /**
     * Generate an assertion from a check.
     * @param {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} [test]
     * When nullish, checks if `node` is a `Node`.
     * When `string`, works like passing `function (node) {return 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 any one of the subtests pass.
     * @returns {AssertAnything}
     */
    function (test) {
      if (test === undefined || test === null) {
        return ok
      }

  throw new Error('Expected function, string, or object as test')
}
      if (typeof test === 'string') {
        return typeFactory(test)
      }

// Utility to assert each property in `test` is represented in `node`, and each
// values are strictly equal.
function allFactory(test) {
  return all
      if (typeof test === 'object') {
        // @ts-ignore looks like a list of tests / partial test object.
        return 'length' in test ? anyFactory(test) : propsFactory(test)
      }

  function all(node) {
    var key
      if (typeof test === 'function') {
        return castFactory(test)
      }

    for (key in test) {
      if (node[key] !== test[key]) return false
      throw new Error('Expected function, string, or object as test')
    }

    return true
  }
}

  )
/**
 * @param {Array.<Type|Props|TestFunctionAnything>} tests
 * @returns {AssertAnything}
 */
function anyFactory(tests) {
  /** @type {Array.<AssertAnything>} */
  var checks = []
  var index = -1


@@ -78,28 +161,82 @@

    checks[index] = convert(tests[index])
  }

  return any
  return castFactory(any)

  /**
   * @this {unknown}
   * @param {unknown[]} parameters
   * @returns {boolean}
   */
  function any(...parameters) {
    var index = -1

    while (++index < checks.length) {
      if (checks[index].call(this, ...parameters)) {
        return true
      }
      if (checks[index].call(this, ...parameters)) return true
    }

    return false
  }
}

// Utility to convert a string into a function which checks a given node’s type
// for said string.
function typeFactory(test) {
  return type
/**
 * Utility to assert each property in `test` is represented in `node`, and each
 * values are strictly equal.
 *
 * @param {Props} check
 * @returns {AssertAnything}
 */
function propsFactory(check) {
  return castFactory(all)

  /**
   * @param {Node} node
   * @returns {boolean}
   */
  function all(node) {
    /** @type {string} */
    var key

    for (key in check) {
      if (node[key] !== check[key]) return
    }

    return true
  }
}

/**
 * Utility to convert a string into a function which checks a given node’s type
 * for said string.
 *
 * @param {Type} check
 * @returns {AssertAnything}
 */
function typeFactory(check) {
  return castFactory(type)

  /**
   * @param {Node} node
   */
  function type(node) {
    return Boolean(node && node.type === test)
    return node && node.type === check
  }
}

/**
 * Utility to convert a string into a function which checks a given node’s type
 * for said string.
 * @param {TestFunctionAnything} check
 * @returns {AssertAnything}
 */
function castFactory(check) {
  return assertion

  /**
   * @this {unknown}
   * @param {Array.<unknown>} parameters
   * @returns {boolean}
   */
  function assertion(...parameters) {
    return Boolean(check.call(this, ...parameters))
  }
}


Files		•	•	•	Coverage
index.js	246	246	0	0	100.00%
Project Totals (1 files)	246	246	0	0	100.00%

View CI Build Download

No yaml found.

Create your codecov.yml to customize your Codecov experience

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

78	161		checks[index] = convert(tests[index])
79	162		}
80	163
81		-	return any
	164	+	return castFactory(any)
82	165
	166	+	/**
	167	+	* @this {unknown}
	168	+	* @param {unknown[]} parameters
	169	+	* @returns {boolean}
	170	+	*/
83	171		function any(...parameters) {
84	172		var index = -1
85	173
86	174		while (++index < checks.length) {
87		-	if (checks[index].call(this, ...parameters)) {
88		-	return true
89		-	}
	175	+	if (checks[index].call(this, ...parameters)) return true
90	176		}
91		-
92		-	return false
93	177		}
94	178		}
95	179
96		-	// Utility to convert a string into a function which checks a given node’s type
97		-	// for said string.
98		-	function typeFactory(test) {
99		-	return type
	180	+	/**
	181	+	* Utility to assert each property in `test` is represented in `node`, and each
	182	+	* values are strictly equal.
	183	+	*
	184	+	* @param {Props} check
	185	+	* @returns {AssertAnything}
	186	+	*/
	187	+	function propsFactory(check) {
	188	+	return castFactory(all)
	189	+
	190	+	/**
	191	+	* @param {Node} node
	192	+	* @returns {boolean}
	193	+	*/
	194	+	function all(node) {
	195	+	/** @type {string} */
	196	+	var key
	197	+
	198	+	for (key in check) {
	199	+	if (node[key] !== check[key]) return
	200	+	}
	201	+
	202	+	return true
	203	+	}
	204	+	}
100	205
	206	+	/**
	207	+	* Utility to convert a string into a function which checks a given node’s type
	208	+	* for said string.
	209	+	*
	210	+	* @param {Type} check
	211	+	* @returns {AssertAnything}
	212	+	*/
	213	+	function typeFactory(check) {
	214	+	return castFactory(type)
	215	+
	216	+	/**
	217	+	* @param {Node} node
	218	+	*/
101	219		function type(node) {
102		-	return Boolean(node && node.type === test)
	220	+	return node && node.type === check
	221	+	}
	222	+	}
	223	+
	224	+	/**
	225	+	* Utility to convert a string into a function which checks a given node’s type
	226	+	* for said string.
	227	+	* @param {TestFunctionAnything} check
	228	+	* @returns {AssertAnything}
	229	+	*/
	230	+	function castFactory(check) {
	231	+	return assertion
	232	+
	233	+	/**
	234	+	* @this {unknown}
	235	+	* @param {Array.<unknown>} parameters
	236	+	* @returns {boolean}
	237	+	*/
	238	+	function assertion(...parameters) {
	239	+	return Boolean(check.call(this, ...parameters))
103	240		}
104	241		}
105	242

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

1		-	// Assert if `test` passes for `node`.
2		-	// When a `parent` node is known the `index` of node should also be given.
3		-	// eslint-disable-next-line max-params
4		-	export function is(node, test, index, parent, context) {
5		-	var check = convert(test)
6		-
7		-	if (
8		-	index !== undefined &&
9		-	index !== null &&
10		-	(typeof index !== 'number' \|\|
11		-	index < 0 \|\|
12		-	index === Number.POSITIVE_INFINITY)
13		-	) {
14		-	throw new Error('Expected positive finite index')
15		-	}
16		-
17		-	if (
18		-	parent !== undefined &&
19		-	parent !== null &&
20		-	(!is(parent) \|\| !parent.children)
21		-	) {
22		-	throw new Error('Expected parent node')
23		-	}
24		-
25		-	if (
26		-	(parent === undefined \|\| parent === null) !==
27		-	(index === undefined \|\| index === null)
28		-	) {
29		-	throw new Error('Expected both parent and index')
30		-	}
31		-
32		-	return node && node.type && typeof node.type === 'string'
33		-	? Boolean(check.call(context, node, index, parent))
34		-	: false
35		-	}
36		-
37		-	export function convert(test) {
38		-	if (test === undefined \|\| test === null) {
39		-	return ok
40		-	}
	1	+	/**
	2	+	* @typedef {import('unist').Node} Node
	3	+	* @typedef {import('unist').Parent} Parent
	4	+	*
	5	+	* @typedef {string} Type
	6	+	* @typedef {Object<string, unknown>} Props
	7	+	*/
	8	+
	9	+	/**
	10	+	* Check if a node passes a test
	11	+	*
	12	+	* @callback TestFunctionAnything
	13	+	* @param {Node} node
	14	+	* @param {number} [index]
	15	+	* @param {Parent} [parent]
	16	+	* @returns {boolean\|void}
	17	+	*/
	18	+
	19	+	/**
	20	+	* Check if a node passes a certain node test
	21	+	*
	22	+	* @template {Node} X
	23	+	* @callback TestFunctionPredicate
	24	+	* @param {Node} node
	25	+	* @param {number} [index]
	26	+	* @param {Parent} [parent]
	27	+	* @returns {node is X}
	28	+	*/
	29	+
	30	+	/**
	31	+	* @callback AssertAnything
	32	+	* @param {unknown} [node]
	33	+	* @param {number} [index]
	34	+	* @param {Parent} [parent]
	35	+	* @returns {boolean}
	36	+	*/
	37	+
	38	+	/**
	39	+	* Check if a node passes a certain node test
	40	+	*
	41	+	* @template {Node} Y
	42	+	* @callback AssertPredicate
	43	+	* @param {unknown} [node]
	44	+	* @param {number} [index]
	45	+	* @param {Parent} [parent]
	46	+	* @returns {node is Y}
	47	+	*/
	48	+
	49	+	export var is =
	50	+	/**
	51	+	* Check if a node passes a test.
	52	+	* When a `parent` node is known the `index` of node should also be given.
	53	+	*
	54	+	* @type {(
	55	+	* (<T extends Node>(node: unknown, test: T['type']\|Partial<T>\|TestFunctionPredicate<T>\|Array.<T['type']\|Partial<T>\|TestFunctionPredicate<T>>, index?: number, parent?: Parent, context?: unknown) => node is T) &
	56	+	* ((node?: unknown, test?: null\|undefined\|Type\|Props\|TestFunctionAnything\|Array.<Type\|Props\|TestFunctionAnything>, index?: number, parent?: Parent, context?: unknown) => boolean)
	57	+	* )}
	58	+	*/
	59	+	(
	60	+	/**
	61	+	* Check if a node passes a test.
	62	+	* When a `parent` node is known the `index` of node should also be given.
	63	+	*
	64	+	* @param {unknown} [node] Node to check
	65	+	* @param {null\|undefined\|Type\|Props\|TestFunctionAnything\|Array.<Type\|Props\|TestFunctionAnything>} [test]
	66	+	* When nullish, checks if `node` is a `Node`.
	67	+	* When `string`, works like passing `function (node) {return node.type === test}`.
	68	+	* When `function` checks if function passed the node is true.
	69	+	* When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
	70	+	* When `array`, checks any one of the subtests pass.
	71	+	* @param {number} [index] Position of `node` in `parent`
	72	+	* @param {Parent} [parent] Parent of `node`
	73	+	* @param {unknown} [context] Context object to invoke `test` with
	74	+	* @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).
	75	+	*/
	76	+	// eslint-disable-next-line max-params
	77	+	function is(node, test, index, parent, context) {
	78	+	var check = convert(test)
	79	+
	80	+	if (
	81	+	index !== undefined &&
	82	+	index !== null &&
	83	+	(typeof index !== 'number' \|\|
	84	+	index < 0 \|\|
	85	+	index === Number.POSITIVE_INFINITY)
	86	+	) {
	87	+	throw new Error('Expected positive finite index')
	88	+	}
41	89
42		-	if (typeof test === 'string') {
43		-	return typeFactory(test)
44		-	}
	90	+	if (
	91	+	parent !== undefined &&
	92	+	parent !== null &&
	93	+	(!is(parent) \|\| !parent.children)
	94	+	) {
	95	+	throw new Error('Expected parent node')
	96	+	}
45	97
46		-	if (typeof test === 'object') {
47		-	return 'length' in test ? anyFactory(test) : allFactory(test)
48		-	}
	98	+	if (
	99	+	(parent === undefined \|\| parent === null) !==
	100	+	(index === undefined \|\| index === null)
	101	+	) {
	102	+	throw new Error('Expected both parent and index')
	103	+	}
49	104
50		-	if (typeof test === 'function') {
51		-	return test
52		-	}
	105	+	// @ts-ignore Looks like a node.
	106	+	return node && node.type && typeof node.type === 'string'
	107	+	? Boolean(check.call(context, node, index, parent))
	108	+	: false
	109	+	}
	110	+	)
	111	+
	112	+	export var convert =
	113	+	/**
	114	+	* @type {(
	115	+	* (<T extends Node>(test: T['type']\|Partial<T>\|TestFunctionPredicate<T>) => AssertPredicate<T>) &
	116	+	* ((test?: null\|undefined\|Type\|Props\|TestFunctionAnything\|Array.<Type\|Props\|TestFunctionAnything>) => AssertAnything)
	117	+	* )}
	118	+	*/
	119	+	(
	120	+	/**
	121	+	* Generate an assertion from a check.
	122	+	* @param {null\|undefined\|Type\|Props\|TestFunctionAnything\|Array.<Type\|Props\|TestFunctionAnything>} [test]
	123	+	* When nullish, checks if `node` is a `Node`.
	124	+	* When `string`, works like passing `function (node) {return node.type === test}`.
	125	+	* When `function` checks if function passed the node is true.
	126	+	* When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
	127	+	* When `array`, checks any one of the subtests pass.
	128	+	* @returns {AssertAnything}
	129	+	*/
	130	+	function (test) {
	131	+	if (test === undefined \|\| test === null) {
	132	+	return ok
	133	+	}
53	134
54		-	throw new Error('Expected function, string, or object as test')
55		-	}
	135	+	if (typeof test === 'string') {
	136	+	return typeFactory(test)
	137	+	}
56	138
57		-	// Utility to assert each property in `test` is represented in `node`, and each
58		-	// values are strictly equal.
59		-	function allFactory(test) {
60		-	return all
	139	+	if (typeof test === 'object') {
	140	+	// @ts-ignore looks like a list of tests / partial test object.
	141	+	return 'length' in test ? anyFactory(test) : propsFactory(test)
	142	+	}
61	143
62		-	function all(node) {
63		-	var key
	144	+	if (typeof test === 'function') {
	145	+	return castFactory(test)
	146	+	}
64	147
65		-	for (key in test) {
66		-	if (node[key] !== test[key]) return false
	148	+	throw new Error('Expected function, string, or object as test')
67	149		}
68		-
69		-	return true
70		-	}
71		-	}
72		-
	150	+	)
	151	+	/**
	152	+	* @param {Array.<Type\|Props\|TestFunctionAnything>} tests
	153	+	* @returns {AssertAnything}
	154	+	*/
73	155		function anyFactory(tests) {
	156	+	/** @type {Array.<AssertAnything>} */
74	157		var checks = []
75	158		var index = -1
76	159

Updating our web app

No yaml found.