chore: bump biome to 2.3.11 and run format (#3354)

## Summary
- Bump `@biomejs/biome` from 2.2.5 to 2.3.11
- Run format to fix 6 files

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: B4nan

package.json

@@ -58,7 +58,7 @@
         "@apify/eslint-config": "^1.0.0",
         "@apify/log": "^2.4.0",
         "@apify/tsconfig": "^0.1.0",
-        "@biomejs/biome": "^2.2.5",
+        "@biomejs/biome": "^2.3.11",
         "@commitlint/config-conventional": "^20.0.0",
         "@playwright/browser-chromium": "1.57.0",
         "@playwright/browser-firefox": "1.57.0",

packages/core/src/crawlers/crawler_commons.ts

@@ -21,11 +21,12 @@ export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 export type LoadedRequest<R extends Request> = WithRequired<R, 'id' | 'loadedUrl'>;
 
 /** @internal */
-export type LoadedContext<Context extends RestrictedCrawlingContext> = IsAny<Context> extends true
-    ? Context
-    : {
-          request: LoadedRequest<Context['request']>;
-      } & Omit<Context, 'request'>;
+export type LoadedContext<Context extends RestrictedCrawlingContext> =
+    IsAny<Context> extends true
+        ? Context
+        : {
+              request: LoadedRequest<Context['request']>;
+          } & Omit<Context, 'request'>;
 
 export interface RestrictedCrawlingContext<UserData extends Dictionary = Dictionary>
     // we need `Record<string & {}, unknown>` here, otherwise `Omit<Context>` is resolved badly

test/browser-pool/anonymize-proxy-sugar.test.ts

@@ -20,13 +20,10 @@ describe('anonymizeProxySugar', () => {
         ['http://username:password@proxy:1000/', 'http://username:password@proxy:1000'],
         ['socks://username:password@proxy:1000', 'socks://username:password@proxy:1000'],
         ['socks://username:password@proxy:1000/', 'socks://username:password@proxy:1000'],
-    ])(
-        'should call anonymizeProxy from proxy-chain with correctly pre-processed URL: %s',
-        async (input, expectedOutput) => {
-            const [anonymized] = await anonymizeProxySugar(input);
+    ])('should call anonymizeProxy from proxy-chain with correctly pre-processed URL: %s', async (input, expectedOutput) => {
+        const [anonymized] = await anonymizeProxySugar(input);
 
-            expect(anonymizeProxy).toHaveBeenCalledWith(expectedOutput);
-            expect(anonymized).toBeTypeOf('string');
-        },
-    );
+        expect(anonymizeProxy).toHaveBeenCalledWith(expectedOutput);
+        expect(anonymized).toBeTypeOf('string');
+    });
 });

test/core/crawlers/adaptive_playwright_crawler.test.ts

@@ -234,34 +234,34 @@ describe('AdaptivePlaywrightCrawler', () => {
         expect(resultChecker).toHaveBeenCalledTimes(1);
     });
 
