@d-zero/puppeteer-dealer 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 D-ZERO Co., Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# `@d-zero/puppeteer-dealer`
+
+```ts
+import { deal } from '@d-zero/puppeteer-dealer';
+
+await deal(
+	// Input list data
+	[
+		{
+			id: '1',
+			url: 'https://example.com',
+		},
+		{
+			id: '2',
+			url: 'https://example.com',
+		},
+	],
+
+	// Header log
+	(progress, done, total) => {
+		return `Header ${Math.ceil(progress * 100)}% ${done}/${total}`;
+	},
+
+	// Handlers
+	{
+		async beforeOpenPage(id, url, logger) {
+			if (condition) {
+				// continue (like Event preventDefault)
+				return false;
+			}
+
+			return true;
+		},
+		async deal(page, id, url, logger) {
+			// Do something
+			await page.goto(url);
+			await page.evaluate(() => {
+				// Do something
+			});
+		},
+	},
+
+	// Options
+	{
+		locale: 'ja-JP',
+		debug: false,
+		limit: 10,
+		verbose: false,
+
+		// Puppeteer launch options
+		headless: true,
+	},
+);
+```

package/dist/create-page.d.ts

@@ -0,0 +1,5 @@
+import type { Page, PuppeteerLaunchOptions } from 'puppeteer';
+export declare function createPage(options?: PuppeteerLaunchOptions): Promise<{
+    page: Page;
+    pid: number;
+}>;

package/dist/create-page.js

@@ -0,0 +1,7 @@
+import { ChildProcessHostedPuppeteerPage } from './puppeteer-page-main-process.js';
+export async function createPage(options) {
+    const page = new ChildProcessHostedPuppeteerPage(options);
+    await page.initialized();
+    const pid = page.pid;
+    return { page, pid };
+}

package/dist/deal.d.ts

@@ -0,0 +1,4 @@
+import type { PuppeteerDealerOptions, PuppeteerDealHandler, URLInfo } from './types.js';
+import type { DealHeader } from '@d-zero/dealer';
+import type { PuppeteerLaunchOptions } from 'puppeteer';
+export declare function deal(list: readonly URLInfo[], header: DealHeader, handler: PuppeteerDealHandler, options?: PuppeteerDealerOptions & PuppeteerLaunchOptions): Promise<void>;

package/dist/deal.js

@@ -0,0 +1,93 @@
+import { deal as coreDeal } from '@d-zero/dealer';
+import { createPage } from '@d-zero/puppeteer-page';
+import { delay } from '@d-zero/shared/delay';
+import c from 'ansi-colors';
+import { log } from './debug.js';
+export async function deal(list, header, handler, options) {
+    const config = {
+        locale: 'ja-JP',
+        ...options,
+    };
+    const childPrecessIds = new Set();
+    const cleanUp = () => {
+        log('child process IDs: %o', childPrecessIds);
+        for (const pid of childPrecessIds) {
+            try {
+                process.kill(pid);
+                log('killed %d', pid);
+            }
+            catch (error) {
+                log('Already dead: %d', pid);
+                if (error instanceof Error && 'code' in error && error.code === 'ESRCH') {
+                    // ignore
+                    continue;
+                }
+                throw error;
+            }
+        }
+        if (log.enabled) {
+            log('process.getActiveResourcesInfo(): %o', process.getActiveResourcesInfo());
+        }
+    };
+    process.on('exit', cleanUp);
+    await coreDeal(list, ({ id, url }, update, index) => {
+        const fileId = id || index.toString().padStart(3, '0');
+        const lineHeader = `%braille% ${c.bgWhite(` ${fileId} `)} ${c.gray(url.toString())}: `;
+        return async () => {
+            const continued = await handler.beforeOpenPage?.(fileId, url.toString(), (log) => update(`${lineHeader}${log}`), index);
+            if (continued === false) {
+                return;
+            }
+            const page = await createPage({
+                headless: true,
+                args: [
+                    //
+                    `--lang=${config.locale}`,
+                    '--no-zygote',
+                    '--ignore-certificate-errors',
+                ],
+                ...config,
+            });
+            if (page.pid !== null) {
+                childPrecessIds.add(page.pid);
+            }
+            await page.setDefaultNavigationTimeout(0);
+            if (config.locale) {
+                await page.setExtraHTTPHeaders({
+                    'Accept-Language': config.locale,
+                });
+            }
+            await handler
+                .deal(page, fileId, url.toString(), (log) => update(`${lineHeader}${log}`), index)
+                .catch(evaluationError(page, url.toString(), fileId, index));
+            update(`${lineHeader} ${c.blue('✓')} Closing page%dots%`);
+            await page.close();
+            update(`${lineHeader} ${c.greenBright('✓')} Page process completed!`);
+            await delay(600);
+        };
+    }, {
+        ...config,
+        header,
+    });
+    log('PuppeteerDealer.deal() completed');
+}
+function evaluationError(page, url, fileId, index) {
+    return (error) => {
+        if (error instanceof Error &&
+            error.message.includes('Execution context was destroyed')) {
+            error.message +=
+                '\n' +
+                    c.red([
+                        `PuppeteerDealer.deal() failed:`,
+                        `    URL: ${url}`,
+                        `    ID: ${fileId}`,
+                        `    Index: ${index}`,
+                        '    Page:',
+                        `        url: ${page.url()}`,
+                        `        isClosed: ${page.isClosed()}`,
+                    ].join('\n'));
+            throw error;
+        }
+        throw error;
+    };
+}

