vike 0.4.229 → 0.4.230-commit-dd11364

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -10,12 +10,12 @@ const renderHtml_js_1 = require("../html/renderHtml.js");
 const utils_js_1 = require("../utils.js");
 const serializeContext_js_1 = require("../html/serializeContext.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
-const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
+const loadPageConfigsLazyServerSide_js_1 = require("./loadPageConfigsLazyServerSide.js");
 const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
 const executeOnBeforeRenderAndDataHooks_js_1 = require("./executeOnBeforeRenderAndDataHooks.js");
 const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const isNewError_js_1 = require("./isNewError.js");
-const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
@@ -26,9 +26,9 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'pageId', 'string'));
     const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
     (0, utils_js_1.assert)(isError === (pageContext.pageId === (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs)));
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     if (!isError) {
-        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext));
+        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }
     if (!isError) {
         await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
@@ -65,7 +65,7 @@ async function prerenderPage(pageContext) {
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
-    await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext))
+    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
     await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
     const { htmlRender, renderHook } = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);

package/dist/cjs/node/runtime/renderPage/resolveRedirects.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redirectsErrPrefix = void 0;
 exports.resolveRedirects = resolveRedirects;
 exports.resolveRouteStringRedirect = resolveRouteStringRedirect;
 const assertIsNotBrowser_js_1 = require("../../../utils/assertIsNotBrowser.js");
