@crawlee/core 4.0.0-beta.276 → 4.0.0-beta.278

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/core",
-    "version": "4.0.0-beta.276",
+    "version": "4.0.0-beta.278",
     "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.13.0"
@@ -53,10 +53,10 @@
         "@apify/log": "^3.0.1",
         "@apify/timeout": "^1.0.1",
         "@apify/utilities": "^3.1.0",
-        "@crawlee/fs-storage": "4.0.0-beta.276",
-        "@crawlee/http-client": "4.0.0-beta.276",
-        "@crawlee/types": "4.0.0-beta.276",
-        "@crawlee/utils": "4.0.0-beta.276",
+        "@crawlee/fs-storage": "4.0.0-beta.278",
+        "@crawlee/http-client": "4.0.0-beta.278",
+        "@crawlee/types": "4.0.0-beta.278",
+        "@crawlee/utils": "4.0.0-beta.278",
         "@sapphire/async-queue": "^1.5.5",
         "@standard-schema/spec": "^1.1.0",
         "@vladfrangu/async_event_emitter": "^2.4.7",
@@ -76,5 +76,5 @@
             }
         }
     },
-    "gitHead": "4332e1245c8d053af16c93d7c180f15c4f022d56"
+    "gitHead": "745f27ebf5c8307d949416c9c884ab941eef1559"
 }

package/storages/request-manager-tandem.d.ts

@@ -70,7 +70,7 @@ export declare class RequestManagerTandem implements IRequestManager {
      * reserved. The manager is opened lazily, so the value is remembered and applied once it resolves.
      * @inheritdoc
      */
-    setExpectedRequestProcessingTimeSecs(secs: number): Promise<void>;
+    setExpectedRequestProcessingTime(processingTimeSecs: number): Promise<void>;
     /**
      * Forwards a pacing signal to the writable manager - the loader side is read-only and dispatches nothing of
      * its own. Only a resolved manager is signalled; the tandem will not open a queue to answer a question about
@@ -78,5 +78,5 @@ export declare class RequestManagerTandem implements IRequestManager {
      * @inheritdoc
      */
     recordPacingSignal(signal: PacingSignal): boolean;
-    extendRequestProcessingTimeSecs(request: Request, secs: number): Promise<boolean>;
+    extendRequestProcessingTime(request: Request, extensionSecs: number): Promise<boolean>;
 }

package/storages/request-manager-tandem.js

