@swmansion/popcorn 0.3.2 → 0.4.0-next.0

package/dist/popcorn.mjs

@@ -1,381 +0,0 @@
-import { IframeBridge } from './bridge.mjs';
-import { HEARTBEAT_TIMEOUT_MS, INIT_VM_TIMEOUT_MS, MESSAGES, EVENT_NAMES, MAX_RELOAD_N, CALL_TIMEOUT_MS } from './types.mjs';
-import { throwError, buildError, PopcornError } from './errors.mjs';
-export { PopcornInternalError } from './errors.mjs';
-
-const INIT_TOKEN = Symbol();
-const IFRAME_URL = new URL("./iframe.mjs", import.meta.url).href;
-/**
- * Manages Elixir by setting up iframe, WASM module, and event listeners. Used to sent messages to Elixir processes.
- */
-class Popcorn {
-    heartbeatTimeoutMs = null;
-    onReloadCallback;
-    bridge = null;
-    bridgeConfig;
-    debug = false;
-    bundleURLs;
-    state = { status: "uninitialized" };
-    defaultReceiver = null;
-    requestId = 0;
-    calls = new Map();
-    logListeners = {
-        stdout: new Set(),
-        stderr: new Set(),
-    };
-    messageHandlers = new Set();
-    mountResolve = null;
-    heartbeatTimeout = null;
-    reloadN = 0;
-    constructor(params, token) {
-        if (token !== INIT_TOKEN)
-            throwError({ t: "private_constructor" });
-        const bundlePaths = params.bundlePaths ?? ["/bundle.avm"];
-        this.bundleURLs = bundlePaths.map((p) => new URL(p, import.meta.url).href);
-        this.onReloadCallback = params.onReload ?? noop;
-        this.debug = params.debug ?? false;
-        this.bridgeConfig = {
-            container: params.container,
-            script: { url: IFRAME_URL, entrypoint: "initVm" },
-            config: Object.fromEntries(this.bundleURLs.map((url, i) => [`bundle-path-${i}`, url])),
-            debug: true,
-            onMessage: this.iframeHandler.bind(this),
-        };
-        this.logListeners.stdout.add(params.onStdout ?? console.log);
-        this.logListeners.stderr.add(params.onStderr ?? console.warn);
-        this.heartbeatTimeoutMs = params.heartbeatTimeoutMs ?? HEARTBEAT_TIMEOUT_MS;
-    }
-    /**
-     * Creates an iframe and sets up communication channels.
-     * Returns after the Elixir app calls `Popcorn.Wasm.ready/0,1`.
-     *
-     * @example
-     * import { Popcorn } from "@swmansion/popcorn";
-     * const popcorn = await Popcorn.init({
-     *   onStdout: console.log,
-     *   onStderr: console.error,
-     *   debug: true,
-     * });
-     */
-    static async init(options) {
-        const { container, ...constructorParams } = options;
-        const containerWithDefault = container ?? document.documentElement;
-        const bundlePaths = constructorParams.bundlePaths && constructorParams.bundlePaths.length > 0
-            ? constructorParams.bundlePaths
-            : [await resolveBundleURL("/bundle.avm", "/assets/bundle.avm")];
-        const popcorn = new Popcorn({ ...constructorParams, bundlePaths, container: containerWithDefault }, INIT_TOKEN);
-        popcorn.trace("Main: init, params: ", { container, ...constructorParams });
-        await popcorn.mount();
-        return popcorn;
-    }
-    async mount() {
-        if (this.bridge !== null)
-            throwError({ t: "already_mounted" });
-        this.assertStatus(["uninitialized", "reload"]);
-        this.transition({ status: "mount" });
-        this.trace("Main: mount, container: ", this.bridgeConfig.container);
-        this.bridge = new IframeBridge(this.bridgeConfig);
-        try {
-            const mountPromise = new Promise((resolve) => {
-                this.mountResolve = resolve;
-            });
-            let initTimeout;
-            await Promise.race([
-                mountPromise,
-                new Promise((_, reject) => {
-                    initTimeout = setTimeout(() => reject(buildError({ t: "app_ready_timeout" })), INIT_VM_TIMEOUT_MS);
-                }),
-            ]);
-            clearTimeout(initTimeout);
-            this.transition({ status: "ready" });
-            this.trace("Main: mounted");
-            this.onHeartbeat();
-        }
-        catch (error) {
-            this.deinit();
-            throw error;
-        }
-    }
-    /**
-     * Sends a message to an Elixir process and awaits for the response.
-     *
-     * If Elixir doesn't respond in configured timeout, the returned promise will be rejected with "process timeout" error.
-     *
-     * Unless passed via options, the name passed in `Popcorn.Wasm.set_default_receiver/1` on the Elixir side is used.
-     * Throws "Unspecified target process" if default process is not set and no process is specified.
-     *
-     * @example
-     * const result = await popcorn.call(
-     *   { action: "get_user", id: 123 },
-     *   { process: "user_server", timeoutMs: 5_000 },
-     * );
-     * console.log(result.data); // Deserialized Elixir response
-     * console.log(result.durationMs); // Entire call duration
-     */
-    async call(args, { process, timeoutMs } = {}) {
-        this.assertStatus(["ready"]);
-        const targetProcess = process ?? this.defaultReceiver;
-        if (targetProcess === null)
-            throwError({ t: "bad_target" });
-        if (this.bridge === null)
-            throwError({ t: "unmounted" });
-        const requestId = this.requestId++;
-        const startTimeMs = performance.now();
-        const callPromise = new Promise((resolve) => {
-            this.calls.set(requestId, { acknowledged: false, startTimeMs, resolve });
-        });
-        this.trace("Main: call: ", { requestId, process, args });
-        this.bridge.sendIframeRequest({
-            type: MESSAGES.CALL,
-            value: { requestId, process: targetProcess, args },
-        });
-        const result = await withTimeout(callPromise, timeoutMs ?? CALL_TIMEOUT_MS);
-        this.calls.delete(requestId);
-        return result;
-    }
-    /**
-     * Sends a message to an Elixir process (default or from options) and returns immediately.
-     *
-     * Unless passed via options, the name passed in `Popcorn.Wasm.set_default_receiver/1` on the Elixir side is used.
-     * Throws "Unspecified target process" if default process is not set and no process is specified.
-     */
-    cast(args, { process } = {}) {
-        this.assertStatus(["ready"]);
-        const targetProcess = process ?? this.defaultReceiver;
-        if (targetProcess === null)
-            throwError({ t: "bad_target" });
-        if (this.bridge === null)
-            throwError({ t: "unmounted" });
-        const requestId = this.requestId++;
-        this.trace("Main: cast: ", { requestId, process, args });
-        this.bridge.sendIframeRequest({
-            type: MESSAGES.CAST,
-            value: { requestId, process: targetProcess, args },
-        });
-    }
-    /**
-     * Destroys an iframe and resets the instance.
-     */
-    deinit() {
-        if (this.bridge === null)
-            throwError({ t: "unmounted" });
-        this.trace("Main: deinit");
-        this.transition({ status: "deinit" });
-        this.teardownBridge("deinitialized");
-        this.logListeners.stdout.clear();
-        this.logListeners.stderr.clear();
-        this.messageHandlers.clear();
-    }
-    teardownBridge(errorCode) {
-        if (this.bridge) {
-            this.bridge.deinit();
-            this.bridge = null;
-        }
-        this.mountResolve = null;
-        this.defaultReceiver = null;
-        if (this.heartbeatTimeout) {
-            clearTimeout(this.heartbeatTimeout);
-            this.heartbeatTimeout = null;
-        }
-        for (const callData of this.calls.values()) {
-            const durationMs = performance.now() - callData.startTimeMs;
-            callData.resolve({
-                ok: false,
-                error: new PopcornError(errorCode),
-                durationMs,
-            });
-        }
-        this.calls.clear();
-    }
-    /**
-     * Registers a log listener that will be called when output of the specified type is received.
-     */
-    registerLogListener(listener, type) {
-        this.logListeners[type].add(listener);
-    }
-    /**
-     * Unregisters a previously registered log listener.
-     */
-    unregisterLogListener(listener, type) {
-        this.logListeners[type].delete(listener);
-    }
-    notifyLogListeners(type, message) {
-        this.logListeners[type].forEach((listener) => {
-            listener(message);
-        });
-    }
-    /**
-     * Registers a catch-all event handler. Returns an unsubscribe function.
-     */
-    onMessage(handler) {
-        this.messageHandlers.add(handler);
-        return () => {
-            this.messageHandlers.delete(handler);
-        };
-    }
-    onEvent({ eventName, payload }) {
-        if (eventName.startsWith("popcorn")) {
-            if (eventName === EVENT_NAMES.ELIXIR_READY) {
-                this.trace("Main: elixir VM ready");
-            }
-            else if (eventName === EVENT_NAMES.APP_READY) {
-                this.defaultReceiver = payload.name;
-                this.mountResolve?.();
-                this.mountResolve = null;
-            }
-            else if (eventName === EVENT_NAMES.SET_DEFAULT_RECEIVER) {
-                this.defaultReceiver = payload.name;
-            }
-            else {
-                this.trace("Unknown internal event:", eventName);
-            }
-            return;
-        }
-        this.messageHandlers.forEach((handler) => {
-            try {
-                handler(eventName, payload);
-            }
-            catch (error) {
-                console.error(`Error in onMessage handler for '${eventName}':`, error);
-            }
-        });
-    }
-    iframeHandler(data) {
-        if (data.type === MESSAGES.EVENT) {
-            this.onEvent(data.value);
-        }
-        else if (data.type === MESSAGES.STDOUT) {
-            this.notifyLogListeners("stdout", data.value);
-        }
-        else if (data.type === MESSAGES.STDERR) {
-            this.notifyLogListeners("stderr", data.value);
-        }
-        else if (data.type === MESSAGES.CALL) {
-            this.onCall(data.value);
-        }
-        else if (data.type === MESSAGES.CALL_ACK) {
-            this.onCallAck(data.value);
-        }
-        else if (data.type === MESSAGES.HEARTBEAT) {
-            this.onHeartbeat();
-        }
-        else if (data.type === MESSAGES.RELOAD) {
-            this.reloadIframe();
-        }
-        else {
-            throwError({ t: "assert" });
-        }
-    }
-    onCallAck({ requestId }) {
-        this.assertStatus(["ready"]);
-        this.trace("Main: onCallAck: ", { requestId });
-        const callData = this.calls.get(requestId);
-        if (callData === undefined)
-            throwError({ t: "bad_ack" });
-        this.calls.set(requestId, { ...callData, acknowledged: true });
-    }
-    onCall({ requestId, error, data, }) {
-        this.assertStatus(["ready"]);
-        this.trace("Main: onCall: ", { requestId, error, data });
-        const callData = this.calls.get(requestId);
-        if (callData === undefined)
-            throwError({ t: "bad_call" });
-        if (!callData.acknowledged)
-            throwError({ t: "no_acked_call" });
-        this.calls.delete(requestId);
-        const durationMs = performance.now() - callData.startTimeMs;
-        if (error !== undefined) {
-            callData.resolve({ ok: false, error, durationMs });
-        }
-        else {
-            callData.resolve({ ok: true, data, durationMs });
-        }
-    }
-    onHeartbeat() {
-        if (this.heartbeatTimeout) {
-            clearTimeout(this.heartbeatTimeout);
-        }
-        this.heartbeatTimeout = setTimeout(() => {
-            this.trace("Main: heartbeat lost");
-            this.reloadIframe("heartbeat_lost");
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        }, this.heartbeatTimeoutMs);
-    }
-    reloadIframe(reason = "other") {
-        if (this.bridge === null) {
-            throwError({ t: "unmounted" });
-        }
-        if (document.hidden) {
-            this.trace("Main: reloading iframe skipped, window not visible");
-            return;
-        }
-        this.reloadN++;
-        if (this.reloadN > MAX_RELOAD_N) {
-            this.trace("Main: exceeded max reload number");
-            return;
-        }
-        this.trace("Main: reloading iframe");
-        this.transition({ status: "reload" });
-        this.teardownBridge("reload");
-        this.onReloadCallback(reason);
-        this.mount();
-    }
-    trace(...messages) {
-        if (this.debug) {
-            console.debug(...messages);
-        }
-    }
-    transition(to) {
-        this.trace(`State: ${this.state.status} -> ${to.status}`);
-        this.state = to;
-    }
-    assertStatus(validStatuses) {
-        const currentStatus = this.state.status;
-        if (!validStatuses.includes(currentStatus)) {
-            throwError({
-                t: "bad_status",
-                status: currentStatus,
-                expectedStatus: validStatuses.join(" | "),
-            });
-        }
-    }
-}
-async function withTimeout(promise, ms) {
-    let timeout = null;
-    const timeoutPromise = new Promise((resolve) => {
-        timeout = setTimeout(() => {
-            resolve({
-                ok: false,
-                error: new PopcornError("timeout"),
-                durationMs: ms,
-            });
-        }, ms);
-    });
-    const result = await Promise.race([promise, timeoutPromise]);
-    if (!timeout)
-        throwError({ t: "assert" });
-    clearTimeout(timeout);
-    return result;
-}
-function noop() {
-    /* noop */
-}
-async function resolveBundleURL(primary, fallback) {
-    const fetchBundle = async (path) => {
-        const url = new URL(path, import.meta.url).href;
-        const response = await fetch(url, { method: "HEAD" });
-        const contentType = response.headers.get("Content-Type") ?? "";
-        if (!response.ok || contentType.includes("text/html")) {
-            throw new Error(`Bundle not found at "${path}"`);
-        }
-        return path;
-    };
-    try {
-        return await Promise.any([fetchBundle(primary), fetchBundle(fallback)]);
-    }
-    catch {
-        throwError({ t: "bundle_not_found", primary, fallback });
-    }
-}
-
-export { Popcorn, PopcornError };

