@bctrl/sdk 1.0.1 → 1.0.3

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

@@ -1,716 +0,0 @@
-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;
-        }
-    }
-}