package/dist/debug.d.ts

@@ -0,0 +1,2 @@
+import debug from 'debug';
+export declare const log: debug.Debugger;

package/dist/debug.js

@@ -0,0 +1,2 @@
+import debug from 'debug';
+export const log = debug('@dz').extend('pptr-dealer');

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { deal } from './deal.js';
+export * from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { deal } from './deal.js';
+export * from './types.js';

package/dist/puppeteer-page-child-process.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/puppeteer-page-child-process.js

@@ -0,0 +1,29 @@
+/* use as a sub-process */
+import { ProcTalk } from '@d-zero/proc-talk';
+import puppeteer from 'puppeteer';
+process.title = '@d-zero/puppeteer-dealer:child-process';
+new ProcTalk({
+    type: 'child',
+    async process(options) {
+        this.log('Starting puppeteer: %O', options);
+        const browser = await puppeteer.launch(options);
+        const page = await browser?.newPage();
+        const cleanUp = async () => {
+            this.log('Cleanup start');
+            await page?.close();
+            await browser?.close();
+            this.log('Cleanup done');
+        };
+        this.bind('evaluate', page.evaluate.bind(page));
+        this.bind('goto', page.goto.bind(page));
+        this.bind('title', page.title.bind(page));
+        this.bind('setDefaultNavigationTimeout', page.setDefaultNavigationTimeout.bind(page));
+        this.bind('setViewport', page.setViewport.bind(page));
+        this.bind('screenshot', page.screenshot.bind(page));
+        this.bind('reload', page.reload.bind(page));
+        this.bind('on', page.on.bind(page));
+        this.bind('close', async () => {
+            await cleanUp();
+        });
+    },
+});

package/dist/puppeteer-page-main-process.d.ts