@@ -12,7 +12,7 @@ export class RequestManagerTandem {
     #resolvedRequestManager;
     #requestManagerFactory;
     /**
-     * The latest expected request-processing time hinted via {@link setExpectedRequestProcessingTimeSecs}.
+     * The latest expected request-processing time hinted via {@link setExpectedRequestProcessingTime}.
      * Remembered so it can be applied to the writable manager once it is lazily resolved.
      */
     #expectedRequestProcessingSecs;
@@ -43,7 +43,7 @@ export class RequestManagerTandem {
             this.#resolvedRequestManager = await this.#requestManagerPromise;
             // Apply any hint received before the manager was resolved.
             if (this.#expectedRequestProcessingSecs !== undefined) {
-                await this.#resolvedRequestManager.setExpectedRequestProcessingTimeSecs?.(this.#expectedRequestProcessingSecs);
+                await this.#resolvedRequestManager.setExpectedRequestProcessingTime?.(this.#expectedRequestProcessingSecs);
             }
         }
         return this.#resolvedRequestManager;
@@ -181,9 +181,9 @@ export class RequestManagerTandem {
      * reserved. The manager is opened lazily, so the value is remembered and applied once it resolves.
      * @inheritdoc
      */
-    async setExpectedRequestProcessingTimeSecs(secs) {
-        this.#expectedRequestProcessingSecs = secs;
-        await this.#resolvedRequestManager?.setExpectedRequestProcessingTimeSecs?.(secs);
+    async setExpectedRequestProcessingTime(processingTimeSecs) {
+        this.#expectedRequestProcessingSecs = processingTimeSecs;
+        await this.#resolvedRequestManager?.setExpectedRequestProcessingTime?.(processingTimeSecs);
     }
     /**
      * Forwards a pacing signal to the writable manager - the loader side is read-only and dispatches nothing of
@@ -194,7 +194,7 @@ export class RequestManagerTandem {
     recordPacingSignal(signal) {
         return this.#resolvedRequestManager?.recordPacingSignal(signal) ?? false;
     }
-    async extendRequestProcessingTimeSecs(request, secs) {
-        return (await this.#getRequestManager()).extendRequestProcessingTimeSecs?.(request, secs) ?? false;
+    async extendRequestProcessingTime(request, extensionSecs) {
+        return (await this.#getRequestManager()).extendRequestProcessingTime?.(request, extensionSecs) ?? false;
     }
 }

package/storages/request-manager.d.ts

@@ -30,7 +30,7 @@ export interface IRequestManager extends IRequestLoader {
      * the same request out again while it is still being processed. Implementations that do not need
      * this hint may leave it `undefined`.
      */
-    setExpectedRequestProcessingTimeSecs?(secs: number): Promise<void>;
+    setExpectedRequestProcessingTime?(processingTimeSecs: number): Promise<void>;
     /**
      * Records something said about the pace requests should go out at, so that a manager which paces its own
      * dispatch can hold requests back.
@@ -50,7 +50,7 @@ export interface IRequestManager extends IRequestLoader {
      * requests or no longer holds this one; non-locking implementations may leave it `undefined`,
      * which callers treat as `false`.
      */
-    extendRequestProcessingTimeSecs?(request: Request, secs: number): Promise<boolean>;
+    extendRequestProcessingTime?(request: Request, extensionSecs: number): Promise<boolean>;
 }
 /**
  * How much of the URL space a {@link PacingSignal} covers.

package/storages/request-queue.d.ts

@@ -178,13 +178,13 @@ export declare class RequestQueue implements IStorage, IRequestManager {
      * ever raise the reservation duration, never lower it — otherwise a short-lived consumer could cut
      * short the reservation of a long-lived one and have its in-flight request stolen.
      */
-    setExpectedRequestProcessingTimeSecs(secs: number): Promise<void>;
+    setExpectedRequestProcessingTime(processingTimeSecs: number): Promise<void>;
     /**
      * @inheritdoc
-     * Unlike {@link RequestQueue.setExpectedRequestProcessingTimeSecs}, which sizes every future lock,
+     * Unlike {@link RequestQueue.setExpectedRequestProcessingTime}, which sizes every future lock,
      * this only touches the one request it is given.
      */
-    extendRequestProcessingTimeSecs(request: Request, secs: number): Promise<boolean>;
+    extendRequestProcessingTime(request: Request, extensionSecs: number): Promise<boolean>;
     /**
      * Removes the queue either from the Apify Cloud storage or from the local database,
      * depending on the mode of operation.

package/storages/request-queue.js

@@ -110,7 +110,7 @@ export class RequestQueue {
     #inProgressRequestBatchCount = 0;
     /**
      * The largest expected request-processing time (in seconds) seen so far via
-     * {@link setExpectedRequestProcessingTimeSecs}. Used to ensure that value is only ever raised, never
+     * {@link setExpectedRequestProcessingTime}. Used to ensure that value is only ever raised, never
      * lowered, before being forwarded to the storage backend.
      */
     #expectedRequestProcessingSecs = 0;
@@ -669,23 +669,23 @@ export class RequestQueue {
      * ever raise the reservation duration, never lower it — otherwise a short-lived consumer could cut
      * short the reservation of a long-lived one and have its in-flight request stolen.
      */
-    async setExpectedRequestProcessingTimeSecs(secs) {
-        if (secs <= this.#expectedRequestProcessingSecs) {
+    async setExpectedRequestProcessingTime(processingTimeSecs) {
+        if (processingTimeSecs <= this.#expectedRequestProcessingSecs) {
             return;
         }
-        this.#expectedRequestProcessingSecs = secs;
-        await this.backend.setExpectedRequestProcessingTimeSecs?.(secs);
+        this.#expectedRequestProcessingSecs = processingTimeSecs;
+        await this.backend.setExpectedRequestProcessingTime?.(processingTimeSecs);
     }
     /**
      * @inheritdoc
-     * Unlike {@link RequestQueue.setExpectedRequestProcessingTimeSecs}, which sizes every future lock,
+     * Unlike {@link RequestQueue.setExpectedRequestProcessingTime}, which sizes every future lock,
      * this only touches the one request it is given.
      */
-    async extendRequestProcessingTimeSecs(request, secs) {
+    async extendRequestProcessingTime(request, extensionSecs) {
         if (!request.id) {
             return false;
         }
-        return (await this.backend.extendRequestProcessingTimeSecs?.(request.id, secs)) ?? false;
+        return (await this.backend.extendRequestProcessingTime?.(request.id, extensionSecs)) ?? false;
     }
     /**
      * Caches information about request to beware of unneeded addRequest() calls.
@@ -722,7 +722,7 @@ export class RequestQueue {
         this.#requestSeenCache.clear();
         this.#inProgressRequestBatchCount = 0;
         // Reset the expected-processing-time high-water mark too, otherwise the monotonic-raise guard
-        // in `setExpectedRequestProcessingTimeSecs` would let a value raised in an earlier run leak into a
+        // in `setExpectedRequestProcessingTime` would let a value raised in an earlier run leak into a
         // later one and silently swallow a lower hint (the queue is meant to be reusable across runs).
         this.#expectedRequestProcessingSecs = 0;
     }