10257211317

Committed 05 Aug 2024 10:57PM UTC coverage: 99.481% (+0.8%) from 98.68%

Build # 10257211317

Build Type

Pull #3970

github

Committed by

web-flow

Commit Message

Merge 3b62f5eae into e6c0988a4

Pull Request Pull Request #3970: Update build tooling, update imports, require Node 16

Run Details

1673 of 1691 branches covered (98.94%)

Branch coverage included in aggregate %.

318 of 329 new or added lines in 17 files covered. (96.66%)

3 existing lines in 2 files now uncovered.

7712 of 7743 relevant lines covered (99.6%)

82.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.45

/src/load.ts

import {
  type CheerioOptions,
  type InternalOptions,
  flattenOptions,
} from './options.js';
import * as staticMethods from './static.js';
import { Cheerio } from './cheerio.js';
import { isHtml, isCheerio } from './utils.js';
import type { AnyNode, Document, Element, ParentNode } from 'domhandler';
import type { SelectorType, BasicAcceptedElems } from './types.js';

type StaticType = typeof staticMethods;

/**
 * A querying function, bound to a document created from the provided markup.
 *
 * Also provides several helper methods for dealing with the document as a
 * whole.
 */
export interface CheerioAPI extends StaticType {
  /**
   * This selector method is the starting point for traversing and manipulating
   * the document. Like jQuery, it's the primary method for selecting elements
   * in the document.
   *
   * `selector` searches within the `context` scope, which searches within the
   * `root` scope.
   *
   * @example
   *
   * ```js
   * $('ul .pear').attr('class');
   * //=> pear
   *
   * $('li[class=orange]').html();
   * //=> Orange
   *
   * $('.apple', '#fruits').text();
   * //=> Apple
   * ```
   *
   * Optionally, you can also load HTML by passing the string as the selector:
   *
   * ```js
   * $('<ul id="fruits">...</ul>');
   * ```
   *
   * Or the context:
   *
   * ```js
   * $('ul', '<ul id="fruits">...</ul>');
   * ```
   *
   * Or as the root:
   *
   * ```js
   * $('li', 'ul', '<ul id="fruits">...</ul>');
   * ```
   *
   * @param selector - Either a selector to look for within the document, or the
   *   contents of a new Cheerio instance.
   * @param context - Either a selector to look for within the root, or the
   *   contents of the document to query.
   * @param root - Optional HTML document string.
   */
  <T extends AnyNode, S extends string>(
    selector?: S | BasicAcceptedElems<T>,
    context?: BasicAcceptedElems<AnyNode> | null,
    root?: BasicAcceptedElems<Document>,
    options?: CheerioOptions,
  ): Cheerio<S extends SelectorType ? Element : T>;

  /**
   * The root the document was originally loaded with.
   *
   * @private
   */
  _root: Document;

  /**
   * The options the document was originally loaded with.
   *
   * @private
   */
  _options: InternalOptions;

  /** Mimic jQuery's prototype alias for plugin authors. */
  fn: typeof Cheerio.prototype;

  /**
   * The `.load` static method defined on the "loaded" Cheerio factory function
   * is deprecated. Users are encouraged to instead use the `load` function
   * exported by the Cheerio module.
   *
   * @deprecated Use the `load` function exported by the Cheerio module.
   * @category Deprecated
   * @example
   *
   * ```js
   * const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
   * ```
   */
  load: ReturnType<typeof getLoad>;
}

