vike 0.4.236-commit-e752d12 → 0.4.236-commit-79f1ef0

package/dist/cjs/utils/getViteRPC.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getViteRPC = getViteRPC;
+exports.createViteRPC = createViteRPC;
+const assert_js_1 = require("./assert.js");
+const genPromise_js_1 = require("./genPromise.js");
+const getRandomId_js_1 = require("./getRandomId.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const debug_js_1 = require("./debug.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/getViteRPC.ts', {
+    rpc: null,
+});
+const debug = (0, debug_js_1.createDebugger)('vike:vite-rpc');
+function getViteRPC() {
+    globalObject.rpc ?? (globalObject.rpc = createRpcClient());
+    return globalObject.rpc;
+}
+function createRpcClient() {
+    // @ts-ignore CJS build doesn't support import.meta — TO-DO/eventually: let's remove this ts-ignore after we removed the CJS build
+    const hot = (undefined);
+    (0, assert_js_1.assert)(hot);
+    const listeners = [];
+    hot.on(`vike:rpc:response`, (dataResponse) => {
+        if (debug.isActivated)
+            debug('Response received', dataResponse);
+        const { callId, functionReturn } = dataResponse;
+        listeners.forEach((l) => {
+            if (callId !== l.callId)
+                return;
+            l.cb(functionReturn);
+            listeners.splice(listeners.indexOf(l), 1);
+        });
+    });
+    const rpc = new Proxy({}, {
+        get(_, functionName) {
+            return async (...functionArgs) => {
+                // @ts-ignore CJS build doesn't support import.meta — TO-DO/eventually: let's remove this ts-ignore after we removed the CJS build
+                const hot = (undefined);
+                (0, assert_js_1.assert)(hot);
+                const callId = (0, getRandomId_js_1.getRandomId)();
+                const { promise, resolve } = (0, genPromise_js_1.genPromise)({ timeout: 3 * 1000 });
+                listeners.push({
+                    callId,
+                    cb: (functionReturn) => {
+                        resolve(functionReturn);
+                    },
+                });
+                const dataRequest = { callId, functionName, functionArgs };
+                if (debug.isActivated)
+                    debug('Request sent', dataRequest);
+                // Vite's type is wrong: (undefined).send() does seem to return a promise
+                await hot.send('vike:rpc:request', dataRequest);
+                const functionReturn = await promise;
+                return functionReturn;
+            };
+        },
+    });
+    return rpc;
+}
+function createViteRPC(viteDevServer, getRpcFunctions) {
+    const rpcFunctions = getRpcFunctions(viteDevServer);
+    const { environments } = viteDevServer;
+    for (const envName in environments) {
+        debug('Listening to environment', envName);
+        const env = environments[envName];
+        env.hot.on('vike:rpc:request', async (dataRequest) => {
+            if (debug.isActivated)
+                debug('Request received', dataRequest);
+            const { callId, functionName, functionArgs } = dataRequest;
+            const functionReturn = await rpcFunctions[functionName](...functionArgs);
+            const dataResponse = { callId, functionReturn };
+            if (debug.isActivated)
+                debug('Response sent', dataResponse);
+            env.hot.send('vike:rpc:response', dataResponse);
+        });
+    }
+}

package/dist/cjs/utils/isFilePathAbsoluteFilesystem.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertFilePathAbsoluteFilesystem = assertFilePathAbsoluteFilesystem;
+exports.isFilePathAbsoluteFilesystem = isFilePathAbsoluteFilesystem;
 exports.isFilePathAbsolute = isFilePathAbsolute;
 const node_path_1 = __importDefault(require("node:path"));
 const assert_js_1 = require("./assert.js");

package/dist/cjs/utils/isRunnableDevEnvironment.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRunnableDevEnvironment = isRunnableDevEnvironment;
+// We use this instead of `import { isRunnableDevEnvironment } from 'vite'` because:
+// - Vite's isRunnableDevEnvironment() isn't reliable in monorepos where multiple Vite instances can be used simultaneously (it uses `instanceof RunnableDevEnvironment` which fails)
+// - We can use this in Vike's server production runtime without having to load the 'vite' package
+function isRunnableDevEnvironment(environment) {
+    return !!environment && 'runner' in environment && !!environment.runner;
+}

