vike 0.4.229-commit-58f7ed0 → 0.4.229-commit-5da80bf

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

@@ -9,17 +9,16 @@ const getHook_js_1 = require("../../../shared/hooks/getHook.js");
 const utils_js_1 = require("../utils.js");
 const stream_js_1 = require("../html/stream.js");
 const assertPageContextProvidedByUser_js_1 = require("../../../shared/assertPageContextProvidedByUser.js");
-const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturnedObject.js");
 const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
+const execHook_js_1 = require("../../../shared/hooks/execHook.js");
 async function executeOnRenderHtmlHook(pageContext) {
-    const { renderHook, hookFn } = getRenderHook(pageContext);
-    (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
-    (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
-    const hookReturnValue = await (0, executeHook_js_1.executeHook)(() => hookFn(pageContext), renderHook, pageContext);
-    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
+    const hook = getRenderHook(pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, { _renderHook: hook });
+    const { hookReturn } = await (0, execHook_js_1.execHookSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });
     const onErrorWhileStreaming = (err) => {
@@ -34,7 +33,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     };
     const htmlRender = await (0, renderHtml_js_1.renderDocumentHtml)(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
     (0, utils_js_1.assert)(typeof htmlRender === 'string' || (0, stream_js_1.isStream)(htmlRender));
-    return { htmlRender, renderHook };
+    return { htmlRender, renderHook: hook };
 }
 function getRenderHook(pageContext) {
     let hookFound;
@@ -54,10 +53,7 @@ function getRenderHook(pageContext) {
         if (hook) {
             (0, utils_js_1.assert)(hookName);
             const { hookFilePath, hookFn, hookTimeout } = hook;
-            hookFound = {
-                hookFn,
-                renderHook: { hookFn, hookFilePath, hookName, hookTimeout }
-            };
+            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
         }
     }
     if (!hookFound) {

package/dist/cjs/node/runtime/renderPage/{loadUserFilesServerSide.js → loadPageConfigsLazyServerSide.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadUserFilesServerSide = loadUserFilesServerSide;
+exports.loadPageConfigsLazyServerSide = loadPageConfigsLazyServerSide;
 const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
-const getPageConfigUserFriendly_js_1 = require("../../../shared/page-configs/getPageConfigUserFriendly.js");
+const getUserFriendlyConfigs_js_1 = require("../../../shared/page-configs/getUserFriendlyConfigs.js");
 const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
 const utils_js_1 = require("../utils.js");
 const getPageAssets_js_1 = require("./getPageAssets.js");
@@ -10,7 +10,7 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
-async function loadUserFilesServerSide(pageContext) {
+async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -102,7 +102,7 @@ async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pag
     const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const pageContextExports = (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendly_oldDesign)(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const pageContextExports = (0, getUserFriendlyConfigs_js_1.getUserFriendlyConfigsPageLazy)(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         pageContextExports,
         pageFilesLoaded: pageFilesServerSide

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForPublicUsageServer = preparePageContextForPublicUsageServer;
+const preparePageContextForPublicUsage_js_1 = require("../../../shared/preparePageContextForPublicUsage.js");
+function preparePageContextForPublicUsageServer(pageContext) {
+    // TODO/next-major-release: after we remove supportVueReactiviy() we can call this later inside the agnostic preparePageContextForPublicUsage()
+    (0, preparePageContextForPublicUsage_js_1.assertPropertyGetters)(pageContext);
+    pageContext = (0, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage)(pageContext);
+    return pageContext;
+}

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.js

@@ -22,8 +22,9 @@ 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 getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
     httpRequestsCount: 0
 });
@@ -81,8 +82,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 +305,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 +416,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);
         }
@@ -488,5 +489,6 @@ function getPageContextInvalidVikeConfig(err, pageContextInit, httpRequestId) {
 function forkPageContext(pageContextBegin) {
     const pageContext = {};
     (0, utils_js_1.objectAssign)(pageContext, pageContextBegin, true);
-    return pageContext;
+    const pageContextWithProxy = (0, getProxyForPublicUsage_js_1.getProxyForMutationTracking)(pageContext);
+    return pageContextWithProxy;
 }

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,22 @@
 "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 getProxyForPublicUsage_js_1 = require("./getProxyForPublicUsage.js");
+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);
+    const pageContextWithProxy = (0, getProxyForPublicUsage_js_1.getProxyForMutationTracking)(pageContext);
+    return pageContextWithProxy;
+}

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,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProxyForPublicUsage = getProxyForPublicUsage;
+exports.getProxyForPublicUsageFlat = getProxyForPublicUsageFlat;
+exports.getProxyForMutationTracking = getProxyForMutationTracking;
+// 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) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp)
+    });
+}
+function getProxyForPublicUsageFlat(obj, objName, skipOnInternalProp) {
+    (0, utils_js_1.assert)(obj._isOriginalObject);
+    (0, utils_js_1.assert)(obj._proxyTarget);
+    obj._proxyTargetPublic ?? (obj._proxyTargetPublic = {});
+    const target = obj._proxyTargetPublic;
+    obj._userMods ?? (obj._userMods = {});
+    const objUserMods = obj._userMods;
+    const update = () => {
+        (0, utils_js_1.assert)(obj._proxyTarget);
+        (0, utils_js_1.objectReplace)(target, obj._proxyTarget);
+        (0, utils_js_1.objectAssign)(target, objUserMods);
+    };
+    obj._onChange = () => {
+        update();
+    };
+    update();
+    return new Proxy(target, {
+        // get: getTrapGet(target, objName, skipOnInternalProp),
+        set(_, prop, val) {
+            const ret = Reflect.set(objUserMods, prop, val);
+            update();
+            return ret;
+        },
+        defineProperty(_, ...args) {
+            const ret = Reflect.defineProperty(objUserMods, ...args);
+            update();
+            return ret;
+        },
+        deleteProperty(_, ...args) {
+            const ret = Reflect.deleteProperty(objUserMods, ...args);
+            update();
+            return ret;
+        }
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function getProxyForMutationTracking(obj) {
+    (0, utils_js_1.objectAssign)(obj, { _proxyTarget: obj });
+    return new Proxy(obj, {
+        set(...args) {
+            const ret = Reflect.set(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        defineProperty(...args) {
+            const ret = Reflect.defineProperty(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        deleteProperty(...args) {
+            const ret = Reflect.deleteProperty(...args);
+            obj._onChange?.();
+            return ret;
+        }
+    });
+}
+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 });
+    }
+}