-    test.each([['static'], ['clientOnly']] as const)(
-        'crawlingContext.addRequests() should add requests correctly (%s)',
-        async (renderingType) => {
-            const renderingTypePredictor = makeRiggedRenderingTypePredictor({
-                detectionProbabilityRecommendation: 0,
-                renderingType,
-            });
-            const url = new URL(`http://${HOSTNAME}:${port}`).toString();
+    test.each([
+        ['static'],
+        ['clientOnly'],
+    ] as const)('crawlingContext.addRequests() should add requests correctly (%s)', async (renderingType) => {
+        const renderingTypePredictor = makeRiggedRenderingTypePredictor({
+            detectionProbabilityRecommendation: 0,
+            renderingType,
+        });
+        const url = new URL(`http://${HOSTNAME}:${port}`).toString();
 
-            let requestContext: LoadedContext<AdaptivePlaywrightCrawlerContext> | undefined;
-            const requestHandler: AdaptivePlaywrightCrawlerOptions['requestHandler'] = async (context) => {
-                const isStartUrl = context.request.url === url;
+        let requestContext: LoadedContext<AdaptivePlaywrightCrawlerContext> | undefined;
+        const requestHandler: AdaptivePlaywrightCrawlerOptions['requestHandler'] = async (context) => {
+            const isStartUrl = context.request.url === url;
 
-                if (isStartUrl) await context.addRequests([`${url}/1`]);
-                else requestContext = context;
-            };
+            if (isStartUrl) await context.addRequests([`${url}/1`]);
+            else requestContext = context;
+        };
 
-            const crawler = await makeOneshotCrawler(
-                { requestHandler, renderingTypePredictor, maxRequestsPerCrawl: 10 },
-                [],
-            );
+        const crawler = await makeOneshotCrawler(
+            { requestHandler, renderingTypePredictor, maxRequestsPerCrawl: 10 },
+            [],
+        );
 
-            await crawler.run([{ url, crawlDepth: 2 }]);
+        await crawler.run([{ url, crawlDepth: 2 }]);
 
-            assert(requestContext);
-            expect(requestContext.request).toMatchObject({ url: `${url}/1`, crawlDepth: 3 });
-        },
-    );
+        assert(requestContext);
+        expect(requestContext.request).toMatchObject({ url: `${url}/1`, crawlDepth: 3 });
+    });
 
     describe('should enqueue links correctly', () => {
         test.each([
@@ -315,49 +315,49 @@ describe('AdaptivePlaywrightCrawler', () => {
         });
     });
 
-    test.each([['static'], ['clientOnly']] as const)(
-        'should respect the strategy option for enqueueLinks (%s)',
-        async (renderingType) => {
-            const renderingTypePredictor = makeRiggedRenderingTypePredictor({
-                detectionProbabilityRecommendation: 0,
-                renderingType,
-            });
-            const url = new URL(`http://${HOSTNAME}:${port}/external-links`);
-            const enqueuedUrls = new Set<string>();
-            const visitedUrls = new Set<string>();
+    test.each([
+        ['static'],
+        ['clientOnly'],
+    ] as const)('should respect the strategy option for enqueueLinks (%s)', async (renderingType) => {
+        const renderingTypePredictor = makeRiggedRenderingTypePredictor({
+            detectionProbabilityRecommendation: 0,
+            renderingType,
+        });
+        const url = new URL(`http://${HOSTNAME}:${port}/external-links`);
+        const enqueuedUrls = new Set<string>();
+        const visitedUrls = new Set<string>();
 
-            const requestHandler: AdaptivePlaywrightCrawlerOptions['requestHandler'] = vi.fn(
-                async ({ enqueueLinks, request }) => {
-                    visitedUrls.add(request.loadedUrl);
+        const requestHandler: AdaptivePlaywrightCrawlerOptions['requestHandler'] = vi.fn(
+            async ({ enqueueLinks, request }) => {
+                visitedUrls.add(request.loadedUrl);
 
-                    if (!request.label) {
-                        const result = await enqueueLinks({
-                            label: 'enqueued-url',
-                            strategy: 'same-hostname',
-                        });
+                if (!request.label) {
+                    const result = await enqueueLinks({
+                        label: 'enqueued-url',
+                        strategy: 'same-hostname',
+                    });
 
-                        for (const processedRequest of result.processedRequests) {
-                            enqueuedUrls.add(processedRequest.uniqueKey);
-                        }
+                    for (const processedRequest of result.processedRequests) {
+                        enqueuedUrls.add(processedRequest.uniqueKey);
                     }
-                },
-            );
+                }
+            },
+        );
 
-            const crawler = await makeOneshotCrawler(
-                {
-                    requestHandler,
-                    renderingTypePredictor,
-                    maxRequestsPerCrawl: 10,
-                },
-                [url.toString()],
-            );
+        const crawler = await makeOneshotCrawler(
+            {
+                requestHandler,
+                renderingTypePredictor,
+                maxRequestsPerCrawl: 10,
+            },
+            [url.toString()],
+        );
 
-            await crawler.run();
+        await crawler.run();
 
-            expect(new Set(visitedUrls)).toEqual(new Set([`http://${HOSTNAME}:${port}/external-links`]));
-            expect(new Set(enqueuedUrls)).toEqual(new Set([`http://${HOSTNAME}:${port}/external-redirect`]));
-        },
-    );
+        expect(new Set(visitedUrls)).toEqual(new Set([`http://${HOSTNAME}:${port}/external-links`]));
+        expect(new Set(enqueuedUrls)).toEqual(new Set([`http://${HOSTNAME}:${port}/external-redirect`]));
+    });
 
     test('should persist crawler state', async () => {
         const renderingTypePredictor = makeRiggedRenderingTypePredictor({

test/core/crawlers/basic_crawler.test.ts

@@ -414,61 +414,61 @@ describe('BasicCrawler', () => {
         expect(await requestList.isEmpty()).toBe(true);
     });
 
-    test.each([EventType.MIGRATING, EventType.ABORTING])(
-        'should pause on %s event and persist RequestList state',
-        async (event) => {
-            const sources = [...Array(500).keys()].map((index) => ({ url: `https://example.com/${index + 1}` }));
-
-            let persistResolve!: (value?: unknown) => void;
-            const persistPromise = new Promise((res) => {
-                persistResolve = res;
-            });
+    test.each([
+        EventType.MIGRATING,
+        EventType.ABORTING,
+    ])('should pause on %s event and persist RequestList state', async (event) => {
+        const sources = [...Array(500).keys()].map((index) => ({ url: `https://example.com/${index + 1}` }));
 
-            // Mock the calls to persist sources.
-            const getValueSpy = vitest.spyOn(KeyValueStore.prototype, 'getValue');
-            const setValueSpy = vitest.spyOn(KeyValueStore.prototype, 'setValue');
-            getValueSpy.mockResolvedValue(null);
+        let persistResolve!: (value?: unknown) => void;
+        const persistPromise = new Promise((res) => {
+            persistResolve = res;
+        });
 
-            const processed: { url: string }[] = [];
-            const requestList = await RequestList.open('reqList', sources);
-            const requestHandler: RequestHandler = async ({ request }) => {
-                if (request.url.endsWith('200')) events.emit(event);
-                processed.push({ url: request.url });
-            };
+        // Mock the calls to persist sources.
+        const getValueSpy = vitest.spyOn(KeyValueStore.prototype, 'getValue');
+        const setValueSpy = vitest.spyOn(KeyValueStore.prototype, 'setValue');
+        getValueSpy.mockResolvedValue(null);
 
-            const basicCrawler = new BasicCrawler({
-                requestList,
-                minConcurrency: 25,
-                maxConcurrency: 25,
-                requestHandler,
-            });
+        const processed: { url: string }[] = [];
+        const requestList = await RequestList.open('reqList', sources);
+        const requestHandler: RequestHandler = async ({ request }) => {
+            if (request.url.endsWith('200')) events.emit(event);
+            processed.push({ url: request.url });
+        };
 
-            let finished = false;
-            // Mock the call to persist state.
-            setValueSpy.mockImplementationOnce(persistResolve as any);
-            // The crawler will pause after 200 requests
-            const runPromise = basicCrawler.run();
-            void runPromise.then(() => {
-                finished = true;
-            });
+        const basicCrawler = new BasicCrawler({
+            requestList,
+            minConcurrency: 25,
+            maxConcurrency: 25,
+            requestHandler,
+        });
 
-            // need to monkeypatch the stats class, otherwise it will never finish
-            basicCrawler.stats.persistState = async () => Promise.resolve();
-            await persistPromise;
+        let finished = false;
+        // Mock the call to persist state.
+        setValueSpy.mockImplementationOnce(persistResolve as any);
+        // The crawler will pause after 200 requests
+        const runPromise = basicCrawler.run();
+        void runPromise.then(() => {
+            finished = true;
+        });
 
-            expect(finished).toBe(false);
-            expect(await requestList.isFinished()).toBe(false);
-            expect(await requestList.isEmpty()).toBe(false);
-            expect(processed.length).toBe(200);
+        // need to monkeypatch the stats class, otherwise it will never finish
+        basicCrawler.stats.persistState = async () => Promise.resolve();
+        await persistPromise;
 
-            expect(getValueSpy).toBeCalled();
-            expect(setValueSpy).toBeCalled();
+        expect(finished).toBe(false);
+        expect(await requestList.isFinished()).toBe(false);
+        expect(await requestList.isEmpty()).toBe(false);
+        expect(processed.length).toBe(200);
 
-            // clean up
-            // @ts-expect-error Accessing private method
-            await basicCrawler.autoscaledPool!._destroy();
-        },
-    );
+        expect(getValueSpy).toBeCalled();
+        expect(setValueSpy).toBeCalled();
+
+        // clean up
+        // @ts-expect-error Accessing private method
+        await basicCrawler.autoscaledPool!._destroy();
+    });
 
     test('should retry failed requests', async () => {
         const sources = [