export function getLoad(
  parse: typeof Cheerio.prototype._parse,
  render: (
    dom: AnyNode | ArrayLike<AnyNode>,
    options: InternalOptions,
  ) => string,
) {
  /**
   * Create a querying function, bound to a document created from the provided
   * markup.
   *
   * Note that similar to web browser contexts, this operation may introduce
   * `<html>`, `<head>`, and `<body>` elements; set `isDocument` to `false` to
   * switch to fragment mode and disable this.
   *
   * @param content - Markup to be loaded.
   * @param options - Options for the created instance.
   * @param isDocument - Allows parser to be switched to fragment mode.
   * @returns The loaded document.
   * @see {@link https://cheerio.js.org#loading} for additional usage information.
   */
  return function load(
    content: string | AnyNode | AnyNode[] | Buffer,
    options?: CheerioOptions | null,
    isDocument = true,
  ): CheerioAPI {
    if ((content as string | null) == null) {
      throw new Error('cheerio.load() expects a string');
    }

    const internalOpts = flattenOptions(options);
    const initialRoot = parse(content, internalOpts, isDocument, null);

    /**
     * Create an extended class here, so that extensions only live on one
     * instance.
     */
    class LoadedCheerio<T> extends Cheerio<T> {
      _make<T>(
        selector?: ArrayLike<T> | T | string,
        context?: BasicAcceptedElems<AnyNode> | null,
      ): Cheerio<T> {
        const cheerio = initialize(selector, context);
        cheerio.prevObject = this;

        return cheerio;
      }

      _parse(
        content: string | Document | AnyNode | AnyNode[] | Buffer,
        options: InternalOptions,
        isDocument: boolean,
        context: ParentNode | null,
      ) {
        return parse(content, options, isDocument, context);
      }

      _render(dom: AnyNode | ArrayLike<AnyNode>): string {
        return render(dom, this.options);
      }
    }

    function initialize<T = AnyNode, S extends string = string>(
      selector?: ArrayLike<T> | T | S,
      context?: BasicAcceptedElems<AnyNode> | null,
      root: BasicAcceptedElems<Document> = initialRoot,
      opts?: CheerioOptions,
    ): Cheerio<S extends SelectorType ? Element : T> {
      type Result = S extends SelectorType ? Element : T;

      // $($)
      if (selector && isCheerio<Result>(selector)) return selector;

      const options = flattenOptions(opts, internalOpts);
      const r =
        typeof root === 'string'
          ? [parse(root, options, false, null)]
          : 'length' in root
            ? root
            : [root];
      const rootInstance = isCheerio<Document>(r)
        ? r
        : new LoadedCheerio<Document>(r, null, options);
      // Add a cyclic reference, so that calling methods on `_root` never fails.
      rootInstance._root = rootInstance;

      // $(), $(null), $(undefined), $(false)
      if (!selector) {
        return new LoadedCheerio<Result>(undefined, rootInstance, options);
      }

      const elements: AnyNode[] | undefined =
        typeof selector === 'string' && isHtml(selector)
          ? // $(<html>)
            parse(selector, options, false, null).children
          : isNode(selector)
            ? // $(dom)
              [selector]
            : Array.isArray(selector)
              ? // $([dom])
                selector
              : undefined;

      const instance = new LoadedCheerio(elements, rootInstance, options);

      if (elements) {
        return instance as any;
      }

      if (typeof selector !== 'string') {
        throw new TypeError('Unexpected type of selector');
      }

      // We know that our selector is a string now.
      let search = selector;

      const searchContext: Cheerio<AnyNode> | undefined = context
        ? // If we don't have a context, maybe we have a root, from loading
          typeof context === 'string'
          ? isHtml(context)
            ? // $('li', '<ul>...</ul>')
              new LoadedCheerio<Document>(
                [parse(context, options, false, null)],
                rootInstance,
                options,
              )
            : // $('li', 'ul')
              ((search = `${context} ${search}` as S), rootInstance)
          : isCheerio<AnyNode>(context)
            ? // $('li', $)
              context
            : // $('li', node), $('li', [nodes])
              new LoadedCheerio<AnyNode>(
                Array.isArray(context) ? context : [context],
                rootInstance,
                options,
              )
        : rootInstance;

      // If we still don't have a context, return
      if (!searchContext) return instance as any;

      /*
       * #id, .class, tag
       */
      return searchContext.find(search) as Cheerio<Result>;
    }

    // Add in static methods & properties
    Object.assign(initialize, staticMethods, {
      load,
      // `_root` and `_options` are used in static methods.
      _root: initialRoot,
      _options: internalOpts,
      // Add `fn` for plugins
      fn: LoadedCheerio.prototype,
      // Add the prototype here to maintain `instanceof` behavior.
      prototype: LoadedCheerio.prototype,
    });

    return initialize as CheerioAPI;
  };
}

function isNode(obj: any): obj is AnyNode {
  return (
    !!obj.name ||
    obj.type === 'root' ||
    obj.type === 'text' ||
    obj.type === 'comment'
  );
}