package/dist/cjs/utils/virtualFileId.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVirtualFileId = isVirtualFileId;
+exports.addVirtualFileIdPrefix = addVirtualFileIdPrefix;
+exports.removeVirtualFileIdPrefix = removeVirtualFileIdPrefix;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const idBase = 'virtual:vike:';
+// https://vitejs.dev/guide/api-plugin.html#virtual-modules-convention
+const prefix = '\0';
+function isVirtualFileId(id) {
+    if (id.startsWith(idBase))
+        return true;
+    if (id.startsWith(prefix + idBase))
+        return true;
+    // https://github.com/vikejs/vike/issues/1985
+    (0, assert_js_1.assertUsage)(!id.includes(idBase), `Encountered a module ID ${picocolors_1.default.cyan(id)} that is unexpected. Are you using a tool that modifies the ID of modules? For example, the baseUrl setting in tsconfig.json cannot be used.`);
+    return false;
+}
+function addVirtualFileIdPrefix(id) {
+    (0, assert_js_1.assert)(isVirtualFileId(id));
+    if (!id.startsWith(prefix)) {
+        id = prefix + id;
+    }
+    (0, assert_js_1.assert)(id.startsWith(prefix));
+    return id;
+}
+function removeVirtualFileIdPrefix(id) {
+    if (id.startsWith(prefix)) {
+        id = id.slice(prefix.length);
+    }
+    (0, assert_js_1.assert)(!id.startsWith(prefix));
+    return id;
+}

package/dist/esm/client/runtime-client-routing/createPageContextClientSide.d.ts

