@bctrl/sdk 1.0.1

package/dist/workspaces/runtime-event-pump.js

@@ -0,0 +1,716 @@
+import { setRemoteListenerBinding, } from '../base/event-binding.js';
+const WAIT_TIMEOUT_MS = 30_000;
+const ERROR_RETRY_DELAY_MS = 250;
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    return value;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : null;
+}
+function asNumber(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    return value;
+}
+function asBoolean(value) {
+    return typeof value === 'boolean' ? value : null;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+function cursorFromEvent(event) {
+    if (!event.createdAt || !event.id)
+        return null;
+    return `${event.createdAt}|${event.id}`;
+}
+class SyntheticConsoleMessage {
+    level;
+    textValue;
+    locationValue;
+    constructor(level, textValue, locationValue) {
+        this.level = level;
+        this.textValue = textValue;
+        this.locationValue = locationValue;
+    }
+    type() {
+        return this.level;
+    }
+    text() {
+        return this.textValue;
+    }
+    location() {
+        return this.locationValue;
+    }
+    stackTrace() {
+        return [];
+    }
+    args() {
+        return [];
+    }
+    page() {
+        return null;
+    }
+    worker() {
+        return null;
+    }
+}
+class SyntheticDialog {
+    dialogType;
+    dialogMessage;
+    dialogDefaultValue;
+    invoke;
+    constructor(dialogType, dialogMessage, dialogDefaultValue, invoke) {
+        this.dialogType = dialogType;
+        this.dialogMessage = dialogMessage;
+        this.dialogDefaultValue = dialogDefaultValue;
+        this.invoke = invoke;
+    }
+    async accept(promptText) {
+        if (!this.invoke) {
+            throw new Error('Dialog actions are not available for this event');
+        }
+        await this.invoke('accept', promptText);
+    }
+    async dismiss() {
+        if (!this.invoke) {
+            throw new Error('Dialog actions are not available for this event');
+        }
+        await this.invoke('dismiss');
+    }
+    type() {
+        return this.dialogType;
+    }
+    message() {
+        return this.dialogMessage;
+    }
+    defaultValue() {
+        return this.dialogDefaultValue;
+    }
+}
+class SyntheticFrame {
+    frameUrl;
+    frameName;
+    constructor(frameUrl, frameName = null) {
+        this.frameUrl = frameUrl;
+        this.frameName = frameName;
+    }
+    url() {
+        return this.frameUrl;
+    }
+    name() {
+        return this.frameName ?? '';
+    }
+}
+class SyntheticResponse {
+    responseUrl;
+    responseStatus;
+    responseStatusText;
+    responseHeaders;
+    responseRequest;
+    constructor(responseUrl, responseStatus, responseStatusText, responseHeaders, responseRequest = null) {
+        this.responseUrl = responseUrl;
+        this.responseStatus = responseStatus;
+        this.responseStatusText = responseStatusText;
+        this.responseHeaders = responseHeaders;
+        this.responseRequest = responseRequest;
+    }
+    url() {
+        return this.responseUrl;
+    }
+    status() {
+        return this.responseStatus;
+    }
+    statusText() {
+        return this.responseStatusText;
+    }
+    ok() {
+        return this.responseStatus >= 200 && this.responseStatus < 300;
+    }
+    headers() {
+        return this.responseHeaders;
+    }
+    request() {
+        return this.responseRequest;
+    }
+}
+class SyntheticRequest {
+    requestUrl;
+    requestMethod;
+    requestResourceType;
+    requestHeaders;
+    requestErrorText;
+    requestTiming;
+    requestResponse;
+    constructor(requestUrl, requestMethod, requestResourceType, requestHeaders, requestErrorText, requestResponse = null, requestTiming = null) {
+        this.requestUrl = requestUrl;
+        this.requestMethod = requestMethod;
+        this.requestResourceType = requestResourceType;
+        this.requestHeaders = requestHeaders;
+        this.requestErrorText = requestErrorText;
+        this.requestTiming = requestTiming;
+        this.requestResponse = requestResponse;
+    }
+    url() {
+        return this.requestUrl;
+    }
+    method() {
+        return this.requestMethod;
+    }
+    resourceType() {
+        return this.requestResourceType;
+    }
+    headers() {
+        return this.requestHeaders;
+    }
+    failure() {
+        if (!this.requestErrorText)
+            return null;
+        return { errorText: this.requestErrorText };
+    }
+    response() {
+        return this.requestResponse;
+    }
+    setResponse(response) {
+        this.requestResponse = response;
+    }
+    timing() {
+        return this.requestTiming;
+    }
+}
+class SyntheticDownload {
+    downloadUrl;
+    downloadSuggestedFilename;
+    downloadPath;
+    constructor(downloadUrl, downloadSuggestedFilename, downloadPath) {
+        this.downloadUrl = downloadUrl;
+        this.downloadSuggestedFilename = downloadSuggestedFilename;
+        this.downloadPath = downloadPath;
+    }
+    url() {
+        return this.downloadUrl;
+    }
+    suggestedFilename() {
+        return this.downloadSuggestedFilename;
+    }
+    async path() {
+        return this.downloadPath;
+    }
+}
+class SyntheticFileChooser {
+    multiple;
+    constructor(multiple) {
+        this.multiple = multiple;
+    }
+    isMultiple() {
+        return this.multiple;
+    }
+}
+class SyntheticWebSocket {
+    socketUrl;
+    constructor(socketUrl) {
+        this.socketUrl = socketUrl;
+    }
+    url() {
+        return this.socketUrl;
+    }
+}
+class SyntheticWorker {
+    workerUrl;
+    constructor(workerUrl) {
+        this.workerUrl = workerUrl;
+    }
+    url() {
+        return this.workerUrl;
+    }
+}
+export class RuntimeEventPump {
+    waiter;
+    pageEmitters = new Set();
+    pageEmitterRecords = new WeakMap();
+    contextEmitters = new Set();
+    contextEmitterRecords = new WeakMap();
+    activeBindingCounts = new Map();
+    activeBackendTypeCounts = new Map();
+    activeBindingTotal = 0;
+    cursor = null;
+    disposed = false;
+    currentEventTypesKey = null;
+    waitAbortController = null;
+    waitPromise = null;
+    constructor(waiter) {
+        this.waiter = waiter;
+    }
+    registerPageEmitter(registration) {
+        if (this.disposed)
+            return;
+        const emitterKey = registration.emitter;
+        if (this.pageEmitterRecords.has(emitterKey))
+            return;
+        const record = {
+            ...registration,
+            activeBackendTypes: new Set(),
+            backendTypeToEvent: new Map(Object.entries(registration.eventMap).map(([eventName, backendType]) => [
+                backendType,
+                eventName,
+            ])),
+        };
+        this.pageEmitters.add(record);
+        this.pageEmitterRecords.set(emitterKey, record);
+        const binding = {
+            onFirstListener: (eventName) => {
+                const backendType = record.eventMap[eventName];
+                if (!backendType || record.activeBackendTypes.has(backendType))
+                    return;
+                record.activeBackendTypes.add(backendType);
+                this.incrementBinding('page', record.pageId, backendType);
+            },
+            onNoListeners: (eventName) => {
+                const backendType = record.eventMap[eventName];
+                if (!backendType || !record.activeBackendTypes.has(backendType))
+                    return;
+                record.activeBackendTypes.delete(backendType);
+                this.decrementBinding('page', record.pageId, backendType);
+            },
+        };
+        setRemoteListenerBinding(registration.emitter, binding);
+        for (const [eventName, backendType] of Object.entries(registration.eventMap)) {
+            if (registration.emitter.listenerCount(eventName) <= 0)
+                continue;
+            if (record.activeBackendTypes.has(backendType))
+                continue;
+            record.activeBackendTypes.add(backendType);
+            this.incrementBinding('page', record.pageId, backendType);
+        }
+    }
+    registerContextEmitter(registration) {
+        if (this.disposed)
+            return;
+        const emitterKey = registration.emitter;
+        if (this.contextEmitterRecords.has(emitterKey))
+            return;
+        const record = {
+            ...registration,
+            activeBackendTypes: new Set(),
+            backendTypeToEvent: new Map(Object.entries(registration.eventMap).map(([eventName, backendType]) => [
+                backendType,
+                eventName,
+            ])),
+        };
+        this.contextEmitters.add(record);
+        this.contextEmitterRecords.set(emitterKey, record);
+        const binding = {
+            onFirstListener: (eventName) => {
+                const backendType = record.eventMap[eventName];
+                if (!backendType || record.activeBackendTypes.has(backendType))
+                    return;
+                record.activeBackendTypes.add(backendType);
+                this.incrementBinding('context', record.contextId, backendType);
+            },
+            onNoListeners: (eventName) => {
+                const backendType = record.eventMap[eventName];
+                if (!backendType || !record.activeBackendTypes.has(backendType))
+                    return;
+                record.activeBackendTypes.delete(backendType);
+                this.decrementBinding('context', record.contextId, backendType);
+            },
+        };
+        setRemoteListenerBinding(registration.emitter, binding);
+        for (const [eventName, backendType] of Object.entries(registration.eventMap)) {
+            if (registration.emitter.listenerCount(eventName) <= 0)
+                continue;
+            if (record.activeBackendTypes.has(backendType))
+                continue;
+            record.activeBackendTypes.add(backendType);
+            this.incrementBinding('context', record.contextId, backendType);
+        }
+    }
+    async close() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        if (this.waitAbortController) {
+            this.waitAbortController.abort();
+            this.waitAbortController = null;
+        }
+        for (const record of this.pageEmitters) {
+            setRemoteListenerBinding(record.emitter, null);
+            record.activeBackendTypes.clear();
+        }
+        for (const record of this.contextEmitters) {
+            setRemoteListenerBinding(record.emitter, null);
+            record.activeBackendTypes.clear();
+        }
+        this.pageEmitters.clear();
+        this.contextEmitters.clear();
+        this.activeBindingCounts.clear();
+        this.activeBackendTypeCounts.clear();
+        this.activeBindingTotal = 0;
+        this.currentEventTypesKey = null;
+        if (this.waitPromise) {
+            try {
+                await this.waitPromise;
+            }
+            catch {
+                // Ignore shutdown race errors.
+            }
+            this.waitPromise = null;
+        }
+    }
+    bindingKey(scope, id, backendType) {
+        return `${scope}:${id}::${backendType}`;
+    }
+    activeBackendTypes() {
+        return Array.from(this.activeBackendTypeCounts.entries())
+            .filter(([, count]) => count > 0)
+            .map(([backendType]) => backendType)
+            .sort();
+    }
+    backendTypesKey(eventTypes) {
+        return eventTypes.join(',');
+    }
+    updateCursor(cursor) {
+        if (typeof cursor !== 'string' || cursor.trim().length === 0)
+            return;
+        this.cursor = cursor.trim();
+    }
+    incrementBinding(scope, id, backendType) {
+        const key = this.bindingKey(scope, id, backendType);
+        const next = (this.activeBindingCounts.get(key) ?? 0) + 1;
+        this.activeBindingCounts.set(key, next);
+        const typeNext = (this.activeBackendTypeCounts.get(backendType) ?? 0) + 1;
+        this.activeBackendTypeCounts.set(backendType, typeNext);
+        if (next === 1) {
+            this.activeBindingTotal += 1;
+        }
+        this.reconfigureLoopIfNeeded();
+    }
+    decrementBinding(scope, id, backendType) {
+        const key = this.bindingKey(scope, id, backendType);
+        const current = this.activeBindingCounts.get(key) ?? 0;
+        if (current <= 0)
+            return;
+        if (current === 1) {
+            this.activeBindingCounts.delete(key);
+            this.activeBindingTotal = Math.max(0, this.activeBindingTotal - 1);
+        }
+        else {
+            this.activeBindingCounts.set(key, current - 1);
+        }
+        const typeCurrent = this.activeBackendTypeCounts.get(backendType) ?? 0;
+        if (typeCurrent <= 1) {
+            this.activeBackendTypeCounts.delete(backendType);
+        }
+        else {
+            this.activeBackendTypeCounts.set(backendType, typeCurrent - 1);
+        }
+        this.reconfigureLoopIfNeeded();
+    }
+    reconfigureLoopIfNeeded() {
+        if (this.disposed)
+            return;
+        if (this.activeBindingTotal === 0) {
+            if (this.waitAbortController) {
+                this.waitAbortController.abort();
+            }
+            return;
+        }
+        const desiredKey = this.backendTypesKey(this.activeBackendTypes());
+        if (!this.waitPromise) {
+            this.ensureLoop();
+            return;
+        }
+        if (this.currentEventTypesKey !== desiredKey && this.waitAbortController) {
+            this.waitAbortController.abort();
+        }
+    }
+    ensureLoop() {
+        if (this.disposed)
+            return;
+        if (this.activeBindingTotal === 0)
+            return;
+        if (this.waitPromise)
+            return;
+        const eventTypes = this.activeBackendTypes();
+        if (eventTypes.length === 0)
+            return;
+        const controller = new AbortController();
+        this.waitAbortController = controller;
+        this.currentEventTypesKey = this.backendTypesKey(eventTypes);
+        const loopPromise = this.runWaitLoop(controller.signal, eventTypes).finally(() => {
+            if (this.waitPromise === loopPromise) {
+                this.waitPromise = null;
+            }
+            if (this.waitAbortController === controller) {
+                this.waitAbortController = null;
+            }
+            this.currentEventTypesKey = null;
+            if (!this.disposed && this.activeBindingTotal > 0) {
+                this.ensureLoop();
+            }
+        });
+        this.waitPromise = loopPromise;
+    }
+    async runWaitLoop(signal, eventTypes) {
+        while (!signal.aborted && !this.disposed && this.activeBindingTotal > 0) {
+            try {
+                const result = await this.waiter.wait({
+                    ...(this.cursor ? { after: this.cursor } : {}),
+                    timeoutMs: WAIT_TIMEOUT_MS,
+                    eventTypes,
+                }, { signal });
+                this.updateCursor(result.cursor);
+                if (result.event) {
+                    this.dispatchRuntimeEvent(result.event);
+                    if (!result.cursor) {
+                        this.updateCursor(cursorFromEvent(result.event));
+                    }
+                }
+            }
+            catch (error) {
+                if (signal.aborted || this.disposed || this.activeBindingTotal === 0) {
+                    return;
+                }
+                if (isAbortError(error)) {
+                    return;
+                }
+                await sleep(ERROR_RETRY_DELAY_MS, signal);
+            }
+        }
+    }
+    dispatchRuntimeEvent(event) {
+        const eventData = asRecord(event.eventData);
+        if (event.eventType.startsWith('context.')) {
+            const contextId = asString(eventData?.contextId);
+            if (contextId) {
+                this.dispatchContextEvent(event, contextId, eventData);
+            }
+            return;
+        }
+        const pageId = asString(eventData?.pageId);
+        if (pageId) {
+            this.dispatchPageEvent(event, pageId, eventData);
+            return;
+        }
+        const contextId = asString(eventData?.contextId);
+        if (contextId) {
+            this.dispatchContextEvent(event, contextId, eventData);
+        }
+    }
+    dispatchPageEvent(event, pageId, eventData) {
+        const records = Array.from(this.pageEmitters).filter((record) => record.pageId === pageId);
+        if (records.length === 0)
+            return;
+        const isPageClosedEvent = event.eventType === 'page.closed';
+        for (const record of records) {
+            const pageEventName = record.backendTypeToEvent.get(event.eventType);
+            if (!pageEventName)
+                continue;
+            if (isPageClosedEvent && typeof record.emitter.markClosed === 'function') {
+                record.emitter.markClosed();
+            }
+            if (record.emitter.listenerCount(pageEventName) > 0) {
+                const payload = this.buildPagePayload(record, event.eventType, eventData);
+                record.emitter.emit(pageEventName, payload);
+            }
+            if (isPageClosedEvent) {
+                this.unregisterPageEmitter(record);
+            }
+        }
+    }
+    dispatchContextEvent(event, contextId, eventData) {
+        const records = Array.from(this.contextEmitters).filter((record) => record.contextId === contextId);
+        if (records.length === 0)
+            return;
+        const isContextClosedEvent = event.eventType === 'context.closed';
+        for (const record of records) {
+            const contextEventName = record.backendTypeToEvent.get(event.eventType);
+            if (!contextEventName)
+                continue;
+            const maybeMarkClosed = record.emitter.markClosed;
+            if (isContextClosedEvent && typeof maybeMarkClosed === 'function') {
+                maybeMarkClosed.call(record.emitter);
+            }
+            if (record.emitter.listenerCount(contextEventName) > 0) {
+                const payload = this.buildContextPayload(record, event.eventType, eventData);
+                record.emitter.emit(contextEventName, payload);
+            }
+            if (isContextClosedEvent) {
+                this.unregisterContextEmitter(record);
+            }
+        }
+    }
+    unregisterPageEmitter(record) {
+        if (!this.pageEmitters.has(record))
+            return;
+        setRemoteListenerBinding(record.emitter, null);
+        this.pageEmitters.delete(record);
+        this.pageEmitterRecords.delete(record.emitter);
+        const activeBackendTypes = Array.from(record.activeBackendTypes);
+        for (const backendType of activeBackendTypes) {
+            this.decrementBinding('page', record.pageId, backendType);
+        }
+        record.activeBackendTypes.clear();
+    }
+    unregisterContextEmitter(record) {
+        if (!this.contextEmitters.has(record))
+            return;
+        setRemoteListenerBinding(record.emitter, null);
+        this.contextEmitters.delete(record);
+        this.contextEmitterRecords.delete(record.emitter);
+        const activeBackendTypes = Array.from(record.activeBackendTypes);
+        for (const backendType of activeBackendTypes) {
+            this.decrementBinding('context', record.contextId, backendType);
+        }
+        record.activeBackendTypes.clear();
+    }
+    createPageForEvent(record, pageId) {
+        if (!record.createPage)
+            return null;
+        try {
+            return record.createPage(pageId);
+        }
+        catch {
+            return null;
+        }
+    }
+    buildPagePayload(record, backendType, eventData) {
+        switch (backendType) {
+            case 'console': {
+                const level = asString(eventData?.level) ?? 'log';
+                const textValue = asString(eventData?.text) ?? '';
+                const location = asRecord(eventData?.location) ?? {};
+                return new SyntheticConsoleMessage(level, textValue, location);
+            }
+            case 'page.error': {
+                const message = asString(eventData?.message) ?? 'Page error';
+                const error = new Error(message);
+                const stack = asString(eventData?.stack);
+                if (stack)
+                    error.stack = stack;
+                return error;
+            }
+            case 'page.request': {
+                const url = asString(eventData?.url) ?? '';
+                const method = asString(eventData?.method) ?? 'GET';
+                const resourceType = asString(eventData?.resourceType) ?? 'other';
+                const headers = asRecord(eventData?.headers) ?? {};
+                return new SyntheticRequest(url, method, resourceType, headers, null);
+            }
+            case 'page.request_failed': {
+                const url = asString(eventData?.url) ?? '';
+                const method = asString(eventData?.method) ?? 'GET';
+                const resourceType = asString(eventData?.resourceType) ?? 'other';
+                const errorText = asString(eventData?.errorText) ?? null;
+                const headers = asRecord(eventData?.headers) ?? {};
+                return new SyntheticRequest(url, method, resourceType, headers, errorText);
+            }
+            case 'page.request_finished': {
+                const url = asString(eventData?.url) ?? '';
+                const method = asString(eventData?.method) ?? 'GET';
+                const resourceType = asString(eventData?.resourceType) ?? 'other';
+                const headers = asRecord(eventData?.headers) ?? {};
+                const timing = asRecord(eventData?.timing);
+                const request = new SyntheticRequest(url, method, resourceType, headers, null, null, timing);
+                const status = asNumber(eventData?.status);
+                const statusText = asString(eventData?.statusText);
+                if (status !== null || statusText !== null) {
+                    const response = new SyntheticResponse(url, status ?? 0, statusText ?? '', {}, request);
+                    request.setResponse(response);
+                }
+                return request;
+            }
+            case 'page.response': {
+                const url = asString(eventData?.url) ?? '';
+                const method = asString(eventData?.method) ?? 'GET';
+                const resourceType = asString(eventData?.resourceType) ?? 'other';
+                const responseHeaders = asRecord(eventData?.headers) ?? {};
+                const request = new SyntheticRequest(url, method, resourceType, {}, null);
+                const response = new SyntheticResponse(url, asNumber(eventData?.status) ?? 0, asString(eventData?.statusText) ?? '', responseHeaders, request);
+                request.setResponse(response);
+                return response;
+            }
+            case 'page.dialog': {
+                const type = asString(eventData?.dialogType) ?? 'alert';
+                const message = asString(eventData?.message) ?? '';
+                const defaultValue = asString(eventData?.defaultValue) ?? '';
+                const dialogId = asString(eventData?.dialogId);
+                const invoke = dialogId && record.callDialogAction
+                    ? async (action, promptText) => {
+                        await record.callDialogAction?.(dialogId, action, promptText);
+                    }
+                    : undefined;
+                return new SyntheticDialog(type, message, defaultValue, invoke);
+            }
+            case 'page.navigated': {
+                return new SyntheticFrame(asString(eventData?.url) ?? '', asString(eventData?.frameName));
+            }
+            case 'page.frame_attached':
+            case 'page.frame_detached': {
+                return new SyntheticFrame(asString(eventData?.frameUrl) ?? '', asString(eventData?.frameName));
+            }
+            case 'page.popup': {
+                const popupPageId = asString(eventData?.popupPageId);
+                if (!popupPageId)
+                    return eventData;
+                const popupPage = this.createPageForEvent(record, popupPageId);
+                return popupPage ?? eventData;
+            }
+            case 'page.download': {
+                const url = asString(eventData?.url) ?? '';
+                const suggestedFilename = asString(eventData?.suggestedFilename) ?? '';
+                const path = asString(eventData?.path);
+                return new SyntheticDownload(url, suggestedFilename, path ?? null);
+            }
+            case 'page.filechooser': {
+                const isMultiple = asBoolean(eventData?.isMultiple) ?? false;
+                return new SyntheticFileChooser(isMultiple);
+            }
+            case 'page.domcontentloaded':
+            case 'page.load':
+            case 'page.crash':
+            case 'page.closed':
+                return undefined;
+            case 'page.websocket':
+                return new SyntheticWebSocket(asString(eventData?.wsUrl) ?? '');
+            case 'page.worker':
+                return new SyntheticWorker(asString(eventData?.workerUrl) ?? '');
+            default:
+                return eventData;
+        }
+    }
+    buildContextPayload(record, backendType, eventData) {
+        switch (backendType) {
+            case 'context.page_created': {
+                const pageId = asString(eventData?.pageId);
+                if (!pageId)
+                    return eventData;
+                const page = this.createPageForEvent(record, pageId);
+                return page ?? eventData;
+            }
+            case 'context.closed':
+                return undefined;
+            default:
+                return eventData;
+        }
+    }
+}