1	import {	1✔
2	type CheerioOptions,
3	type InternalOptions,
4	flattenOptions,
5	} from './options.js';	1✔
6	import * as staticMethods from './static.js';	1✔
7	import { Cheerio } from './cheerio.js';	1✔
8	import { isHtml, isCheerio } from './utils.js';	1✔
9	import type { AnyNode, Document, Element, ParentNode } from 'domhandler';
10	import type { SelectorType, BasicAcceptedElems } from './types.js';
11
12	type StaticType = typeof staticMethods;
13
14	/**
15	* A querying function, bound to a document created from the provided markup.
16	*
17	* Also provides several helper methods for dealing with the document as a
18	* whole.
19	*/
20	export interface CheerioAPI extends StaticType {
21	/**
22	* This selector method is the starting point for traversing and manipulating
23	* the document. Like jQuery, it's the primary method for selecting elements
24	* in the document.
25	*
26	* `selector` searches within the `context` scope, which searches within the
27	* `root` scope.
28	*
29	* @example
30	*
31	* ```js
32	* $('ul .pear').attr('class');
33	* //=> pear
34	*
35	* $('li[class=orange]').html();
36	* //=> Orange
37	*
38	* $('.apple', '#fruits').text();
39	* //=> Apple
40	* ```
41	*
42	* Optionally, you can also load HTML by passing the string as the selector:
43	*
44	* ```js
45	* $('<ul id="fruits">...</ul>');
46	* ```
47	*
48	* Or the context:
49	*
50	* ```js
51	* $('ul', '<ul id="fruits">...</ul>');
52	* ```
53	*
54	* Or as the root:
55	*
56	* ```js
57	* $('li', 'ul', '<ul id="fruits">...</ul>');
58	* ```
59	*
60	* @param selector - Either a selector to look for within the document, or the
61	* contents of a new Cheerio instance.
62	* @param context - Either a selector to look for within the root, or the
63	* contents of the document to query.
64	* @param root - Optional HTML document string.
65	*/
66	<T extends AnyNode, S extends string>(
67	selector?: S \| BasicAcceptedElems<T>,
68	context?: BasicAcceptedElems<AnyNode> \| null,
69	root?: BasicAcceptedElems<Document>,
70	options?: CheerioOptions,
71	): Cheerio<S extends SelectorType ? Element : T>;
72
73	/**
74	* The root the document was originally loaded with.
75	*
76	* @private
77	*/
78	_root: Document;
79
80	/**
81	* The options the document was originally loaded with.
82	*
83	* @private
84	*/
85	_options: InternalOptions;
86
87	/** Mimic jQuery's prototype alias for plugin authors. */
88	fn: typeof Cheerio.prototype;
89
90	/**
91	* The `.load` static method defined on the "loaded" Cheerio factory function
92	* is deprecated. Users are encouraged to instead use the `load` function
93	* exported by the Cheerio module.
94	*
95	* @deprecated Use the `load` function exported by the Cheerio module.
96	* @category Deprecated
97	* @example
98	*
99	* ```js
100	* const $ = cheerio.load('<h1>Hello, <span>world</span>.</h1>');
101	* ```
102	*/
103	load: ReturnType<typeof getLoad>;
104	}
105
106	export function getLoad(	1✔
107	parse: typeof Cheerio.prototype._parse,	13✔
108	render: (	13✔
109	dom: AnyNode \| ArrayLike<AnyNode>,
110	options: InternalOptions,
111	) => string,
112	) {	13✔
113	/**
114	* Create a querying function, bound to a document created from the provided
115	* markup.
116	*
117	* Note that similar to web browser contexts, this operation may introduce
118	* `<html>`, `<head>`, and `<body>` elements; set `isDocument` to `false` to
119	* switch to fragment mode and disable this.
120	*
121	* @param content - Markup to be loaded.
122	* @param options - Options for the created instance.
123	* @param isDocument - Allows parser to be switched to fragment mode.
124	* @returns The loaded document.
125	* @see {@link https://cheerio.js.org#loading} for additional usage information.
126	*/
127	return function load(	13✔
128	content: string \| AnyNode \| AnyNode[] \| Buffer,	791✔
129	options?: CheerioOptions \| null,	791✔
130	isDocument = true,	791✔
131	): CheerioAPI {	791✔
132	if ((content as string \| null) == null) {	791✔
133	throw new Error('cheerio.load() expects a string');	1✔
134	}	1✔
135
136	const internalOpts = flattenOptions(options);	790✔
137	const initialRoot = parse(content, internalOpts, isDocument, null);	790✔
138
139	/**
140	* Create an extended class here, so that extensions only live on one
141	* instance.
142	*/
143	class LoadedCheerio<T> extends Cheerio<T> {	790✔
144	_make<T>(	790✔
145	selector?: ArrayLike<T> \| T \| string,	4,186✔
146	context?: BasicAcceptedElems<AnyNode> \| null,	4,186✔
147	): Cheerio<T> {	4,186✔
148	const cheerio = initialize(selector, context);	4,186✔
149	cheerio.prevObject = this;	4,186✔
150
151	return cheerio;	4,186✔
152	}	4,186✔
153
154	_parse(	790✔
155	content: string \| Document \| AnyNode \| AnyNode[] \| Buffer,	77✔
156	options: InternalOptions,	77✔
157	isDocument: boolean,	77✔
158	context: ParentNode \| null,	77✔
159	) {	77✔
160	return parse(content, options, isDocument, context);	77✔
161	}	77✔
162
163	_render(dom: AnyNode \| ArrayLike<AnyNode>): string {	790✔
164	return render(dom, this.options);	138✔
165	}	138✔
166	}	790✔
167
168	function initialize<T = AnyNode, S extends string = string>(	790✔
169	selector?: ArrayLike<T> \| T \| S,	5,839✔
170	context?: BasicAcceptedElems<AnyNode> \| null,	5,839✔
171	root: BasicAcceptedElems<Document> = initialRoot,	5,839✔
172	opts?: CheerioOptions,	5,839✔
173	): Cheerio<S extends SelectorType ? Element : T> {	5,839✔
174	type Result = S extends SelectorType ? Element : T;
175
176	// $($)
177	if (selector && isCheerio<Result>(selector)) return selector;	5,839✔
178
179	const options = flattenOptions(opts, internalOpts);	5,807✔
180	const r =	5,807✔
181	typeof root === 'string'	5,807✔
182	? [parse(root, options, false, null)]	3✔
183	: 'length' in root	5,804!
UNCOV 184	? root	×
185	: [root];	5,804✔
186	const rootInstance = isCheerio<Document>(r)	5,839!
UNCOV 187	? r	✔
188	: new LoadedCheerio<Document>(r, null, options);	5,807✔
189	// Add a cyclic reference, so that calling methods on `_root` never fails.
190	rootInstance._root = rootInstance;	5,839✔
191
192	// $(), $(null), $(undefined), $(false)
193	if (!selector) {	5,839✔
194	return new LoadedCheerio<Result>(undefined, rootInstance, options);	23✔
195	}	23✔
196
197	const elements: AnyNode[] \| undefined =	5,784✔
198	typeof selector === 'string' && isHtml(selector)	5,837✔
199	? // $(<html>)
200	parse(selector, options, false, null).children	230✔
201	: isNode(selector)	5,554✔
202	? // $(dom)
203	[selector]	429✔
204	: Array.isArray(selector)	5,125✔
205	? // $([dom])
206	selector	3,802✔
207	: undefined;	1,323✔
208
209	const instance = new LoadedCheerio(elements, rootInstance, options);	5,839✔
210
211	if (elements) {	5,839✔
212	return instance as any;	4,461✔
213	}	4,461✔
214
215	if (typeof selector !== 'string') {	5,746!
216	throw new TypeError('Unexpected type of selector');	×
217	}	✔
218
219	// We know that our selector is a string now.
220	let search = selector;	1,323✔
221
222	const searchContext: Cheerio<AnyNode> \| undefined = context	1,323✔
223	? // If we don't have a context, maybe we have a root, from loading
224	typeof context === 'string'	70✔
225	? isHtml(context)	62✔
226	? // $('li', '<ul>...</ul>')
227	new LoadedCheerio<Document>(	58✔
228	[parse(context, options, false, null)],	58✔
229	rootInstance,	58✔
230	options,	58✔
231	)	58✔
232	: // $('li', 'ul')
233	((search = `${context} ${search}` as S), rootInstance)	4✔
234	: isCheerio<AnyNode>(context)	8✔
235	? // $('li', $)
236	context	5✔
237	: // $('li', node), $('li', [nodes])
238	new LoadedCheerio<AnyNode>(	3✔
239	Array.isArray(context) ? context : [context],	3✔
240	rootInstance,	3✔
241	options,	3✔
242	)	3✔
243	: rootInstance;	1,253✔
244
245	// If we still don't have a context, return
246	if (!searchContext) return instance as any;	5,839✔
247
248	/*
249	* #id, .class, tag
250	*/
251	return searchContext.find(search) as Cheerio<Result>;	1,323✔
252	}	5,839✔
253
254	// Add in static methods & properties
255	Object.assign(initialize, staticMethods, {	790✔
256	load,	790✔
257	// `_root` and `_options` are used in static methods.
258	_root: initialRoot,	790✔
259	_options: internalOpts,	790✔
260	// Add `fn` for plugins
261	fn: LoadedCheerio.prototype,	790✔
262	// Add the prototype here to maintain `instanceof` behavior.
263	prototype: LoadedCheerio.prototype,	790✔
264	});	790✔
265
266	return initialize as CheerioAPI;	790✔
267	};	791✔
268	}	13✔
269
270	function isNode(obj: any): obj is AnyNode {	5,554✔
271	return (	5,554✔
272	!!obj.name \|\|	5,554✔
273	obj.type === 'root' \|\|	5,159✔
274	obj.type === 'text' \|\|	5,128✔
275	obj.type === 'comment'	5,126✔
276	);
277	}	5,554✔

cheeriojs / cheerio / 10257211317

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous