apify 2.3.1-beta.4 → 3.0.0-alpha.10

package/build/crawlers/puppeteer_crawler.js

@@ -1,299 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const ow_1 = (0, tslib_1.__importDefault)(require("ow"));
-const puppeteer_utils_1 = require("../puppeteer_utils");
-const stealth_1 = (0, tslib_1.__importDefault)(require("../stealth/stealth"));
-/* eslint-disable no-unused-vars,import/named,import/no-duplicates,import/order */
-const puppeteer_launcher_1 = require("../browser_launchers/puppeteer_launcher");
-const browser_crawler_1 = (0, tslib_1.__importDefault)(require("./browser_crawler"));
-/* eslint-enable no-unused-vars,import/named,import/no-duplicates,import/order */
-/**
- * @callback PuppeteerHook
- * @param {{ page: Page, crawler: PuppeteerCrawler } & BrowserCrawlingContext & CrawlingContext} crawlingContext
- * @param {DirectNavigationOptions} gotoOptions
- * @returns {Promise<void>}
- */
-/**
- * @typedef PuppeteerHandlePageFunctionParam
- * @property {Page} page
- * @property {PuppeteerCrawler} crawler
- */
-/**
- * @callback PuppeteerHandlePage
- * @param {CrawlingContext & BrowserCrawlingContext & { page: Page, crawler: PuppeteerCrawler }} context
- * @returns {Promise<void>}
- */
-/**
- * @typedef PuppeteerCrawlerOptions
- * @property {PuppeteerHandlePage} handlePageFunction
- *   Function that is called to process each request.
- *   It is passed an object with the following fields:
- *
- * ```
- * {
- *   request: Request,
- *   response: Response,
- *   page: Page,
- *   session: Session,
- *   browserController: BrowserController,
- *   proxyInfo: ProxyInfo,
- *   crawler: PuppeteerCrawler,
- * }
- * ```
- *
- *   `request` is an instance of the {@link Request} object with details about the URL to open, HTTP method etc.
- *   `page` is an instance of the `Puppeteer`
- *   [`Page`](https://pptr.dev/#?product=Puppeteer&show=api-class-page)
- *   `browserPool` is an instance of the
- *   [`BrowserPool`](https://github.com/apify/browser-pool#BrowserPool),
- *   `browserController` is an instance of the
- *   [`BrowserController`](https://github.com/apify/browser-pool#browsercontroller),
- *   `response` is an instance of the `Puppeteer`
- *   [`Response`](https://pptr.dev/#?product=Puppeteer&show=api-class-response),
- *   which is the main resource response as returned by `page.goto(request.url)`.
- *   The function must return a promise, which is then awaited by the crawler.
- *
- *   If the function throws an exception, the crawler will try to re-crawl the
- *   request later, up to `option.maxRequestRetries` times.
- *   If all the retries fail, the crawler calls the function
- *   provided to the `handleFailedRequestFunction` parameter.
- *   To make this work, you should **always**
- *   let your function throw exceptions rather than catch them.
- *   The exceptions are logged to the request using the
- *   {@link Request#pushErrorMessage} function.
- * @property {number} [navigationTimeoutSecs=60]
- *   Timeout in which page navigation needs to finish, in seconds.
- * @property {HandleFailedRequest} [handleFailedRequestFunction]
- *   A function to handle requests that failed more than `option.maxRequestRetries` times.
- *
- *   The function receives the following object as an argument:
- * ```
-  * {
- *   request: Request,
- *   response: Response,
- *   page: Page,
- *   session: Session,
- *   browserController: BrowserController,
- *   proxyInfo: ProxyInfo,
- *   crawler: PuppeteerCrawler,
- * }
- * ```
- *   Where the {@link Request} instance corresponds to the failed request, and the `Error` instance
- *   represents the last error thrown during processing of the request.
- * @property {PuppeteerLaunchContext} [launchContext]
- *   Options used by {@link Apify#launchPuppeteer} to start new Puppeteer instances.
- * @property {number} [handlePageTimeoutSecs=60]
- *   Timeout in which the function passed as `handlePageFunction` needs to finish, in seconds.
- * @property {BrowserPoolOptions} [browserPoolOptions]
- *   Custom options passed to the underlying [`BrowserPool`](https://github.com/apify/browser-pool#BrowserPool) constructor.
- *   You can tweak those to fine-tune browser management.
- * @property {boolean} [persistCookiesPerSession=true]
- *   Automatically saves cookies to Session. Works only if Session Pool is used.
- * @property {ProxyConfiguration} [proxyConfiguration]
- *   If set, `PuppeteerCrawler` will be configured for all connections to use
- *   [Apify Proxy](https://console.apify.com/proxy) or your own Proxy URLs provided and rotated according to the configuration.
- *   For more information, see the [documentation](https://docs.apify.com/proxy).
- * @property {Array<PuppeteerHook>} [preNavigationHooks]
- *   Async functions that are sequentially evaluated before the navigation. Good for setting additional cookies
- *   or browser properties before navigation. The function accepts two parameters, `crawlingContext` and `gotoOptions`,
- *   which are passed to the `page.goto()` function the crawler calls to navigate.
- *   Example:
- * ```
- * preNavigationHooks: [
- *     async (crawlingContext, gotoOptions) => {
- *         const { page } = crawlingContext;
- *         await page.evaluate((attr) => { window.foo = attr; }, 'bar');
- *     },
- * ]
- * ```
- * @property {Array<PuppeteerHook>} [postNavigationHooks]
- *   Async functions that are sequentially evaluated after the navigation. Good for checking if the navigation was successful.
- *   The function accepts `crawlingContext` as the only parameter.
- *   Example:
- * ```
- * postNavigationHooks: [
- *     async (crawlingContext) => {
- *         const { page } = crawlingContext;
- *         if (hasCaptcha(page)) {
- *             await solveCaptcha (page);
- *         }
- *     },
- * ]
- * ```
- * @property {RequestList} [requestList]
- *   Static list of URLs to be processed.
- *   Either `requestList` or `requestQueue` option must be provided (or both).
- * @property {RequestQueue} [requestQueue]
- *   Dynamic queue of URLs to be processed. This is useful for recursive crawling of websites.
- *   Either `requestList` or `requestQueue` option must be provided (or both).
- * @property {number} [maxRequestRetries=3]
- *   Indicates how many times the request is retried if {@link PuppeteerCrawlerOptions.handlePageFunction} fails.
- * @property {number} [maxRequestsPerCrawl]
- *   Maximum number of pages that the crawler will open. The crawl will stop when this limit is reached.
- *   Always set this value in order to prevent infinite loops in misconfigured crawlers.
- *   Note that in cases of parallel crawling, the actual number of pages visited might be slightly higher than this value.
- * @property {AutoscaledPoolOptions} [autoscaledPoolOptions]
- *   Custom options passed to the underlying {@link AutoscaledPool} constructor.
- *   Note that the `runTaskFunction` and `isTaskReadyFunction` options
- *   are provided by the crawler and cannot be overridden.
- *   However, you can provide a custom implementation of `isFinishedFunction`.
- * @property {number} [minConcurrency=1]
- *   Sets the minimum concurrency (parallelism) for the crawl. Shortcut to the corresponding {@link AutoscaledPool} option.
- *
- *   *WARNING:* If you set this value too high with respect to the available system memory and CPU, your crawler will run extremely slow or crash.
- *   If you're not sure, just keep the default value and the concurrency will scale up automatically.
- * @property {number} [maxConcurrency=1000]
- *   Sets the maximum concurrency (parallelism) for the crawl. Shortcut to the corresponding {@link AutoscaledPool} option.
- * @property {boolean} [useSessionPool=true]
- *   Puppeteer crawler will initialize the  {@link SessionPool} with the corresponding `sessionPoolOptions`.
- *   The session instance will be than available in the `handleRequestFunction`.
- * @property {SessionPoolOptions} [sessionPoolOptions] The configuration options for {@link SessionPool} to use.
- */
-/**
- * Provides a simple framework for parallel crawling of web pages
- * using headless Chrome with [Puppeteer](https://github.com/puppeteer/puppeteer).
- * The URLs to crawl are fed either from a static list of URLs
- * or from a dynamic queue of URLs enabling recursive crawling of websites.
- *
- * Since `PuppeteerCrawler` uses headless Chrome to download web pages and extract data,
- * it is useful for crawling of websites that require to execute JavaScript.
- * If the target website doesn't need JavaScript, consider using {@link CheerioCrawler},
- * which downloads the pages using raw HTTP requests and is about 10x faster.
- *
- * The source URLs are represented using {@link Request} objects that are fed from
- * {@link RequestList} or {@link RequestQueue} instances provided by the {@link PuppeteerCrawlerOptions.requestList}
- * or {@link PuppeteerCrawlerOptions.requestQueue} constructor options, respectively.
- *
- * If both {@link PuppeteerCrawlerOptions.requestList} and {@link PuppeteerCrawlerOptions.requestQueue} are used,
- * the instance first processes URLs from the {@link RequestList} and automatically enqueues all of them
- * to {@link RequestQueue} before it starts their processing. This ensures that a single URL is not crawled multiple times.
- *
- * The crawler finishes when there are no more {@link Request} objects to crawl.
- *
- * `PuppeteerCrawler` opens a new Chrome page (i.e. tab) for each {@link Request} object to crawl
- * and then calls the function provided by user as the {@link PuppeteerCrawlerOptions.handlePageFunction} option.
- *
- * New pages are only opened when there is enough free CPU and memory available,
- * using the functionality provided by the {@link AutoscaledPool} class.
- * All {@link AutoscaledPool} configuration options can be passed to the {@link PuppeteerCrawlerOptions.autoscaledPoolOptions}
- * parameter of the `PuppeteerCrawler` constructor. For user convenience, the `minConcurrency` and `maxConcurrency`
- * {@link AutoscaledPoolOptions} are available directly in the `PuppeteerCrawler` constructor.
- *
- * Note that the pool of Puppeteer instances is internally managed by the {@link BrowserPool} class.
- *
- * **Example usage:**
- *
- * ```javascript
- * const crawler = new Apify.PuppeteerCrawler({
- *     requestList,
- *     handlePageFunction: async ({ page, request }) => {
- *         // This function is called to extract data from a single web page
- *         // 'page' is an instance of Puppeteer.Page with page.goto(request.url) already called
- *         // 'request' is an instance of Request class with information about the page to load
- *         await Apify.pushData({
- *             title: await page.title(),
- *             url: request.url,
- *             succeeded: true,
- *         })
- *     },
- *     handleFailedRequestFunction: async ({ request }) => {
- *         // This function is called when the crawling of a request failed too many times
- *         await Apify.pushData({
- *             url: request.url,
- *             succeeded: false,
- *             errors: request.errorMessages,
- *         })
- *     },
- * });
- *
- * await crawler.run();
- * ```
- * @property {Statistics} stats
- *  Contains statistics about the current run.
- * @property {RequestList} [requestList]
- *  A reference to the underlying {@link RequestList} class that manages the crawler's {@link Request}s.
- *  Only available if used by the crawler.
- * @property {RequestQueue} [requestQueue]
- *  A reference to the underlying {@link RequestQueue} class that manages the crawler's {@link Request}s.
- *  Only available if used by the crawler.
- * @property {SessionPool} [sessionPool]
- *  A reference to the underlying {@link SessionPool} class that manages the crawler's {@link Session}s.
- *  Only available if used by the crawler.
- * @property {ProxyConfiguration} proxyConfiguration
- *  A reference to the underlying {@link ProxyConfiguration} class that manages the crawler's proxies.
- *  Only available if used by the crawler.
- * @property {BrowserPool} browserPool
- *  A reference to the underlying `BrowserPool` class that manages the crawler's browsers.
- *  For more information about it, see the [`browser-pool` module](https://github.com/apify/browser-pool).
- * @property {AutoscaledPool} autoscaledPool
- *  A reference to the underlying {@link AutoscaledPool} class that manages the concurrency of the crawler.
- *  Note that this property is only initialized after calling the {@link CheerioCrawler#run} function.
- *  You can use it to change the concurrency settings on the fly,
- *  to pause the crawler by calling {@link AutoscaledPool#pause}
- *  or to abort it by calling {@link AutoscaledPool#abort}.
- */
-class PuppeteerCrawler extends browser_crawler_1.default {
-    /**
-    * @param {PuppeteerCrawlerOptions} options
-    * All `PuppeteerCrawler` parameters are passed via an options object.
-    */
-    constructor(options = {}) {
-        (0, ow_1.default)(options, 'PuppeteerCrawlerOptions', ow_1.default.object.exactShape(PuppeteerCrawler.optionsShape));
-        const { launchContext = {}, // @TODO: should not launcher be inside launchContext
-        browserPoolOptions = {}, proxyConfiguration, ...browserCrawlerOptions } = options;
-        const { stealth = false, } = launchContext;
-        if (launchContext.proxyUrl) {
-            throw new Error('PuppeteerCrawlerOptions.launchContext.proxyUrl is not allowed in PuppeteerCrawler.'
-                + 'Use PuppeteerCrawlerOptions.proxyConfiguration');
-        }
-        const puppeteerLauncher = new puppeteer_launcher_1.PuppeteerLauncher(launchContext);
-        browserPoolOptions.browserPlugins = [
-            puppeteerLauncher.createBrowserPlugin(),
-        ];
-        super({
-            ...browserCrawlerOptions,
-            proxyConfiguration,
-            browserPoolOptions,
-        });
-        if (stealth) {
-            this.browserPool.postLaunchHooks.push(async (pageId, browserController) => {
-                // @TODO: We can do this better now. It is not necessary to override the page.
-                // we can modify the page in the postPageCreateHook
-                const { hideWebDriver, ...newStealthOptions } = puppeteerLauncher.stealthOptions;
-                await (0, stealth_1.default)(browserController.browser, newStealthOptions);
-            });
-        }
-        this.launchContext = launchContext;
-    }
-    /**
-     * @param {*} crawlingContext
-     * @param {*} gotoOptions
-     * @ignore
-     * @protected
-     * @internal
-     */
-    async _navigationHandler(crawlingContext, gotoOptions) {
-        if (this.gotoFunction) {
-            this.log.deprecated('PuppeteerCrawlerOptions.gotoFunction is deprecated. Use "preNavigationHooks" and "postNavigationHooks" instead.');
-            return this.gotoFunction(crawlingContext, gotoOptions);
-        }
-        return (0, puppeteer_utils_1.gotoExtended)(crawlingContext.page, crawlingContext.request, gotoOptions);
-    }
-}
-/**
- * @internal
- * @type any
- */
-Object.defineProperty(PuppeteerCrawler, "optionsShape", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        ...browser_crawler_1.default.optionsShape,
-        browserPoolOptions: ow_1.default.optional.object,
-        launchContext: ow_1.default.optional.object,
-    }
-});
-exports.default = PuppeteerCrawler;
-//# sourceMappingURL=puppeteer_crawler.js.map