@@ -0,0 +1,84 @@
+import type { Browser, BrowserContext, CDPSession, Cookie, CookieParam, Coverage, Credentials, DeleteCookiesRequest, Device, DeviceRequestPrompt, EvaluateFunc, EvaluateFuncWith, EventsWithWildcard, FileChooser, Frame, GoToOptions, HandleFor, HTTPResponse, JSHandle, Keyboard, MediaFeature, Metrics, Mouse, NetworkConditions, NewDocumentScriptEvaluation, NodeFor, PageEvents, PDFOptions, Protocol, PuppeteerLaunchOptions, Target, Touchscreen, Tracing, Viewport, WaitForOptions, WaitTimeoutOptions, WebWorker } from 'puppeteer';
+import type { ParseSelector } from 'typed-query-selector/parser.js';
+import { ProcTalk } from '@d-zero/proc-talk';
+import { Page } from 'puppeteer';
+export declare class ChildProcessHostedPuppeteerPage extends Page {
+    #private;
+    readonly process: ProcTalk<Page, PuppeteerLaunchOptions>;
+    get mouse(): Mouse;
+    get tracing(): Tracing;
+    get coverage(): Coverage;
+    get keyboard(): Keyboard;
+    get touchscreen(): Touchscreen;
+    get pid(): number;
+    constructor(options?: PuppeteerLaunchOptions);
+    initialized(): Promise<void>;
+    url(): string;
+    waitForDevicePrompt(options?: WaitTimeoutOptions): Promise<DeviceRequestPrompt>;
+    setViewport(viewport: Viewport | null): Promise<void>;
+    viewport(): Viewport | null;
+    pdf(options?: PDFOptions): Promise<Uint8Array>;
+    title(): Promise<string>;
+    close(options?: {
+        runBeforeUnload?: boolean;
+    }): Promise<void>;
+    isClosed(): boolean;
+    emulate(device: Device): Promise<void>;
+    emit<Key extends keyof PageEvents>(type: Key, event: EventsWithWildcard<PageEvents>[Key]): boolean;
+    emulateCPUThrottling(factor: number | null): Promise<void>;
+    emulateIdleState(overrides?: {
+        isUserActive: boolean;
+        isScreenUnlocked: boolean;
+    }): Promise<void>;
+    emulateMediaFeatures(features?: MediaFeature[]): Promise<void>;
+    emulateMediaType(type?: string): Promise<void>;
+    emulateTimezone(timezoneId?: string): Promise<void>;
+    emulateVisionDeficiency(type?: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest['type']): Promise<void>;
+    removeScriptToEvaluateOnNewDocument(identifier: string): Promise<void>;
+    evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    evaluateHandle<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<HandleFor<Awaited<ReturnType<Func>>>>;
+    evaluateOnNewDocument<Params extends unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, ...args: Params): Promise<NewDocumentScriptEvaluation>;
+    $eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<NodeFor<Selector>, Params> = EvaluateFuncWith<ParseSelector<Selector, Element>, Params>>(selector: Selector, pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    $$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<Array<NodeFor<Selector>>, Params> = EvaluateFuncWith<ParseSelector<Selector, Element>[], Params>>(selector: Selector, pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    setCacheEnabled(enabled?: boolean): Promise<void>;
+    setBypassCSP(enabled: boolean): Promise<void>;
+    setJavaScriptEnabled(enabled: boolean): Promise<void>;
+    goBack(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    goForward(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    goto(url: string, options?: GoToOptions): Promise<HTTPResponse | null>;
+    reload(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    metrics(): Promise<Metrics>;
+    setUserAgent(userAgent: string, userAgentMetadata?: Protocol.Emulation.UserAgentMetadata): Promise<void>;
+    setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;
+    authenticate(credentials: Credentials | null): Promise<void>;
+    removeExposedFunction(name: string): Promise<void>;
+    exposeFunction(name: string, pptrFunction: Function | {
+        default: Function;
+    }): Promise<void>;
+    setCookie(...cookies: CookieParam[]): Promise<void>;
+    deleteCookie(...cookies: DeleteCookiesRequest[]): Promise<void>;
+    cookies(...urls: string[]): Promise<Cookie[]>;
+    queryObjects<Prototype>(prototypeHandle: JSHandle<Prototype>): Promise<JSHandle<Prototype[]>>;
+    setDefaultTimeout(timeout: number): void;
+    getDefaultTimeout(): number;
+    setDefaultNavigationTimeout(timeout: number): void;
+    setOfflineMode(enabled: boolean): Promise<void>;
+    emulateNetworkConditions(networkConditions: NetworkConditions | null): Promise<void>;
+    setDragInterception(enabled: boolean): Promise<void>;
+    setBypassServiceWorker(bypass: boolean): Promise<void>;
+    setRequestInterception(value: boolean): Promise<void>;
+    workers(): WebWorker[];
+    frames(): Frame[];
+    createPDFStream(options?: PDFOptions): Promise<ReadableStream<Uint8Array>>;
+    createCDPSession(): Promise<CDPSession>;
+    mainFrame(): Frame;
+    browser(): Browser;
+    bringToFront(): Promise<void>;
+    browserContext(): BrowserContext;
+    target(): Target;
+    setGeolocation(): Promise<void>;
+    waitForFileChooser(): Promise<FileChooser>;
+    isJavaScriptEnabled(): boolean;
+    isDragInterceptionEnabled(): boolean;
+    isServiceWorkerBypassed(): boolean;
+}

package/dist/puppeteer-page-main-process.js

@@ -0,0 +1,358 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import path from 'node:path';
+import { ProcTalk } from '@d-zero/proc-talk';
+import { raceWithTimeout } from '@d-zero/shared/race-with-timeout';
+import { Page } from 'puppeteer';
+import { log } from './debug.js';
+const SUB_PROCESS_PATH = path.resolve(import.meta.dirname, 'puppeteer-page-child-process.js');
+let ChildProcessHostedPuppeteerPage = (() => {
+    let _classDecorators = [UnsafeDefineMethods(['screenshot', 'on'])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Page;
+    var ChildProcessHostedPuppeteerPage = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ChildProcessHostedPuppeteerPage = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        process;
+        #url = 'about:blank';
+        get mouse() {
+            throw new Error('Not implemented');
+        }
+        get tracing() {
+            throw new Error('Not implemented');
+        }
+        get coverage() {
+            throw new Error('Not implemented');
+        }
+        get keyboard() {
+            throw new Error('Not implemented');
+        }
+        get touchscreen() {
+            throw new Error('Not implemented');
+        }
+        get pid() {
+            return this.process.pid;
+        }
+        constructor(options) {
+            super();
+            this.process = new ProcTalk({
+                type: 'main',
+                subModulePath: SUB_PROCESS_PATH,
+                options,
+            });
+        }
+        async initialized() {
+            return await this.process.initialized();
+        }
+        url() {
+            return this.#url;
+        }
+        waitForDevicePrompt(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async setViewport(viewport) {
+            return await this.process.call('setViewport', viewport);
+        }
+        viewport() {
+            throw new Error('Not implemented');
+        }
+        pdf(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async title() {
+            return await this.process.call('title');
+        }
+        async close(options) {
+            const TIME_OUT = 30_000;
+            log('Closing page(%d)', this.process.pid);
+            const { timeout } = await raceWithTimeout(async () => {
+                await this.process.call('close', options);
+            }, TIME_OUT);
+            if (timeout) {
+                log('Timeout(%dms) closing page', TIME_OUT);
+            }
+            const closed = this.process.close();
+            if (!closed) {
+                log('Need force killing process(%d)', this.process.pid);
+            }
+            log('Closed page(%d)', this.process.pid);
+        }
+        isClosed() {
+            throw new Error('Not implemented');
+        }
+        emulate(device) {
+            void device;
+            throw new Error('Not implemented');
+        }
+        emit(type, event) {
+            void type;
+            void event;
+            throw new Error('Not implemented');
+        }
+        emulateCPUThrottling(factor) {
+            void factor;
+            throw new Error('Not implemented');
+        }
+        emulateIdleState(overrides) {
+            void overrides;
+            throw new Error('Not implemented');
+        }
+        emulateMediaFeatures(features) {
+            void features;
+            throw new Error('Not implemented');
+        }
+        emulateMediaType(type) {
+            void type;
+            throw new Error('Not implemented');
+        }
+        emulateTimezone(timezoneId) {
+            void timezoneId;
+            throw new Error('Not implemented');
+        }
+        emulateVisionDeficiency(type) {
+            void type;
+            throw new Error('Not implemented');
+        }
+        removeScriptToEvaluateOnNewDocument(identifier) {
+            void identifier;
+            throw new Error('Not implemented');
+        }
+        evaluate(pageFunction, ...args) {
+            return this.process.call('evaluate', 
+            // @ts-ignore
+            pageFunction, ...args);
+        }
+        evaluateHandle(pageFunction, ...args) {
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        evaluateOnNewDocument(pageFunction, ...args) {
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        $eval(selector, pageFunction, ...args) {
+            void selector;
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        $$eval(selector, pageFunction, ...args) {
+            void selector;
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        setCacheEnabled(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setBypassCSP(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setJavaScriptEnabled(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        goBack(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        goForward(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async goto(url, options) {
+            this.#url = url;
+            return await this.process.call('goto', url, options);
+        }
+        async reload(options) {
+            return await this.process.call('reload', options);
+        }
+        metrics() {
+            throw new Error('Not implemented');
+        }
+        setUserAgent(userAgent, userAgentMetadata) {
+            void userAgent;
+            void userAgentMetadata;
+            throw new Error('Not implemented');
+        }
+        setExtraHTTPHeaders(headers) {
+            void headers;
+            throw new Error('Not implemented');
+        }
+        authenticate(credentials) {
+            void credentials;
+            throw new Error('Not implemented');
+        }
+        removeExposedFunction(name) {
+            void name;
+            throw new Error('Not implemented');
+        }
+        exposeFunction(name, 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        pptrFunction) {
+            void name;
+            void pptrFunction; // cspell: disable-line
+            throw new Error('Not implemented');
+        }
+        setCookie(...cookies) {
+            void cookies;
+            throw new Error('Not implemented');
+        }
+        deleteCookie(...cookies) {
+            void cookies;
+            throw new Error('Not implemented');
+        }
+        cookies(...urls) {
+            void urls;
+            throw new Error('Not implemented');
+        }
+        queryObjects(prototypeHandle) {
+            void prototypeHandle;
+            throw new Error('Not implemented');
+        }
+        setDefaultTimeout(timeout) {
+            void timeout;
+            throw new Error('Not implemented');
+        }
+        getDefaultTimeout() {
+            throw new Error('Not implemented');
+        }
+        setDefaultNavigationTimeout(timeout) {
+            this.process.callSync('setDefaultNavigationTimeout', timeout);
+        }
+        setOfflineMode(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        emulateNetworkConditions(networkConditions) {
+            void networkConditions;
+            throw new Error('Not implemented');
+        }
+        setDragInterception(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setBypassServiceWorker(bypass) {
+            void bypass;
+            throw new Error('Not implemented');
+        }
+        setRequestInterception(value) {
+            void value;
+            throw new Error('Not implemented');
+        }
+        workers() {
+            throw new Error('Not implemented');
+        }
+        frames() {
+            throw new Error('Not implemented');
+        }
+        createPDFStream(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        createCDPSession() {
+            throw new Error('Not implemented');
+        }
+        mainFrame() {
+            throw new Error('Not implemented. `Frame` is returned empty object due to it cannot be serialized');
+            // return this.process.callSync('mainFrame');
+        }
+        browser() {
+            throw new Error('Not implemented');
+        }
+        bringToFront() {
+            throw new Error('Not implemented');
+        }
+        browserContext() {
+            throw new Error('Not implemented');
+        }
+        target() {
+            throw new Error('Not implemented');
+        }
+        setGeolocation() {
+            throw new Error('Not implemented');
+        }
+        waitForFileChooser() {
+            throw new Error('Not implemented');
+        }
+        isJavaScriptEnabled() {
+            throw new Error('Not implemented');
+        }
+        isDragInterceptionEnabled() {
+            throw new Error('Not implemented');
+        }
+        isServiceWorkerBypassed() {
+            throw new Error('Not implemented');
+        }
+    };
+    return ChildProcessHostedPuppeteerPage = _classThis;
+})();
+export { ChildProcessHostedPuppeteerPage };
+function UnsafeDefineMethods(methods) {
+    return (Constructor) => {
+        const addMethod = (name) => {
+            Object.defineProperty(
+            // @ts-ignore
+            Constructor.prototype, name, {
+                value: async function (...args) {
+                    if (this.process) {
+                        return await this.process.call(name, ...args);
+                    }
+                    // @ts-ignore
+                    return Page.prototype[name]?.call?.(this, ...args);
+                },
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        };
+        // eslint-disable-next-line unicorn/no-array-for-each
+        methods.forEach(addMethod);
+    };
+}

package/dist/puppeteer-page-main.d.ts

@@ -0,0 +1,84 @@
+import type { Browser, BrowserContext, CDPSession, Cookie, CookieParam, Coverage, Credentials, DeleteCookiesRequest, Device, DeviceRequestPrompt, EvaluateFunc, EvaluateFuncWith, EventsWithWildcard, FileChooser, Frame, GoToOptions, HandleFor, HTTPResponse, JSHandle, Keyboard, MediaFeature, Metrics, Mouse, NetworkConditions, NewDocumentScriptEvaluation, NodeFor, PageEvents, PDFOptions, Protocol, PuppeteerLaunchOptions, Target, Touchscreen, Tracing, Viewport, WaitForOptions, WaitTimeoutOptions, WebWorker } from 'puppeteer';
+import type { ParseSelector } from 'typed-query-selector/parser.js';
+import { ProcTalk } from '@d-zero/proc-talk';
+import { Page } from 'puppeteer';
+export declare class ExPage extends Page {
+    #private;
+    readonly process: ProcTalk<Page, PuppeteerLaunchOptions>;
+    get mouse(): Mouse;
+    get tracing(): Tracing;
+    get coverage(): Coverage;
+    get keyboard(): Keyboard;
+    get touchscreen(): Touchscreen;
+    get pid(): number;
+    constructor(options?: PuppeteerLaunchOptions);
+    initialized(): Promise<void>;
+    url(): string;
+    waitForDevicePrompt(options?: WaitTimeoutOptions): Promise<DeviceRequestPrompt>;
+    setViewport(viewport: Viewport | null): Promise<void>;
+    viewport(): Viewport | null;
+    pdf(options?: PDFOptions): Promise<Uint8Array>;
+    title(): Promise<string>;
+    close(options?: {
+        runBeforeUnload?: boolean;
+    }): Promise<void>;
+    isClosed(): boolean;
+    emulate(device: Device): Promise<void>;
+    emit<Key extends keyof PageEvents>(type: Key, event: EventsWithWildcard<PageEvents>[Key]): boolean;
+    emulateCPUThrottling(factor: number | null): Promise<void>;
+    emulateIdleState(overrides?: {
+        isUserActive: boolean;
+        isScreenUnlocked: boolean;
+    }): Promise<void>;
+    emulateMediaFeatures(features?: MediaFeature[]): Promise<void>;
+    emulateMediaType(type?: string): Promise<void>;
+    emulateTimezone(timezoneId?: string): Promise<void>;
+    emulateVisionDeficiency(type?: Protocol.Emulation.SetEmulatedVisionDeficiencyRequest['type']): Promise<void>;
+    removeScriptToEvaluateOnNewDocument(identifier: string): Promise<void>;
+    evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    evaluateHandle<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<HandleFor<Awaited<ReturnType<Func>>>>;
+    evaluateOnNewDocument<Params extends unknown[], Func extends (...args: Params) => unknown = (...args: Params) => unknown>(pageFunction: Func | string, ...args: Params): Promise<NewDocumentScriptEvaluation>;
+    $eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<NodeFor<Selector>, Params> = EvaluateFuncWith<ParseSelector<Selector, Element>, Params>>(selector: Selector, pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    $$eval<Selector extends string, Params extends unknown[], Func extends EvaluateFuncWith<Array<NodeFor<Selector>>, Params> = EvaluateFuncWith<ParseSelector<Selector, Element>[], Params>>(selector: Selector, pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
+    setCacheEnabled(enabled?: boolean): Promise<void>;
+    setBypassCSP(enabled: boolean): Promise<void>;
+    setJavaScriptEnabled(enabled: boolean): Promise<void>;
+    goBack(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    goForward(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    goto(url: string, options?: GoToOptions): Promise<HTTPResponse | null>;
+    reload(options?: WaitForOptions): Promise<HTTPResponse | null>;
+    metrics(): Promise<Metrics>;
+    setUserAgent(userAgent: string, userAgentMetadata?: Protocol.Emulation.UserAgentMetadata): Promise<void>;
+    setExtraHTTPHeaders(headers: Record<string, string>): Promise<void>;
+    authenticate(credentials: Credentials | null): Promise<void>;
+    removeExposedFunction(name: string): Promise<void>;
+    exposeFunction(name: string, pptrFunction: Function | {
+        default: Function;
+    }): Promise<void>;
+    setCookie(...cookies: CookieParam[]): Promise<void>;
+    deleteCookie(...cookies: DeleteCookiesRequest[]): Promise<void>;
+    cookies(...urls: string[]): Promise<Cookie[]>;
+    queryObjects<Prototype>(prototypeHandle: JSHandle<Prototype>): Promise<JSHandle<Prototype[]>>;
+    setDefaultTimeout(timeout: number): void;
+    getDefaultTimeout(): number;
+    setDefaultNavigationTimeout(timeout: number): void;
+    setOfflineMode(enabled: boolean): Promise<void>;
+    emulateNetworkConditions(networkConditions: NetworkConditions | null): Promise<void>;
+    setDragInterception(enabled: boolean): Promise<void>;
+    setBypassServiceWorker(bypass: boolean): Promise<void>;
+    setRequestInterception(value: boolean): Promise<void>;
+    workers(): WebWorker[];
+    frames(): Frame[];
+    createPDFStream(options?: PDFOptions): Promise<ReadableStream<Uint8Array>>;
+    createCDPSession(): Promise<CDPSession>;
+    mainFrame(): Frame;
+    browser(): Browser;
+    bringToFront(): Promise<void>;
+    browserContext(): BrowserContext;
+    target(): Target;
+    setGeolocation(): Promise<void>;
+    waitForFileChooser(): Promise<FileChooser>;
+    isJavaScriptEnabled(): boolean;
+    isDragInterceptionEnabled(): boolean;
+    isServiceWorkerBypassed(): boolean;
+}

package/dist/puppeteer-page-main.js

@@ -0,0 +1,358 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import path from 'node:path';
+import { ProcTalk } from '@d-zero/proc-talk';
+import { raceWithTimeout } from '@d-zero/shared/race-with-timeout';
+import { Page } from 'puppeteer';
+import { log } from './debug.js';
+const SUB_PROCESS_PATH = path.resolve(import.meta.dirname, 'puppeteer-page-sub.js');
+let ExPage = (() => {
+    let _classDecorators = [UnsafeDefineMethods(['screenshot', 'on'])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = Page;
+    var ExPage = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ExPage = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        process;
+        #url = 'about:blank';
+        get mouse() {
+            throw new Error('Not implemented');
+        }
+        get tracing() {
+            throw new Error('Not implemented');
+        }
+        get coverage() {
+            throw new Error('Not implemented');
+        }
+        get keyboard() {
+            throw new Error('Not implemented');
+        }
+        get touchscreen() {
+            throw new Error('Not implemented');
+        }
+        get pid() {
+            return this.process.pid;
+        }
+        constructor(options) {
+            super();
+            this.process = new ProcTalk({
+                type: 'main',
+                subModulePath: SUB_PROCESS_PATH,
+                options,
+            });
+        }
+        async initialized() {
+            return await this.process.initialized();
+        }
+        url() {
+            return this.#url;
+        }
+        waitForDevicePrompt(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async setViewport(viewport) {
+            return await this.process.call('setViewport', viewport);
+        }
+        viewport() {
+            throw new Error('Not implemented');
+        }
+        pdf(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async title() {
+            return await this.process.call('title');
+        }
+        async close(options) {
+            const TIME_OUT = 30_000;
+            log('Closing page(%d)', this.process.pid);
+            const { timeout } = await raceWithTimeout(async () => {
+                await this.process.call('close', options);
+            }, TIME_OUT);
+            if (timeout) {
+                log('Timeout(%dms) closing page', TIME_OUT);
+            }
+            const closed = this.process.close();
+            if (!closed) {
+                log('Need force killing process(%d)', this.process.pid);
+            }
+            log('Closed page(%d)', this.process.pid);
+        }
+        isClosed() {
+            throw new Error('Not implemented');
+        }
+        emulate(device) {
+            void device;
+            throw new Error('Not implemented');
+        }
+        emit(type, event) {
+            void type;
+            void event;
+            throw new Error('Not implemented');
+        }
+        emulateCPUThrottling(factor) {
+            void factor;
+            throw new Error('Not implemented');
+        }
+        emulateIdleState(overrides) {
+            void overrides;
+            throw new Error('Not implemented');
+        }
+        emulateMediaFeatures(features) {
+            void features;
+            throw new Error('Not implemented');
+        }
+        emulateMediaType(type) {
+            void type;
+            throw new Error('Not implemented');
+        }
+        emulateTimezone(timezoneId) {
+            void timezoneId;
+            throw new Error('Not implemented');
+        }
+        emulateVisionDeficiency(type) {
+            void type;
+            throw new Error('Not implemented');
+        }
+        removeScriptToEvaluateOnNewDocument(identifier) {
+            void identifier;
+            throw new Error('Not implemented');
+        }
+        evaluate(pageFunction, ...args) {
+            return this.process.call('evaluate', 
+            // @ts-ignore
+            pageFunction, ...args);
+        }
+        evaluateHandle(pageFunction, ...args) {
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        evaluateOnNewDocument(pageFunction, ...args) {
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        $eval(selector, pageFunction, ...args) {
+            void selector;
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        $$eval(selector, pageFunction, ...args) {
+            void selector;
+            void pageFunction;
+            void args;
+            throw new Error('Not implemented');
+        }
+        setCacheEnabled(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setBypassCSP(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setJavaScriptEnabled(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        goBack(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        goForward(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        async goto(url, options) {
+            this.#url = url;
+            return await this.process.call('goto', url, options);
+        }
+        async reload(options) {
+            return await this.process.call('reload', options);
+        }
+        metrics() {
+            throw new Error('Not implemented');
+        }
+        setUserAgent(userAgent, userAgentMetadata) {
+            void userAgent;
+            void userAgentMetadata;
+            throw new Error('Not implemented');
+        }
+        setExtraHTTPHeaders(headers) {
+            void headers;
+            throw new Error('Not implemented');
+        }
+        authenticate(credentials) {
+            void credentials;
+            throw new Error('Not implemented');
+        }
+        removeExposedFunction(name) {
+            void name;
+            throw new Error('Not implemented');
+        }
+        exposeFunction(name, 
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+        pptrFunction) {
+            void name;
+            void pptrFunction; // cspell: disable-line
+            throw new Error('Not implemented');
+        }
+        setCookie(...cookies) {
+            void cookies;
+            throw new Error('Not implemented');
+        }
+        deleteCookie(...cookies) {
+            void cookies;
+            throw new Error('Not implemented');
+        }
+        cookies(...urls) {
+            void urls;
+            throw new Error('Not implemented');
+        }
+        queryObjects(prototypeHandle) {
+            void prototypeHandle;
+            throw new Error('Not implemented');
+        }
+        setDefaultTimeout(timeout) {
+            void timeout;
+            throw new Error('Not implemented');
+        }
+        getDefaultTimeout() {
+            throw new Error('Not implemented');
+        }
+        setDefaultNavigationTimeout(timeout) {
+            // TODO: Async call
+            return void this.process.call('setDefaultNavigationTimeout', timeout);
+        }
+        setOfflineMode(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        emulateNetworkConditions(networkConditions) {
+            void networkConditions;
+            throw new Error('Not implemented');
+        }
+        setDragInterception(enabled) {
+            void enabled;
+            throw new Error('Not implemented');
+        }
+        setBypassServiceWorker(bypass) {
+            void bypass;
+            throw new Error('Not implemented');
+        }
+        setRequestInterception(value) {
+            void value;
+            throw new Error('Not implemented');
+        }
+        workers() {
+            throw new Error('Not implemented');
+        }
+        frames() {
+            throw new Error('Not implemented');
+        }
+        createPDFStream(options) {
+            void options;
+            throw new Error('Not implemented');
+        }
+        createCDPSession() {
+            throw new Error('Not implemented');
+        }
+        mainFrame() {
+            throw new Error('Not implemented');
+        }
+        browser() {
+            throw new Error('Not implemented');
+        }
+        bringToFront() {
+            throw new Error('Not implemented');
+        }
+        browserContext() {
+            throw new Error('Not implemented');
+        }
+        target() {
+            throw new Error('Not implemented');
+        }
+        setGeolocation() {
+            throw new Error('Not implemented');
+        }
+        waitForFileChooser() {
+            throw new Error('Not implemented');
+        }
+        isJavaScriptEnabled() {
+            throw new Error('Not implemented');
+        }
+        isDragInterceptionEnabled() {
+            throw new Error('Not implemented');
+        }
+        isServiceWorkerBypassed() {
+            throw new Error('Not implemented');
+        }
+    };
+    return ExPage = _classThis;
+})();
+export { ExPage };
+function UnsafeDefineMethods(methods) {
+    return (Constructor) => {
+        const addMethod = (name) => {
+            Object.defineProperty(
+            // @ts-ignore
+            Constructor.prototype, name, {
+                value: async function (...args) {
+                    if (this.process) {
+                        return await this.process.call(name, ...args);
+                    }
+                    // @ts-ignore
+                    return Page.prototype[name]?.call?.(this, ...args);
+                },
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        };
+        // eslint-disable-next-line unicorn/no-array-for-each
+        methods.forEach(addMethod);
+    };
+}

package/dist/puppeteer-page-sub.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/puppeteer-page-sub.js

@@ -0,0 +1,29 @@
+/* use as a sub-process */
+import { ProcTalk } from '@d-zero/proc-talk';
+import puppeteer from 'puppeteer';
+process.title = '@d-zero/puppeteer-dealer:sub-process';
+new ProcTalk({
+    type: 'child',
+    async process(options) {
+        this.log('Starting puppeteer: %O', options);
+        const browser = await puppeteer.launch(options);
+        const page = await browser?.newPage();
+        const cleanUp = async () => {
+            this.log('Cleanup start');
+            await page?.close();
+            await browser?.close();
+            this.log('Cleanup done');
+        };
+        this.bind('evaluate', page.evaluate.bind(page));
+        this.bind('goto', page.goto.bind(page));
+        this.bind('title', page.title.bind(page));
+        this.bind('setDefaultNavigationTimeout', page.setDefaultNavigationTimeout.bind(page));
+        this.bind('setViewport', page.setViewport.bind(page));
+        this.bind('screenshot', page.screenshot.bind(page));
+        this.bind('reload', page.reload.bind(page));
+        this.bind('on', page.on.bind(page));
+        this.bind('close', async () => {
+            await cleanUp();
+        });
+    },
+});

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import type { DealOptions } from '@d-zero/dealer';
+import type { Page } from '@d-zero/puppeteer-page';
+export type PuppeteerDealerOptions = {
+    readonly locale?: string;
+} & DealOptions;
+export type PuppeteerDealHandler = {
+    beforeOpenPage?: (id: string, url: string, log: Logger, index: number) => Promise<boolean>;
+    deal: (page: Page, id: string, url: string, log: Logger, index: number) => Promise<void>;
+};
+export type URLInfo = {
+    readonly id: string | null;
+    readonly url: string | URL;
+};
+export type Logger = (log: string) => void;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@d-zero/puppeteer-dealer",
+	"version": "0.2.0",
+	"description": "Puppeteer handles each page",
+	"author": "D-ZERO",
+	"license": "MIT",
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc",
+		"watch": "tsc --watch",
+		"clean": "tsc --build --clean"
+	},
+	"dependencies": {
+		"@d-zero/dealer": "1.2.0",
+		"@d-zero/puppeteer-page": "0.2.0",
+		"@d-zero/shared": "0.6.0",
+		"ansi-colors": "4.1.3",
+		"debug": "4.3.7"
+	},
+	"devDependencies": {
+		"puppeteer": "23.6.1"
+	},
+	"gitHead": "1eb1c03400580040119121e11ffb33acd876fe1b"
+}