@@ -30,7 +30,7 @@ declare function createPageContextClientSide(urlOriginal: string): Promise<{
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts

@@ -50,7 +50,7 @@ declare function getPageContextFromHooks_isHydration(pageContext: PageContextSer
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;
@@ -264,7 +264,7 @@ declare function getPageContextFromClientHooks(pageContext: {
     } & {
         _pageRoutes: import("../../__internal/index.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;

package/dist/esm/client/runtime-client-routing/globalContext.d.ts

@@ -27,4 +27,4 @@ declare const getGlobalContextClientInternal: () => Promise<{
 } & {
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
     _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-}>;
+} & Record<string, any>>;

package/dist/esm/client/runtime-client-routing/history.d.ts

@@ -2,7 +2,8 @@ export { pushHistoryState };
 export { replaceHistoryStateOriginal };
 export { onPopStateBegin };
 export { saveScrollPosition };
-export { initHistory };
+export { initHistoryState };
+export { monkeyPatchHistoryAPI };
 export type { HistoryInfo };
 export type { ScrollPosition };
 type StateEnhanced = {
@@ -18,6 +19,7 @@ type ScrollPosition = {
 declare function saveScrollPosition(): void;
 declare function pushHistoryState(url: string, overwriteLastHistoryEntry: boolean): void;
 declare function replaceHistoryStateOriginal(state: unknown, url: string): void;
+declare function monkeyPatchHistoryAPI(): void;
 type HistoryInfo = {
     url: `/${string}`;
     state: StateEnhanced;
@@ -27,4 +29,4 @@ declare function onPopStateBegin(): {
     previous: HistoryInfo;
     current: HistoryInfo;
 };
-declare function initHistory(): void;
+declare function initHistoryState(): void;

package/dist/esm/client/runtime-client-routing/history.js

@@ -2,15 +2,12 @@ export { pushHistoryState };
 export { replaceHistoryStateOriginal };
 export { onPopStateBegin };
 export { saveScrollPosition };
-export { initHistory };
+export { initHistoryState };
+export { monkeyPatchHistoryAPI };
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { assert, assertUsage, getGlobalObject, isObject } from './utils.js';
-const globalObject = getGlobalObject('history.ts', {
-    monkeyPatched: false,
-    previous: undefined,
-});
-initHistory(); // we redundantly call initHistory() to ensure it's called early
-globalObject.previous = getHistoryInfo();
+initHistoryState(); // we redundantly call initHistoryState() to ensure it's called early
+const globalObject = getGlobalObject('runtime-client-routing/history.ts', { previous: getHistoryInfo() });
 // `window.history.state === null` when:
 // - The very first render
 // - Click on `<a href="#some-hash" />`
@@ -44,7 +41,7 @@ function enhance(stateNotEnhanced) {
             _isVikeEnhanced: true,
         };
     }
-    assertIsVikeEnhanced(stateVikeEnhanced);
+    assert(isVikeEnhanced(stateVikeEnhanced));
     return stateVikeEnhanced;
 }
 function getState() {
@@ -54,7 +51,7 @@ function getState() {
     // - Therefore, we have to monkey patch history.pushState() and history.replaceState()
     // - Therefore, we need the assert() below to ensure history.state has been enhanced by Vike
     //   - If users stumble upon this assert() then let's make it a assertUsage()
-    assertIsVikeEnhanced(state);
+    assert(isVikeEnhanced(state), { state });
     return state;
 }
 function getStateNotEnhanced() {
@@ -93,7 +90,6 @@ function pushHistoryState(url, overwriteLastHistoryEntry) {
 function replaceHistoryState(state, url) {
     const url_ = url ?? null; // Passing `undefined` chokes older Edge versions.
     window.history.replaceState(state, '', url_);
-    assertIsVikeEnhanced(getState());
 }
 function replaceHistoryStateOriginal(state, url) {
     // Bypass all monkey patches.
@@ -104,11 +100,7 @@ function replaceHistoryStateOriginal(state, url) {
 // - history.pushState()
 // - history.replaceState()
 function monkeyPatchHistoryAPI() {
-    if (globalObject.monkeyPatched)
-        return;
-    globalObject.monkeyPatched = true;
-    // Ensure Vike's monkey patch is the first.
-    assert(window.history.pushState === History.prototype.pushState);
+    ;
     ['pushState', 'replaceState'].forEach((funcName) => {
         const funcOriginal = window.history[funcName].bind(window.history);
         window.history[funcName] = (stateOriginal = {}, ...rest) => {
@@ -122,14 +114,11 @@ function monkeyPatchHistoryAPI() {
                     triggeredBy: 'user',
                     ...stateOriginal,
                 };
-            assertIsVikeEnhanced(stateEnhanced);
-            funcOriginal(stateEnhanced, ...rest);
-            assertIsVikeEnhanced(getState());
+            assert(isVikeEnhanced(stateEnhanced));
+            const ret = funcOriginal(stateEnhanced, ...rest);
             globalObject.previous = getHistoryInfo();
+            return ret;
         };
-        window.history[funcName]._isVikeMonkeyPatch = true;
-        // Ensure assert() above isn't a false positive
-        assert(window.history.pushState !== History.prototype.pushState);
     });
 }
 function isVikeEnhanced(state) {
@@ -147,16 +136,6 @@ function isVikeEnhanced(state) {
     }
     return false;
 }
-function assertIsVikeEnhanced(state) {
-    if (isVikeEnhanced(state))
-        return;
-    assert(false, {
-        state,
-        // TO-DO/eventually: remove _isVikeMonkeyPatch debug info to save KBs
-        pushStateIsVikeMonkeyPatch: window.history.pushState._isVikeMonkeyPatch,
-        replaceStateIsVikeMonkeyPatch: window.history.replaceState._isVikeMonkeyPatch,
-    });
-}
 function getHistoryInfo() {
     return {
         url: getCurrentUrl(),
@@ -168,12 +147,11 @@ function onPopStateBegin() {
     const isHistoryStateEnhanced = window.history.state !== null;
     if (!isHistoryStateEnhanced)
         enhanceHistoryState();
-    assertIsVikeEnhanced(window.history.state);
+    assert(isVikeEnhanced(window.history.state));
     const current = getHistoryInfo();
     globalObject.previous = current;
     return { isHistoryStateEnhanced, previous, current };
 }
-function initHistory() {
-    monkeyPatchHistoryAPI(); // the earlier we call it the better (Vike can workaround erroneous library monkey patches if Vike is the last one in the monkey patch chain)
-    enhanceHistoryState(); // enhance very first window.history.state which is `null`
+function initHistoryState() {
+    enhanceHistoryState();
 }

package/dist/esm/client/runtime-client-routing/initClientRouter.js

@@ -6,7 +6,7 @@ import { initOnLinkClick } from './initOnLinkClick.js';
 import { scrollRestoration_init } from './scrollRestoration.js';
 import { autoSaveScrollPosition } from './setScrollPosition.js';
 import { initLinkPrefetchHandlers } from './prefetch.js';
-import { initHistory } from './history.js';
+import { initHistoryState, monkeyPatchHistoryAPI } from './history.js';
 async function initClientRouter() {
     // Init navigation history and scroll restoration
     initHistoryAndScroll();
@@ -29,7 +29,8 @@ async function renderFirstPage() {
 }
 function initHistoryAndScroll() {
     scrollRestoration_init();
-    initHistory(); // we redundantly call initHistory() to ensure it's called early
+    monkeyPatchHistoryAPI();
+    initHistoryState(); // we redundantly call initHistoryState() to ensure it's called early
     autoSaveScrollPosition();
     // Handle back-/forward navigation
     initOnPopState();

package/dist/esm/client/runtime-client-routing/renderPageClientSide.d.ts

@@ -63,7 +63,7 @@ declare function getPageContextBegin(isForErrorPage: boolean, { urlOriginal, isB
     } & {
         _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
         _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    };
+    } & Record<string, any>;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _urlHandler: null;
     _urlRewrite: null | string;

package/dist/esm/client/runtime-client-routing/renderPageClientSide.js

@@ -84,7 +84,7 @@ async function renderPageClientSide(renderArgs) {
                     return;
             }
         }
-        // Route
+        // Get pageContext serialized in <script id="vike_pageContext" type="application/json">
         if (isFirstRender) {
             const pageContextSerialized = getPageContextFromHooks_serialized();
             // TO-DO/eventually: create helper assertPageContextFromHook()
@@ -93,7 +93,9 @@ async function renderPageClientSide(renderArgs) {
             // TO-DO/pageContext-prefetch: remove or change, because this only makes sense for a pre-rendered page
             populatePageContextPrefetchCache(pageContext, { pageContextFromServerHooks: pageContextSerialized });
         }
-        else {
+        // Route
+        // - We must also run it upon hydration to call the onBeforeRoute() hook, which is needed for i18n URL locale extraction.
+        {
             let pageContextFromRoute;
             try {
                 pageContextFromRoute = await route(pageContext);
@@ -104,38 +106,49 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            if (!pageContextFromRoute.pageId) {
-                /*
-                // We don't use the client router to render the 404 page:
-                //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
-                //    - This is the main argument.
-                //    - See also failed CI: https://github.com/vikejs/vike/pull/1871
-                //  - So that server-side error tracking can track 404 links?
-                //    - We do use the client router for rendering the error page, so I don't think this is much of an argument.
-                await renderErrorPage({ is404: true })
-                */
-                redirectHard(urlOriginal);
-                return;
+            // TO-DO/eventually: create helper assertPageContextFromHook()
+            assert(!('urlOriginal' in pageContextFromRoute));
+            if (isFirstRender) {
+                // Set pageContext properties set by onBeforeRoute()
+                // - But we skip pageId and routeParams because routing may have been aborted by a server-side `throw render()`
+                const { pageId, routeParams, ...pageContextFromRouteRest } = pageContextFromRoute;
+                objectAssign(pageContext, pageContextFromRouteRest);
+                assert(hasProp(pageContext, 'routeParams', 'string{}')); // Help TS
             }
-            assert(hasProp(pageContextFromRoute, 'pageId', 'string')); // Help TS
-            const isClientRoutable = await isClientSideRoutable(pageContextFromRoute.pageId, pageContext);
-            if (isRenderOutdated())
-                return;
-            if (!isClientRoutable) {
-                redirectHard(urlOriginal);
-                return;
+            else {
+                objectAssign(pageContext, pageContextFromRoute);
             }
-            const isSamePage = pageContextFromRoute.pageId &&
-                previousPageContext?.pageId &&
-                pageContextFromRoute.pageId === previousPageContext.pageId;
-            if (doNotRenderIfSamePage && isSamePage) {
-                // Skip's Vike's rendering; let the user handle the navigation
-                return;
+            if (!isFirstRender) {
+                if (!pageContextFromRoute.pageId) {
+                    /*
+                    // We don't use the client router to render the 404 page:
+                    //  - So that the +redirects setting (https://vike.dev/redirects) can be applied.
+                    //    - This is the main argument.
+                    //    - See also failed CI: https://github.com/vikejs/vike/pull/1871
+                    //  - So that server-side error tracking can track 404 links?
+                    //    - We do use the client router for rendering the error page, so I don't think this is much of an argument.
+                    await renderErrorPage({ is404: true })
+                    */
+                    redirectHard(urlOriginal);
+                    return;
+                }
+                const isClientRoutable = await isClientSideRoutable(pageContextFromRoute.pageId, pageContext);
+                if (isRenderOutdated())
+                    return;
+                if (!isClientRoutable) {
+                    redirectHard(urlOriginal);
+                    return;
+                }
+                const isSamePage = pageContextFromRoute.pageId &&
+                    previousPageContext?.pageId &&
+                    pageContextFromRoute.pageId === previousPageContext.pageId;
+                if (doNotRenderIfSamePage && isSamePage) {
+                    // Skip's Vike's rendering; let the user handle the navigation
+                    return;
+                }
             }
-            // TO-DO/eventually: create helper assertPageContextFromHook()
-            assert(!('urlOriginal' in pageContextFromRoute));
-            objectAssign(pageContext, pageContextFromRoute);
         }
+        assert(hasProp(pageContext, 'pageId', 'string')); // Help TS
         const res = await loadPageConfigsLazyClientSideAndExecHook(pageContext, isFirstRender, isRenderOutdated);
         /* Already called inside loadPageConfigsLazyClientSideAndExecHook()
         if (isRenderOutdated()) return

package/dist/esm/client/runtime-server-routing/createPageContextClientSide.d.ts

@@ -26,7 +26,7 @@ declare function createPageContextClientSide(): Promise<{
         };
     } & {
         isClientSide: true;
-    } & object;
+    } & object & Record<string, any>;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;

package/dist/esm/client/runtime-server-routing/globalContext.d.ts

@@ -24,4 +24,4 @@ declare const getGlobalContextClientInternal: () => Promise<{
     };
 } & {
     isClientSide: true;
-} & object>;
+} & object & Record<string, any>>;

package/dist/esm/client/shared/createGetGlobalContextClient.d.ts

@@ -30,7 +30,7 @@ declare function createGetGlobalContextClient<GlobalContextAddendum extends obje
      * We recommend using `import.meta.env.SSR` instead, see https://vike.dev/globalContext
      */
     isClientSide: true;
-} & Awaited<GlobalContextAddendum>>;
+} & Awaited<GlobalContextAddendum> & Record<string, any>>;
 type NeverExported = never;
 declare function getGlobalContext(): Promise<NeverExported>;
 declare function getGlobalContextSync(): NeverExported;

package/dist/esm/client/shared/createGetGlobalContextClient.js

@@ -5,12 +5,12 @@ export { getGlobalContextSync };
 export { createGetGlobalContextClient };
 import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
 import { getGlobalContextSerializedInHtml } from './getJsonSerializedInHtml.js';
-import { assert, assertUsage, genPromise, getGlobalObject, objectAssign } from './utils.js';
+import { assert, assertUsage, genPromise, getGlobalObject, objectAssign, checkType } from './utils.js';
 const globalObject = getGlobalObject('createGetGlobalContextClient.ts', (() => {
-    const { promise: globalContextPromise, resolve: globalContextPromiseResolve } = genPromise();
+    const { promise: globalContextInitialPromise, resolve: globalContextInitialPromiseResolve } = genPromise();
     return {
-        globalContextPromise,
-        globalContextPromiseResolve,
+        globalContextInitialPromise,
+        globalContextInitialPromiseResolve,
     };
 })());
 function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGlobalContext) {
@@ -21,13 +21,17 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
     return getGlobalContext;
     async function getGlobalContext() {
         // Cache
-        if (globalObject.globalContext &&
+        if (globalObject.virtualFileExports &&
             // Don't break HMR
-            globalObject.globalContext._virtualFileExports !== virtualFileExports) {
-            return globalObject.globalContext;
+            globalObject.virtualFileExports === virtualFileExports) {
+            const globalContext = await globalObject.globalContextPromise;
+            return globalContext;
+        }
+        else {
+            globalObject.virtualFileExports = virtualFileExports;
         }
         // Create
-        const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, undefined, async (globalContext) => {
+        const globalContextPromise = createGlobalContextShared(virtualFileExports, globalObject, undefined, async (globalContext) => {
             const globalContextAddendum = {
                 /**
                  * Whether the environment is client-side or server-side / pre-rendering.
@@ -40,18 +44,24 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
             objectAssign(globalContextAddendum, await addGlobalContext?.(globalContext));
             return globalContextAddendum;
         });
-        assert(globalObject.globalContext);
-        globalObject.globalContextPromiseResolve(globalObject.globalContext);
+        globalObject.globalContextPromise = globalContextPromise;
+        const globalContext = await globalContextPromise;
+        assert(globalObject.globalContext === globalContext);
+        globalObject.globalContextInitialPromiseResolve();
         // Return
         return globalContext;
     }
 }
 async function getGlobalContext() {
+    await globalObject.globalContextInitialPromise;
     const globalContext = await globalObject.globalContextPromise;
+    assert(globalContext);
+    checkType(globalContext);
     return globalContext;
 }
 function getGlobalContextSync() {
     const { globalContext } = globalObject;
     assertUsage(globalContext, getGlobalContextSyncErrMsg);
+    checkType(globalContext);
     return globalContext;
 }

package/dist/esm/client/shared/utils.d.ts

@@ -4,3 +4,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/checkType.js';

package/dist/esm/client/shared/utils.js

@@ -4,3 +4,4 @@ export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/checkType.js';