@@ -13,7 +12,6 @@ const resolveRouteString_js_1 = require("../../../shared/route/resolveRouteStrin
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
 const redirectsErrPrefix = '[+redirects]';
-exports.redirectsErrPrefix = redirectsErrPrefix;
 function resolveRedirects(redirectsAll, urlPathname) {
     const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {

package/dist/cjs/node/runtime/renderPage.js

@@ -22,7 +22,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const serializeContext_js_1 = require("./html/serializeContext.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
-const loadUserFilesServerSide_js_1 = require("./renderPage/loadUserFilesServerSide.js");
+const loadPageConfigsLazyServerSide_js_1 = require("./renderPage/loadPageConfigsLazyServerSide.js");
 const resolveRedirects_js_1 = require("./renderPage/resolveRedirects.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
     httpRequestsCount: 0
@@ -33,9 +33,9 @@ async function renderPage(pageContextInit) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string')); // assertUsage() already implemented at assertArguments()
     assertIsUrl(pageContextInit.urlOriginal);
     (0, utils_js_1.onSetupRuntime)();
-    const pageContextInvalidRequest = getPageContextInvalidRequest(pageContextInit);
-    if (pageContextInvalidRequest)
-        return pageContextInvalidRequest;
+    const pageContextSkipRequest = getPageContextSkipRequest(pageContextInit);
+    if (pageContextSkipRequest)
+        return pageContextSkipRequest;
     const httpRequestId = getRequestId();
     const urlOriginalPretty = (0, utils_js_1.getUrlPretty)(pageContextInit.urlOriginal);
     logHttpRequest(urlOriginalPretty, httpRequestId);
@@ -81,8 +81,8 @@ async function renderPagePrepare(pageContextInit, httpRequestId) {
     else {
         // `globalContext` now contains the entire Vike config and getVikeConfig() isn't called anymore for this request.
     }
-    const { globalContext, globalContext_public } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
-    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId);
+    const { globalContext } = await (0, globalContext_js_1.getGlobalContextServerInternal)();
+    const pageContextBegin = await getPageContextBegin(pageContextInit, globalContext, httpRequestId);
     // Check Base URL
     {
         const pageContextHttpResponse = await checkBaseUrl(pageContextBegin, globalContext);
@@ -304,9 +304,9 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     (0, utils_js_1.assert)(pageContext.errorWhileRendering);
     return pageContext;
 }
-async function getPageContextBegin(pageContextInit, globalContext, globalContext_public, httpRequestId) {
+async function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, globalContext_public, {
+    const pageContextBegin = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
             urlHandler: _urlHandler,
@@ -415,7 +415,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
-            (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
+            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }
@@ -459,13 +459,22 @@ async function checkBaseUrl(pageContextBegin, globalContext) {
     (0, utils_js_1.checkType)(pageContext);
     return pageContext;
 }
-function getPageContextInvalidRequest(pageContextInit) {
+function getPageContextSkipRequest(pageContextInit) {
     const urlPathnameWithBase = (0, utils_js_1.parseUrl)(pageContextInit.urlOriginal, '/').pathname;
     assertIsNotViteRequest(urlPathnameWithBase, pageContextInit.urlOriginal);
-    if (!urlPathnameWithBase.endsWith('/favicon.ico'))
+    let errMsg404;
+    if (urlPathnameWithBase.endsWith('/favicon.ico')) {
+        errMsg404 = 'No favicon.ico found';
+    }
+    if (urlPathnameWithBase.endsWith('.well-known/appspecific/com.chrome.devtools.json')) {
+        // https://chromium.googlesource.com/devtools/devtools-frontend/+/main/docs/ecosystem/automatic_workspace_folders.md
+        // https://www.reddit.com/r/node/comments/1kcr0wh/odd_request_coming_into_my_localhost_server_from/
+        errMsg404 = 'Not spported';
+    }
+    if (!errMsg404)
         return;
     const pageContext = (0, createPageContextServerSide_js_1.createPageContextServerSideWithoutGlobalContext)(pageContextInit);
-    const httpResponse = (0, createHttpResponse_js_1.createHttpResponseFavicon404)();
+    const httpResponse = (0, createHttpResponse_js_1.createHttpResponse404)(errMsg404);
     (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
     (0, utils_js_1.checkType)(pageContext);
     return pageContext;

package/dist/cjs/node/runtime/utils.js

@@ -74,5 +74,5 @@ __exportStar(require("../../utils/isVikeReactApp.js"), exports);
 __exportStar(require("../../utils/getPropAccessNotation.js"), exports);
 __exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
 __exportStar(require("../../utils/genPromise.js"), exports);
-__exportStar(require("../../utils/getPublicProxy.js"), exports);
 __exportStar(require("../../utils/augmentType.js"), exports);
+__exportStar(require("../../utils/changeEnumerable.js"), exports);

package/dist/cjs/shared/NOT_SERIALIZABLE.js

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOT_SERIALIZABLE = void 0;
-// TODO: move to ../node/runtime/html/NOT_SERIALIZABLE.ts once code is distributed as ESM
 exports.NOT_SERIALIZABLE = '__VIKE__NOT_SERIALIZABLE__';

package/dist/cjs/shared/addIs404ToPageProps.js

@@ -2,16 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addIs404ToPageProps = addIs404ToPageProps;
 const utils_js_1 = require("./utils.js");
-const error_page_js_1 = require("./error-page.js");
 function addIs404ToPageProps(pageContext) {
-    assertIs404(pageContext);
     addIs404(pageContext);
 }
-function assertIs404(pageContext) {
-    if ((0, error_page_js_1.isErrorPage)(pageContext.pageId, pageContext._pageConfigs)) {
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, 'is404', 'boolean'));
-    }
-}
 function addIs404(pageContext) {
     if (pageContext.is404 === undefined || pageContext.is404 === null)
         return;

package/dist/cjs/shared/createGlobalContextShared.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalContextSyncErrMsg = void 0;
 exports.createGlobalContextShared = createGlobalContextShared;
+const utils_js_1 = require("./utils.js");
+const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
+const getUserFriendlyConfigs_js_1 = require("./page-configs/getUserFriendlyConfigs.js");
+const execHook_js_1 = require("./hooks/execHook.js");
+const prepareGlobalContextForPublicUsage_js_1 = require("./prepareGlobalContextForPublicUsage.js");
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 exports.getGlobalContextSyncErrMsg = getGlobalContextSyncErrMsg;
-const getPageConfigsRuntime_js_1 = require("./getPageConfigsRuntime.js");
-const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
-const utils_js_1 = require("./utils.js");
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     const globalContextAddendum = await addGlobalContext?.(globalContext);
@@ -24,17 +26,17 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         //      - globalContext._viteDevServer.hot.send()
         //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
         //        - Seems less idiomatic
-        await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+        await (0, execHook_js_1.execHookGlobal)('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage_js_1.prepareGlobalContextForPublicUsage);
     }
     else {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
         // We don't use objectReplace() in order to keep user-land properties.
-        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext);
+        (0, utils_js_1.objectAssign)(globalObject.globalContext, globalContext, true);
     }
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -42,13 +44,40 @@ function createGlobalContextBase(virtualFileExports) {
          * https://vike.dev/globalContext#typescript
          */
         isGlobalContext: true,
+        _isOriginalObject: true,
         _virtualFileExports: virtualFileExports,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        config: globalConfig.config,
-        pages: pageConfigsUserFriendly
+        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
+        config: userFriendlyConfigsGlobal.config,
+        pages: userFriendlyConfigsPageEager
     };
+    (0, utils_js_1.changeEnumerable)(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
+function getConfigsAll(virtualFileExports) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(virtualFileExports);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const userFriendlyConfigsGlobal = (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsGlobal)({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsPageEager)(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    }));
+    return {
+        pageFilesAll,
+        allPageIds,
+        pageConfigs,
+        pageConfigGlobal,
+        userFriendlyConfigsGlobal,
+        userFriendlyConfigsPageEager
+    };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = (0, utils_js_1.unique)(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/cjs/shared/createPageContextShared.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
-const executeHookGeneric_js_1 = require("./hooks/executeHookGeneric.js");
-const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
+exports.createPageContextObject = createPageContextObject;
+const execHook_js_1 = require("./hooks/execHook.js");
+const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
-async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
-    const pageConfigGlobalUserFriendly = (0, getPageConfigUserFriendly_js_1.getPageConfigGlobalUserFriendly)({
-        pageConfigGlobalValues: pageConfigGlobal.configValues
-    });
-    (0, utils_js_1.objectAssign)(pageContextCreated, {
-        isPageContext: true,
-        ...pageConfigGlobalUserFriendly
-    }, true);
-    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
+    (0, utils_js_1.objectAssign)(pageContextCreated, userFriendlyConfigsGlobal);
+    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
+function createPageContextObject() {
+    const pageContext = {
+        _isOriginalObject: true,
+        isPageContext: true
+    };
+    (0, utils_js_1.changeEnumerable)(pageContext, '_isOriginalObject', false);
+    return pageContext;
+}

package/dist/cjs/shared/getPageContext.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.providePageContext = exports.getPageContext = void 0;
-var executeHook_js_1 = require("./hooks/executeHook.js");
-Object.defineProperty(exports, "getPageContext", { enumerable: true, get: function () { return executeHook_js_1.getPageContext; } });
-Object.defineProperty(exports, "providePageContext", { enumerable: true, get: function () { return executeHook_js_1.providePageContext; } });
+var execHook_js_1 = require("./hooks/execHook.js");
+Object.defineProperty(exports, "getPageContext", { enumerable: true, get: function () { return execHook_js_1.getPageContext; } });
+Object.defineProperty(exports, "providePageContext", { enumerable: true, get: function () { return execHook_js_1.providePageContext; } });

package/dist/cjs/shared/getPageContextUrlComputed.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageContextUrlComputed = getPageContextUrlComputed;
-exports.assertPageContextUrl = assertPageContextUrl;
 // =====================
 // File determining the URL logic.
 // URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
 // =====================
 const objectDefineProperty_js_1 = require("../utils/objectDefineProperty.js");
+const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
 function getPageContextUrlComputed(pageContext) {
     (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
-    assertPageContextUrlComputed(pageContext);
+    (0, preparePageContextForPublicUsage_js_1.assertPropertyGetters)(pageContext);
     const pageContextUrlComputed = {};
     (0, objectDefineProperty_js_1.objectDefineProperty)(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
@@ -130,37 +130,3 @@ function urlParsedGetter() {
     }
     return urlParsedEnhanced;
 }
-function assertPageContextUrl(pageContext) {
-    (0, utils_js_1.assert)(typeof pageContext.urlOriginal === 'string');
-    (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
-    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.urlParsed));
-    (0, utils_js_1.assert)(pageContext.urlPathname === pageContext.urlParsed.pathname);
-    assertPageContextUrlComputed(pageContext);
-}
-function assertPageContextUrlComputed(pageContext) {
-    /*
-    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
-    ```js
-    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
-  
-    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
-    Object.assign(pageContext, pageContextUrlComputed)
-  
-    // ❌ Also breaks property descriptors/getters
-    const pageContext = { ...pageContextUrlComputed }
-  
-    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
-    objectAssign(pageContext, pageContextUrlComputed)
-    ```
-    */
-    if ('urlPathname' in pageContext) {
-        (0, utils_js_1.assert)(typeof pageContext.urlPathname === 'string');
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlPathname'));
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'urlParsed'));
-        (0, utils_js_1.assert)((0, utils_js_1.isPropertyGetter)(pageContext, 'url'));
-    }
-    else {
-        (0, utils_js_1.assert)(!('urlParsed' in pageContext));
-        (0, utils_js_1.assert)(!('url' in pageContext));
-    }
-}

package/dist/cjs/shared/getProxyForPublicUsage.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxyForPublicUsage = getProxyForPublicUsage;
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+// Show warning when user is accessing internal `_` properties.
+const NOT_SERIALIZABLE_js_1 = require("./NOT_SERIALIZABLE.js");
+const utils_js_1 = require("./utils.js");
+function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp, fallback)
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (prop === '_isProxyObject')
+            return true;
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        if (fallback && !(prop in obj)) {
+            // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
+            // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
+            return fallback(prop);
+        }
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function onNotSerializable(propStr, val, objName) {
+    if (val !== NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE)
+        return;
+    const propName = (0, utils_js_1.getPropAccessNotation)(propStr);
+    (0, utils_js_1.assert)((0, utils_js_1.isBrowser)());
+    (0, utils_js_1.assertUsage)(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
+}
+function onInternalProp(propStr, objName) {
+    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
+    //   - Where import.meta.CLIENT is defined by Vike
+    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
+    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
+    if ((0, utils_js_1.isBrowser)())
+        return;
+    // TODO/now remove this and only warn on built-in access instead
+    if (propStr === '_configFromHook')
+        return;
+    if (propStr.startsWith('_')) {
+        (0, utils_js_1.assertWarning)(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+    }
+}

package/dist/cjs/shared/hooks/execHook.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHook = execHook;
+exports.execHookSingle = execHookSingle;
+exports.execHookSingleWithReturn = execHookSingleWithReturn;
+exports.execHookErrorHandling = execHookErrorHandling;
+exports.execHooksErrorHandling = execHooksErrorHandling;
+exports.execHookWithoutPageContext = execHookWithoutPageContext;
+exports.execHookGlobal = execHookGlobal;
+exports.execHookSync = execHookSync;
+exports.getPageContext = getPageContext;
+exports.providePageContext = providePageContext;
+exports.isUserHookError = isUserHookError;
+const assert_js_1 = require("../../utils/assert.js");
+const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
+const humanizeTime_js_1 = require("../../utils/humanizeTime.js");
+const isObject_js_1 = require("../../utils/isObject.js");
+const getHook_js_1 = require("./getHook.js");
+const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/execHook.ts', {
+    userHookErrors: new WeakMap(),
+    pageContext: null
+});
+async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    (0, assert_js_1.assertUsage)(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    return { hookReturn };
+}
+async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    return res.hooks;
+}
+async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
+    const hooks = (0, getHook_js_1.getHookFromPageContextNew)(hookName, pageContext);
+    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
+}
+async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return { hooks: [] };
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    let hooksWithResult;
+    let err;
+    try {
+        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+            return { ...hook, hookReturn };
+        }));
+    }
+    catch (err_) {
+        err = err_;
+    }
+    if (hooksWithResult) {
+        return { hooks: hooksWithResult };
+    }
+    else {
+        return { hooks, err };
+    }
+}
+async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
+    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+    await Promise.all(hooks.map(async (hook) => {
+        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+    }));
+}
+function isUserHookError(err) {
+    if (!(0, isObject_js_1.isObject)(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+async function execHookWithoutPageContext(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout } = hook;
+    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    return hookReturn;
+}
+function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
+    };
+    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
+        setTimeout(() => {
+            (0, assert_js_1.assertWarning)(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${(0, humanizeTime_js_1.humanizeTime)(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
+        }, timeoutWarn);
+    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
+        setTimeout(() => {
+            const err = (0, assert_js_1.getProjectError)(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${(0, humanizeTime_js_1.humanizeTime)(timeoutErr)} (https://vike.dev/hooksTimeout)`);
+            reject(err);
+        }, timeoutErr);
+    (async () => {
+        try {
+            providePageContextInternal(pageContextForPublicUsage);
+            const ret = await hookFnCaller();
+            resolve(ret);
+        }
+        catch (err) {
+            if ((0, isObject_js_1.isObject)(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    providePageContextInternal(pageContextForPublicUsage);
+    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    return { hookReturn };
+}
+function isNotDisabled(timeout) {
+    return !!timeout && timeout !== Infinity;
+}
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    const { pageContext } = globalObject;
+    if (!pageContext)
+        return null;
+    const pageContextForPublicUsage = pageContext._isProxyObject
+        ? // providePageContext() is called on the user-land (e.g. it's called by `vike-{react,vue,solid}`) thus it's already a proxy
+            pageContext
+        : (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
+    return pageContextForPublicUsage;
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function providePageContext(pageContext) {
+    providePageContextInternal(pageContext);
+}
+function providePageContextInternal(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

package/dist/cjs/shared/hooks/getHook.js

@@ -4,10 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHookFromPageContext = getHookFromPageContext;
+exports.getHookFromPageContextNew = getHookFromPageContextNew;
 exports.getHookFromPageConfig = getHookFromPageConfig;
 exports.getHookFromPageConfigGlobal = getHookFromPageConfigGlobal;
 exports.getHookFromPageConfigGlobalCumulative = getHookFromPageConfigGlobalCumulative;
-exports.assertHook = assertHook;
 exports.getHook_setIsPrerenderering = getHook_setIsPrerenderering;
 exports.getHookTimeoutDefault = getHookTimeoutDefault;
 const getGlobalObject_js_1 = require("../../utils/getGlobalObject.js");
@@ -25,12 +25,34 @@ function getHookFromPageContext(pageContext, hookName) {
     const hookFn = pageContext.exports[hookName];
     if (hookFn === null)
         return null;
+    // TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
     const file = pageContext.exportsAll[hookName][0];
     (0, utils_js_1.assert)(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     (0, utils_js_1.assert)(hookFilePath);
     return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
+// TO-DO/eventually: remove getHookFromPageContext() in favor of getHookFromPageContextNew()
+function getHookFromPageContextNew(hookName, pageContext) {
+    const { hooksTimeout } = pageContext.config;
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+    const hooks = [];
+    /* TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
+    pageContext.configEntries[hookName]?.forEach((val) => {
+      const hookFn = val.configValue
+      if (hookFn === null) return
+      const hookFilePath = val.configDefinedByFile
+    */
+    pageContext.exportsAll[hookName]?.forEach((val) => {
+        const hookFn = val.exportValue;
+        if (hookFn === null)
+            return;
+        const hookFilePath = val.filePath;
+        (0, utils_js_1.assert)(hookFilePath);
+        hooks.push(getHook(hookFn, hookName, hookFilePath, hookTimeout));
+    });
+    return hooks;
+}
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = (0, getConfigValueRuntime_js_1.getConfigValueRuntime)(pageConfig, hookName);
     if (!configValue?.value)
@@ -79,9 +101,6 @@ function getHookFromConfigValue(configValue) {
     const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue.definedAtData);
     return { hookFn, hookFilePath };
 }
-function assertHook(pageContext, hookName) {
-    getHookFromPageContext(pageContext, hookName);
-}
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     (0, utils_js_1.assert)(hookName && hookFilePath);
     (0, utils_js_1.assert)(!hookName.endsWith(')'));