rwsdk/dist/use-synced-state/shim/worker.mjs

Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime

import { runWithRequestInfo } from "../../runtime/requestInfo/worker";
import { SyncedStateServer as HibernationSyncedStateServer, } from "../hibernation/worker.mjs";
export { SyncedStateServer } from "../hibernation/worker.mjs";
export { syncedStateRoutes } from "../hibernation/worker.mjs";
// Backwards-compatible wrapper that preserves the capnweb-style handler API.
//
// The hibernation transport captures requestInfo.ctx at WebSocket upgrade time
// and stores it on the socket attachment. When a legacy handler is invoked,
// we reconstruct a RequestInfo with that captured ctx and run the handler
// inside runWithRequestInfo so existing code can keep reading requestInfo.ctx.
const originalRegisterKeyHandler = HibernationSyncedStateServer.registerKeyHandler.bind(HibernationSyncedStateServer);
const originalRegisterSetStateHandler = HibernationSyncedStateServer.registerSetStateHandler.bind(HibernationSyncedStateServer);
const originalRegisterGetStateHandler = HibernationSyncedStateServer.registerGetStateHandler.bind(HibernationSyncedStateServer);
const originalRegisterSubscribeHandler = HibernationSyncedStateServer.registerSubscribeHandler.bind(HibernationSyncedStateServer);
const originalRegisterUnsubscribeHandler = HibernationSyncedStateServer.registerUnsubscribeHandler.bind(HibernationSyncedStateServer);
function makeLegacyRequestInfo(identity) {
    return {
        request: new Request("http://internal/use-synced-state"),
        path: "/use-synced-state",
        params: {},
        ctx: identity,
        url: new URL("http://internal/use-synced-state"),
        rw: {
            nonce: "",
            Document: () => null,
            rscPayload: false,
            ssr: false,
            databases: new Map(),
            scriptsToBeLoaded: new Set(),
            entryScripts: new Set(),
            inlineScripts: new Set(),
            pageRouteResolved: Promise.withResolvers(),
        },
        cf: {
            waitUntil: () => { },
            passThroughOnException: () => { },
        },
        response: { headers: new Headers() },
        isAction: false,
    };
}
function callWithLegacyContext(identity, fn) {
    const requestInfo = makeLegacyRequestInfo(identity);
    return runWithRequestInfo(requestInfo, fn);
}
function isLegacyKeyHandler(handler) {
    return handler.length === 2;
}
function isLegacySetGetHandler(handler) {
    return handler.length === 3;
}
function isLegacySubscribeUnsubscribeHandler(handler) {
    return handler.length === 2;
}
HibernationSyncedStateServer.registerKeyHandler = (handler) => {
    if (!handler) {
        originalRegisterKeyHandler(null);
        return;
    }
    if (isLegacyKeyHandler(handler)) {
        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
        }
        originalRegisterKeyHandler(async (key, identity, stub) => {
            return await callWithLegacyContext(identity, () => handler(key, stub));
        });
    }
    else {
        originalRegisterKeyHandler(handler);
    }
};
HibernationSyncedStateServer.registerSetStateHandler = (handler) => {
    if (!handler) {
        originalRegisterSetStateHandler(null);
        return;
    }
    if (isLegacySetGetHandler(handler)) {
        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
        }
        originalRegisterSetStateHandler((key, value, identity, stub) => {
            callWithLegacyContext(identity, () => handler(key, value, stub));
        });
    }
    else {
        originalRegisterSetStateHandler(handler);
    }
};
HibernationSyncedStateServer.registerGetStateHandler = (handler) => {
    if (!handler) {
        originalRegisterGetStateHandler(null);
        return;
    }
    if (isLegacySetGetHandler(handler)) {
        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
        }
        originalRegisterGetStateHandler((key, value, identity, stub) => {
            callWithLegacyContext(identity, () => handler(key, value, stub));
        });
    }
    else {
        originalRegisterGetStateHandler(handler);
    }
};
HibernationSyncedStateServer.registerSubscribeHandler = (handler) => {
    if (!handler) {
        originalRegisterSubscribeHandler(null);
        return;
    }
    if (isLegacySubscribeUnsubscribeHandler(handler)) {
        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
        }
        originalRegisterSubscribeHandler((key, identity, stub) => {
            callWithLegacyContext(identity, () => handler(key, stub));
        });
    }
    else {
        originalRegisterSubscribeHandler(handler);
    }
};
HibernationSyncedStateServer.registerUnsubscribeHandler = (handler) => {
    if (!handler) {
        originalRegisterUnsubscribeHandler(null);
        return;
    }
    if (isLegacySubscribeUnsubscribeHandler(handler)) {
        if (!HibernationSyncedStateServer.getIdentityExtractor()) {
            HibernationSyncedStateServer.registerIdentityExtractor((requestInfo) => requestInfo.ctx);
        }
        originalRegisterUnsubscribeHandler((key, identity, stub) => {
            callWithLegacyContext(identity, () => handler(key, stub));
        });
    }
    else {
        originalRegisterUnsubscribeHandler(handler);
    }
};