@crawlee/cheerio 4.0.0-beta.121 → 4.0.0-beta.123

package/internals/cheerio-crawler.d.ts

@@ -1,8 +1,7 @@
-import type { BasicCrawlingContext, CrawlingContext, EnqueueLinksOptions, ErrorHandler, GetUserDataFromRequest, HttpCrawlerOptions, InternalHttpCrawlingContext, InternalHttpHook, IRequestManager, RequestHandler, RouterHandler, RouterRoutes, RouteSchemas, RoutesFromSchemas, SkippedRequestCallback } from '@crawlee/http';
+import type { AddRequestsBatchedResult, CrawlingContext, EnqueueLinksOptions, ErrorHandler, ExtractLinksOptions, GetUserDataFromRequest, HttpCrawlerOptions, InternalHttpCrawlingContext, InternalHttpHook, RequestHandler, RouterHandler, RouterRoutes, RouteSchemas, RoutesFromSchemas } from '@crawlee/http';
 import { HttpCrawler } from '@crawlee/http';
-import type { BatchAddRequestsResult, Dictionary } from '@crawlee/types';
+import type { Dictionary } from '@crawlee/types';
 import { type CheerioRoot } from '@crawlee/utils/internal';
-import { type RobotsTxtFile } from '@crawlee/utils';
 import type { CheerioAPI } from 'cheerio';
 import * as cheerio from 'cheerio';
 export type CheerioErrorHandler<UserData extends Dictionary = any, // with default to Dictionary we cant use a typed router in untyped crawler