package/build/crawlers/puppeteer_crawler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"puppeteer_crawler.js","sourceRoot":"","sources":["../../src/crawlers/puppeteer_crawler.js"],"names":[],"mappings":";;;AAAA,yDAAoB;AAEpB,wDAAkD;AAClD,8EAAuD;AAEvD,kFAAkF;AAClF,gFAAoG;AAEpG,qFAA2E;AAU3E,iFAAiF;AAEjF;;;;;GAKG;AACH;;;;GAIG;AACH;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,MAAM,gBAAiB,SAAQ,yBAAc;IAWzC;;;MAGE;IACF,YAAY,OAAO,GAAG,EAAE;QACpB,IAAA,YAAE,EAAC,OAAO,EAAE,yBAAyB,EAAE,YAAE,CAAC,MAAM,CAAC,UAAU,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;QAE5F,MAAM,EACF,aAAa,GAAG,EAAE,EAAE,qDAAqD;QACzE,kBAAkB,GAAG,EAAE,EACvB,kBAAkB,EAClB,GAAG,qBAAqB,EAC3B,GAAG,OAAO,CAAC;QAEZ,MAAM,EACF,OAAO,GAAG,KAAK,GAClB,GAAG,aAAa,CAAC;QAElB,IAAI,aAAa,CAAC,QAAQ,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oFAAoF;kBAC9F,gDAAgD,CAAC,CAAC;SAC3D;QACD,MAAM,iBAAiB,GAAG,IAAI,sCAAiB,CAAC,aAAa,CAAC,CAAC;QAE/D,kBAAkB,CAAC,cAAc,GAAG;YAChC,iBAAiB,CAAC,mBAAmB,EAAE;SAC1C,CAAC;QAEF,KAAK,CAAC;YACF,GAAG,qBAAqB;YACxB,kBAAkB;YAClB,kBAAkB;SACrB,CAAC,CAAC;QAEH,IAAI,OAAO,EAAE;YACT,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,EAAE;gBACtE,8EAA8E;gBAC9E,mDAAmD;gBACnD,MAAM,EAAE,aAAa,EAAE,GAAG,iBAAiB,EAAE,GAAG,iBAAiB,CAAC,cAAc,CAAC;gBACjF,MAAM,IAAA,iBAAqB,EAAC,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;YAC9E,CAAC,CAAC,CAAC;SACN;QAED,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACvC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,kBAAkB,CAAC,eAAe,EAAE,WAAW;QACjD,IAAI,IAAI,CAAC,YAAY,EAAE;YACnB,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,iHAAiH,CAAC,CAAC;YAEvI,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;SAC1D;QACD,OAAO,IAAA,8BAAY,EAAC,eAAe,CAAC,IAAI,EAAE,eAAe,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACpF,CAAC;;AAtED;;;GAGG;AACI;;;;WAAe;QAClB,GAAG,yBAAc,CAAC,YAAY;QAC9B,kBAAkB,EAAE,YAAE,CAAC,QAAQ,CAAC,MAAM;QACtC,aAAa,EAAE,YAAE,CAAC,QAAQ,CAAC,MAAM;KACpC;GAAC;AAiEN,kBAAe,gBAAgB,CAAC"}