package/dist/types.mjs

@@ -1,25 +0,0 @@
-const INIT_VM_TIMEOUT_MS = 30_000;
-const CALL_TIMEOUT_MS = 60_000;
-const HEARTBEAT_TIMEOUT_MS = 60_000;
-const MAX_RELOAD_N = 3;
-const MESSAGES = {
-    EVENT: "popcorn-event",
-    CALL: "popcorn-call",
-    CAST: "popcorn-cast",
-    CALL_ACK: "popcorn-callAck",
-    STDOUT: "popcorn-stdout",
-    STDERR: "popcorn-stderr",
-    HEARTBEAT: "popcorn-heartbeat",
-    RELOAD: "popcorn-reload",
-};
-const EVENT_NAMES = {
-    ELIXIR_READY: "popcorn_elixir_ready",
-    APP_READY: "popcorn_app_ready",
-    SET_DEFAULT_RECEIVER: "popcorn_set_default_receiver",
-};
-const MESSAGES_TYPES = new Set(Object.values(MESSAGES));
-function isMessageType(type) {
-    return MESSAGES_TYPES.has(type);
-}
-
-export { CALL_TIMEOUT_MS, EVENT_NAMES, HEARTBEAT_TIMEOUT_MS, INIT_VM_TIMEOUT_MS, MAX_RELOAD_N, MESSAGES, isMessageType };