@@ -53,10 +52,14 @@ JSONData extends Dictionary = any> extends InternalHttpCrawlingContext<UserData,
      * ```
      */
     parseWithCheerio(selector?: string, timeoutMs?: number): Promise<CheerioRoot>;
+    /**
+     * Extracts URLs from the parsed HTML, without adding them to the request queue.
+     */
+    extractLinks(options?: ExtractLinksOptions): Promise<string[]>;
     /**
      * Helper function for extracting URLs from the parsed HTML and adding them to the request queue.
      */
-    enqueueLinks(options?: EnqueueLinksOptions): Promise<BatchAddRequestsResult>;
+    enqueueLinks(options?: EnqueueLinksOptions): Promise<AddRequestsBatchedResult>;
 }
 export type CheerioRequestHandler<UserData extends Dictionary = any, // with default to Dictionary we cant use a typed router in untyped crawler
 JSONData extends Dictionary = any> = RequestHandler<CheerioCrawlingContext<UserData, JSONData>>;
@@ -149,31 +152,14 @@ export declare class CheerioCrawler<ContextExtension = Dictionary<never>, Extend
         readonly body: string;
         readonly $: CheerioAPI;
     } & {
-        enqueueLinks: (enqueueOptions?: EnqueueLinksOptions) => Promise<BatchAddRequestsResult>;
+        extractLinks: (options?: ExtractLinksOptions) => Promise<string[]>;
+        enqueueLinks: (options?: EnqueueLinksOptions) => Promise<AddRequestsBatchedResult>;
         waitForSelector: (selector: string, _timeoutMs?: number) => Promise<void>;
         parseWithCheerio: (selector?: string, timeoutMs?: number) => Promise<CheerioAPI>;
     }>;
     private parseContent;
     private addHelpers;
 }
-interface EnqueueLinksInternalOptions {
-    options?: EnqueueLinksOptions;
-    $: cheerio.CheerioAPI | null;
-    requestManager: IRequestManager;
-    robotsTxtFile?: RobotsTxtFile;
-    onSkippedRequest?: SkippedRequestCallback;
-    originalRequestUrl: string;
-    finalRequestUrl?: string;
-}
-interface BoundEnqueueLinksInternalOptions {
-    enqueueLinks: BasicCrawlingContext['enqueueLinks'];
-    options?: EnqueueLinksOptions;
-    $: cheerio.CheerioAPI | null;
-    originalRequestUrl: string;
-    finalRequestUrl?: string;
-}
-/** @internal */
-export declare function cheerioCrawlerEnqueueLinks(options: EnqueueLinksInternalOptions | BoundEnqueueLinksInternalOptions): Promise<unknown>;
 /**
  * Creates new {@link Router} instance that works based on request labels.
  * This instance can then serve as a `requestHandler` of your {@link CheerioCrawler}.
@@ -201,4 +187,3 @@ export declare function cheerioCrawlerEnqueueLinks(options: EnqueueLinksInternal
 export declare function createCheerioRouter<Context extends CheerioCrawlingContext = CheerioCrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>>(routes?: RouterRoutes<Context, Routes>): RouterHandler<Context, Routes>;
 export declare function createCheerioRouter<Context extends CheerioCrawlingContext = CheerioCrawlingContext, UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(routes?: RouterRoutes<Context, Record<string, UserData>>): RouterHandler<Context, Record<string, UserData>>;
 export declare function createCheerioRouter<Context extends CheerioCrawlingContext = CheerioCrawlingContext, const Schemas extends RouteSchemas = RouteSchemas>(schemas: Schemas): RouterHandler<Context, RoutesFromSchemas<Schemas>>;
-export {};

package/internals/cheerio-crawler.js

@@ -1,4 +1,4 @@
-import { enqueueLinks, HttpCrawler, NavigationSkippedError, resolveBaseUrlForEnqueueLinksFiltering, Router, } from '@crawlee/http';
+import { EnqueueStrategy, HttpCrawler, NavigationSkippedError, resolveBaseUrlForEnqueueLinksFiltering, Router, } from '@crawlee/http';
 import { extractUrlsFromCheerio } from '@crawlee/utils/internal';
 import * as cheerio from 'cheerio';
 import { parseDocument } from 'htmlparser2';
@@ -130,22 +130,28 @@ export class CheerioCrawler extends HttpCrawler {
         }
     }
     async addHelpers(crawlingContext) {
-        const originalEnqueueLinks = crawlingContext.enqueueLinks;
+        const addRequests = crawlingContext.addRequests;
+        const extractLinks = async (options) => {
+            if (!crawlingContext.$) {
+                throw new Error('Cannot extract links because the DOM is not available.');
+            }
+            return extractUrlsFromCheerio(crawlingContext.$, options?.selector ?? 'a', options?.baseUrl ?? crawlingContext.request.loadedUrl ?? crawlingContext.request.url);
+        };
         return {
-            enqueueLinks: async (enqueueOptions) => {
-                return (await cheerioCrawlerEnqueueLinks({
-                    options: {
-                        ...enqueueOptions,
-                        limit: await this.calculateEnqueuedRequestLimit(enqueueOptions?.limit),
-                    },
-                    $: crawlingContext.$,
-                    requestManager: await this.getRequestManager(),
-                    robotsTxtFile: await this.getRobotsTxtFileForUrl(crawlingContext.request.url),
-                    onSkippedRequest: this.handleSkippedRequest,
-                    originalRequestUrl: crawlingContext.request.url,
+            extractLinks,
+            enqueueLinks: async (options = {}) => {
+                const baseUrl = resolveBaseUrlForEnqueueLinksFiltering({
+                    enqueueStrategy: options.strategy,
                     finalRequestUrl: crawlingContext.request.loadedUrl,
-                    enqueueLinks: originalEnqueueLinks,
-                })); // TODO make this type safe, see https://github.com/apify/crawlee/issues/4024
+                    originalRequestUrl: crawlingContext.request.url,
+                    userProvidedBaseUrl: options.baseUrl,
+                });
+                const urls = await extractLinks(options);
+                return addRequests(urls, {
+                    ...options,
+                    baseUrl,
+                    strategy: options.strategy ?? EnqueueStrategy.SameHostname,
+                });
             },
             waitForSelector: async (selector, _timeoutMs) => {
                 if (crawlingContext.$(selector).get().length === 0) {
@@ -161,39 +167,6 @@ export class CheerioCrawler extends HttpCrawler {
         };
     }
 }
-/** @internal */
-function containsEnqueueLinks(options) {
-    return !!options.enqueueLinks;
-}
-/** @internal */
-export async function cheerioCrawlerEnqueueLinks(options) {
-    const { options: enqueueLinksOptions, $, originalRequestUrl, finalRequestUrl } = options;
-    if (!$) {
-        throw new Error('Cannot enqueue links because the DOM is not available.');
-    }
-    const baseUrl = resolveBaseUrlForEnqueueLinksFiltering({
-        enqueueStrategy: enqueueLinksOptions?.strategy,
-        finalRequestUrl,
-        originalRequestUrl,
-        userProvidedBaseUrl: enqueueLinksOptions?.baseUrl,
-    });
-    const urls = extractUrlsFromCheerio($, enqueueLinksOptions?.selector ?? 'a', enqueueLinksOptions?.baseUrl ?? finalRequestUrl ?? originalRequestUrl);
-    if (containsEnqueueLinks(options)) {
-        return options.enqueueLinks({
-            urls,
-            baseUrl,
-            ...enqueueLinksOptions,
-        });
-    }
-    return enqueueLinks({
-        requestManager: options.requestManager,
-        robotsTxtFile: options.robotsTxtFile,
-        onSkippedRequest: options.onSkippedRequest,
-        urls,
-        baseUrl,
-        ...enqueueLinksOptions,
-    });
-}
 export function createCheerioRouter(routesOrSchemas) {
     return Router.create(routesOrSchemas);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/cheerio",
-    "version": "4.0.0-beta.121",
+    "version": "4.0.0-beta.123",
     "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
     "engines": {
         "node": ">=22.0.0"
@@ -47,9 +47,9 @@
         "access": "public"
     },
     "dependencies": {
-        "@crawlee/http": "4.0.0-beta.121",
-        "@crawlee/types": "4.0.0-beta.121",
-        "@crawlee/utils": "4.0.0-beta.121",
+        "@crawlee/http": "4.0.0-beta.123",
+        "@crawlee/types": "4.0.0-beta.123",
+        "@crawlee/utils": "4.0.0-beta.123",
         "cheerio": "^1.0.0",
         "htmlparser2": "^10.0.0",
         "tslib": "^2.8.1"
@@ -61,5 +61,5 @@
             }
         }
     },
-    "gitHead": "5027317de626f5ba6de5047ae9341a898258cc5a"
+    "gitHead": "f77648095c6a3f5ed8815c7620ea765db430ae44"
 }