package/build/crawlers/statistics.d.ts

@@ -1,185 +0,0 @@
-export default Statistics;
-export type StatisticsOptions = {
-    logIntervalSecs?: number | undefined;
-    logMessage?: string | undefined;
-};
-/**
- * Format of the persisted stats
- */
-export type StatisticPersistedState = {
-    requestRetryHistogram: number[];
-    statsId: number;
-    requestAvgFailedDurationMillis: number;
-    requestAvgFinishedDurationMillis: number;
-    requestsFinishedPerMinute: number;
-    requestsFailedPerMinute: number;
-    requestTotalDurationMillis: number;
-    requestsTotal: number;
-    crawlerRuntimeMillis: number;
-    crawlerLastStartTimestamp: number;
-    statsPersistedAt: string;
-};
-/**
- * Contains the statistics state
- */
-export type StatisticState = {
-    requestsFinished: number;
-    requestsFailed: number;
-    requestsRetries: number;
-    requestsFailedPerMinute: number;
-    requestsFinishedPerMinute: number;
-    requestMinDurationMillis: number;
-    requestMaxDurationMillis: number;
-    requestTotalFailedDurationMillis: number;
-    requestTotalFinishedDurationMillis: number;
-    crawlerStartedAt: Date | string | null;
-    crawlerFinishedAt: Date | string | null;
-    crawlerRuntimeMillis: number;
-    statsPersistedAt: Date | string | null;
-};
-/**
- * The statistics class provides an interface to collecting and logging run
- * statistics for requests.
- *
- * All statistic information is saved on key value store
- * under the key SDK_CRAWLER_STATISTICS_*, persists between
- * migrations and abort/resurrect
- *
- * @property {StatisticState} state
- *   Current statistic state used for doing calculations on {@link Statistics#calculate} calls
- * @property {number} id
- *   Statistic instance id
- * @property {number[]} requestRetryHistogram
- *   Contains the current retries histogram.
- *   Index 0 means 0 retries, index 2, 2 retries,
- *   and so on
- */
-declare class Statistics {
-    /**
-     * @param {StatisticsOptions} [options]
-     * @hideconstructor
-     */
-    constructor(options?: StatisticsOptions | undefined);
-    log: import("@apify/log/log").Log;
-    logIntervalMillis: number;
-    logMessage: string;
-    keyValueStore: import("../storages/key_value_store").KeyValueStore | null;
-    id: number;
-    persistStateKey: string;
-    listener: () => Promise<void>;
-    requestRetryHistogram: any[];
-    /**
-     * @private
-     * @type {Object<string|number, Job>}
-     */
-    private requestsInProgress;
-    /**
-     * Set the current statistic instance to pristine values
-     */
-    reset(): void;
-    state: {
-        requestsFinished: number;
-        requestsFailed: number;
-        requestsRetries: number;
-        requestsFailedPerMinute: number;
-        requestsFinishedPerMinute: number;
-        requestMinDurationMillis: number;
-        requestMaxDurationMillis: number;
-        requestTotalFailedDurationMillis: number;
-        requestTotalFinishedDurationMillis: number;
-        crawlerStartedAt: null;
-        crawlerFinishedAt: null;
-        statsPersistedAt: null;
-        crawlerRuntimeMillis: number;
-    } | undefined;
-    instanceStart: number | undefined;
-    /**
-     * Starts a job
-     *
-     * @param {number|string} id
-     * @ignore
-     */
-    startJob(id: number | string): void;
-    /**
-     * Mark job as finished and sets the state
-     *
-     * @param {number|string} id
-     * @ignore
-     */
-    finishJob(id: number | string): void;
-    /**
-     * Mark job as failed and sets the state
-     *
-     * @param {number|string} id
-     * @ignore
-     */
-    failJob(id: number | string): void;
-    /**
-     * Calculate the current statistics
-     */
-    calculate(): {
-        requestAvgFailedDurationMillis: number;
-        requestAvgFinishedDurationMillis: number;
-        requestsFinishedPerMinute: number;
-        requestsFailedPerMinute: number;
-        requestTotalDurationMillis: any;
-        requestsTotal: any;
-        crawlerRuntimeMillis: number;
-    };
-    /**
-     * Initializes the key value store for persisting the statistics,
-     * displaying the current state in predefined intervals
-     */
-    startCapturing(): Promise<void>;
-    logInterval: NodeJS.Timer | null | undefined;
-    /**
-     * Stops logging and remove event listeners, then persist
-     */
-    stopCapturing(): Promise<void>;
-    /**
-     * @param {Job} job
-     * @ignore
-     * @protected
-     * @internal
-     */
-    protected _saveRetryCountForJob(job: Job): void;
-    /**
-     * Persist internal state to the key value store
-     */
-    persistState(): Promise<void>;
-    /**
-     * Loads the current statistic from the key value store if any
-     * @ignore
-     * @protected
-     * @internal
-     */
-    protected _maybeLoadStatistics(): Promise<void>;
-    /**
-     * @ignore
-     * @protected
-     * @internal
-     */
-    protected _teardown(): void;
-    /**
-     * Make this class serializable when called with `JSON.stringify(statsInstance)` directly
-     * or through `keyValueStore.setValue('KEY', statsInstance)`
-     *
-     * @returns {StatisticPersistedState & StatisticState}
-     */
-    toJSON(): StatisticPersistedState & StatisticState;
-}
-declare namespace Statistics {
-    const id: number;
-}
-/**
- * @ignore
- */
-declare class Job {
-    lastRunAt: number | null;
-    runs: number;
-    run(): number;
-    finish(): number;
-    durationMillis: number | undefined;
-    retryCount(): number;
-}
-//# sourceMappingURL=statistics.d.ts.map

package/build/crawlers/statistics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../src/crawlers/statistics.js"],"names":[],"mappings":";;;;;;;;;2BAsVc,MAAM,EAAE;aACR,MAAM;oCACN,MAAM;sCACN,MAAM;+BACN,MAAM;6BACN,MAAM;gCACN,MAAM;mBACN,MAAM;0BACN,MAAM;+BACN,MAAM;sBACN,MAAM;;;;;;sBAON,MAAM;oBACN,MAAM;qBACN,MAAM;6BACN,MAAM;+BACN,MAAM;8BACN,MAAM;8BACN,MAAM;sCACN,MAAM;wCACN,MAAM;sBACN,IAAI,GAAC,MAAM,GAAC,IAAI;uBAChB,IAAI,GAAC,MAAM,GAAC,IAAI;0BAChB,MAAM;sBACN,IAAI,GAAC,MAAM,GAAC,IAAI;;AApV9B;;;;;;;;;;;;;;;;GAgBG;AACH;IACI;;;OAGG;IACH,qDA6BC;IAlBG,kCAAqD;IACrD,0BAA+C;IAC/C,mBAA4B;IAC5B,0EAAyB;IAEzB,WAAyB;IACzB,wBAA0D;IAC1D,8BAA4C;IAC5C,6BAA+B;IAE/B;;;OAGG;IACH,2BAAmC;IAMvC;;OAEG;IACH,cAsBC;IArBG;;;;;;;;;;;;;;kBAcC;IAID,kCAA+B;IAKnC;;;;;OAKG;IACH,aAHW,MAAM,GAAC,MAAM,QAQvB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GAAC,MAAM,QAavB;IAED;;;;;OAKG;IACH,YAHW,MAAM,GAAC,MAAM,QAUvB;IAED;;OAEG;IACH;;;;;;;;MAmBC;IAED;;;OAGG;IACH,gCAiBC;IANG,6CAK0B;IAG9B;;OAEG;IACH,+BAMC;IAED;;;;;OAKG;IACH,qCALW,GAAG,QAWb;IAED;;OAEG;IACH,8BASC;IAED;;;;;OAKG;IACH,gDAsCC;IAED;;;;OAIG;IACH,4BAQC;IAED;;;;;OAKG;IACH,UAFa,uBAAuB,GAAG,cAAc,CAgBpD;CACJ;;;;AA9TD;;GAEG;AACH;IAEQ,yBAAqB;IACrB,aAAa;IAGjB,cAGC;IAED,iBAGC;IAFG,mCAAiD;IAIrD,qBAEC;CACJ"}