vike 0.4.247 → 0.4.249

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -1,54 +0,0 @@
-export { 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/4dbb354b0bcec04e862041fc9183fc4691bb8711/vike/utils/makePublicCopy.ts
-// Show warning when user is accessing internal `_` properties.
-import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
-function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
-    return new Proxy(obj, {
-        get: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
-    });
-}
-function getProp(prop, obj, objName, skipOnInternalProp, fallback) {
-    const propStr = String(prop);
-    if (prop === '_isProxyObject')
-        return true;
-    if (prop === 'dangerouslyUseInternals')
-        return obj;
-    if (!skipOnInternalProp) {
-        if (!globalThis.__VIKE__IS_CLIENT)
-            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)
-        return;
-    const propName = getPropAccessNotation(propStr);
-    assert(isBrowser());
-    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 on the client-side because of the reactivity mechanism of UI frameworks like Solid.
-    assert(!isBrowser());
-    // TO-DO/soon/proxy: remove this and only warn on built-in access instead
-    if (propStr === '_configFromHook')
-        return;
-    if (propStr.startsWith('_')) {
-        assertWarning(false, `Using internal ${objName}.${propStr} — https://vike.dev/warning/internals`, {
-            onlyOnce: true,
-            showStackTrace: true,
-        });
-    }
-}

package/dist/esm/shared/hooks/execHook.d.ts

@@ -1,49 +0,0 @@
-export { execHook };
-export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { getPageContext };
-export { providePageContext };
-export { isUserHookError };
-export type { PageContextExecHook };
-import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
-import type { Hook, HookLoc } from './getHook.js';
-import type { PageContextConfig } from '../getPageFiles.js';
-import type { HookName, HookNameGlobal } from '../../types/Config.js';
-import type { PageConfigGlobalRuntime } from '../../types/PageConfig.js';
-import type { PageContextForPublicUsageServer } from '../../node/runtime/renderPage/preparePageContextForPublicUsageServer.js';
-import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
-import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
-import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecHook = PageContextConfig & PageContextForPublicUsage;
-type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
-type HookWithResult = Hook & {
-    hookReturn: unknown;
-};
-declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
-declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
-declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
-    hookReturn: unknown;
-}>;
-declare function isUserHookError(err: unknown): false | HookLoc;
-declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
-declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
-    hookReturn: unknown;
-};
-/**
- * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
- *
- * https://vike.dev/getPageContext
- */
-declare function getPageContext<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
-/**
- * Provide `pageContext` for universal hooks.
- *
- * https://vike.dev/getPageContext
- */
-declare function providePageContext(pageContext: null | PageContextClient | PageContextServer): void;

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

@@ -1,145 +0,0 @@
-export { execHook };
-export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { getPageContext };
-export { providePageContext };
-export { isUserHookError };
-import { getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
-import { getGlobalObject } from '../../utils/getGlobalObject.js';
-import { humanizeTime } from '../../utils/humanizeTime.js';
-import { isObject } from '../../utils/isObject.js';
-import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
-import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
-const globalObject = getGlobalObject('utils/execHook.ts', {
-    userHookErrors: new WeakMap(),
-    pageContext: null,
-});
-async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
-    const hooks = getHookFromPageContextNew(hookName, pageContext);
-    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
-}
-async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
-    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
-    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
-    await Promise.all(hooks.map(async (hook) => {
-        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
-    }));
-}
-async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
-    if (!hooks.length)
-        return [];
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
-        return { ...hook, hookReturn };
-    }));
-    return hooksWithResult;
-}
-async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
-    const { hookReturn } = hooksWithResult[0];
-    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
-}
-async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
-    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
-    const { hookReturn } = hooksWithResult[0];
-    return { hookReturn };
-}
-function isUserHookError(err) {
-    if (!isObject(err))
-        return false;
-    return globalObject.userHookErrors.get(err) ?? false;
-}
-async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
-    const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
-    return hookReturn;
-}
-function execHookDirectAsync(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(() => {
-            assertWarning(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${humanizeTime(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
-        }, timeoutWarn);
-    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
-        setTimeout(() => {
-            const err = getProjectError(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${humanizeTime(timeoutErr)} (https://vike.dev/hooksTimeout)`);
-            reject(err);
-        }, timeoutErr);
-    (async () => {
-        try {
-            providePageContextInternal(pageContextForPublicUsage);
-            const ret = await hookFnCaller();
-            resolve(ret);
-        }
-        catch (err) {
-            if (isObject(err)) {
-                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
-            }
-            reject(err);
-        }
-    })();
-    return promise;
-}
-function execHookDirectSync(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
-        : 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/esm/shared/hooks/getHook.d.ts

@@ -1,38 +0,0 @@
-export { getHookFromPageContext };
-export { getHookFromPageContextNew };
-export { getHookFromPageConfig };
-export { getHookFromPageConfigGlobal };
-export { getHookFromPageConfigGlobalCumulative };
-export { getHook_setIsPrerenderering };
-export type { Hook };
-export type { HookLoc };
-export type { HookTimeout };
-export type { HooksTimeoutProvidedByUser };
-export { getHookTimeoutDefault };
-import type { PageContextConfig } from '../getPageFiles.js';
-import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
-import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
-type HookArgDefault = PageContextPrepareMinimum;
-type Hook<HookArg = HookArgDefault> = HookLoc & {
-    hookFn: HookFn<HookArg>;
-    hookTimeout: HookTimeout;
-};
-type HookLoc = {
-    hookName: HookNameOld;
-    hookFilePath: string;
-};
-type HookFn<HookArg = HookArgDefault> = (arg: HookArg) => unknown;
-type HookTimeout = {
-    error: number | false;
-    warning: number | false;
-};
-type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
-declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
-declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
-declare function getHookFromPageConfigGlobalCumulative<HookArg = GlobalContextPrepareMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
-declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
-declare function getHook_setIsPrerenderering(): void;

package/dist/esm/shared/page-configs/loadAndParseVirtualFilePageEntry.js

@@ -1,23 +0,0 @@
-export { loadAndParseVirtualFilePageEntry };
-import { assert, objectAssign } from '../utils.js';
-import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
-async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
-    if ('isPageEntryLoaded' in pageConfig &&
-        // We don't need to cache in dev, since Vite already caches the virtual module
-        !isDev) {
-        return pageConfig;
-    }
-    const { moduleId, moduleExportsPromise } = pageConfig.loadVirtualFilePageEntry();
-    const virtualFileExportsPageEntry = await moduleExportsPromise;
-    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
-    if (!virtualFileExportsPageEntry)
-        assert(false, { moduleExportsPromise, virtualFileExportsPageEntry, moduleId });
-    const configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
-    Object.assign(pageConfig.configValues, configValues);
-    objectAssign(pageConfig, { isPageEntryLoaded: true });
-    return pageConfig;
-}
-function parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry) {
-    const configValues = parseConfigValuesSerialized(virtualFileExportsPageEntry.configValuesSerialized);
-    return configValues;
-}

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -1,285 +0,0 @@
-export { serializeConfigValues };
-export { getConfigValuesBase };
-export { isJsonValue };
-import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assert, assertIsNotBrowser, assertPosixPath, assertUsage, deepEqual, getPropAccessNotation, isImportPathRelative, } from '../../../node/vite/utils.js';
-import { parsePointerImportData } from '../../../node/vite/shared/resolveVikeConfigInternal/pointerImports.js';
-import { getConfigValueFilePathToShowToUser } from '../helpers.js';
-import { stringify } from '@brillout/json-serializer/stringify';
-import pc from '@brillout/picocolors';
-import { getConfigValueSourcesRelevant, isRuntimeEnvMatch, } from '../../../node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
-const stringifyOptions = { forbidReactElements: true };
-const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
-const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
-// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigsSerialized()
-// - vike/shared/page-configs/serialize/parsePageConfigsSerialized.ts
-// - parsePageConfigsSerialized() is loaded on both the client- and server-side.
-assertIsNotBrowser();
-assertIsNotProductionRuntime();
-function serializeConfigValues(pageConfig, importStatements, filesEnv, runtimeEnv, tabspace, isEager) {
-    const lines = [];
-    tabspace += '  ';
-    getConfigValuesBase(pageConfig, runtimeEnv, isEager).forEach((entry) => {
-        if (entry.configValueBase.type === 'computed') {
-            assert('value' in entry); // Help TS
-            const { configValueBase, value, configName, configEnv } = entry;
-            const valueData = getValueSerializedWithJson(value, configName, configValueBase.definedAtData, importStatements, filesEnv, configEnv);
-            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-        }
-        if (entry.configValueBase.type === 'standard') {
-            assert('sourceRelevant' in entry); // Help TS
-            const { configValueBase, sourceRelevant, configName } = entry;
-            const valueData = getValueSerializedFromSource(sourceRelevant, configName, importStatements, filesEnv);
-            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
-        }
-        if (entry.configValueBase.type === 'cumulative') {
-            assert('sourcesRelevant' in entry); // Help TS
-            const { configValueBase, sourcesRelevant, configName } = entry;
-            const valueDataList = [];
-            sourcesRelevant.forEach((source) => {
-                const valueData = getValueSerializedFromSource(source, configName, importStatements, filesEnv);
-                valueDataList.push(valueData);
-            });
-            serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
-        }
-    });
-    return lines;
-}
-function getValueSerializedFromSource(configValueSource, configName, importStatements, filesEnv) {
-    let valueData;
-    if (configValueSource.valueIsLoaded && !configValueSource.valueIsLoadedWithImport) {
-        valueData = getValueSerializedWithJson(configValueSource.value, configName, configValueSource.definedAt, importStatements, filesEnv, configValueSource.configEnv);
-    }
-    else {
-        valueData = getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName);
-    }
-    return valueData;
-}
-function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
-    lineAdd(`[${JSON.stringify(configName)}]: {`);
-    {
-        tab();
-        lineAdd(`type: "${configValueBase.type}",`);
-        lineAdd(`definedAtData: ${JSON.stringify(configValueBase.definedAtData)},`);
-        lineAdd(`valueSerialized:`);
-        if (!Array.isArray(valueData)) {
-            serializeValueData(valueData);
-        }
-        else {
-            lineAppend(' [');
-            valueData.forEach(serializeValueData);
-            lineAppend(` ],`);
-        }
-        untab();
-    }
-    lineAdd('},');
-    return;
-    function serializeValueData(valueData) {
-        lineAppend(` {`);
-        tab();
-        lineAdd(`type: "${valueData.type}",`);
-        const valueProp = valueData.type !== 'plus-file' ? 'value' : 'exportValues';
-        lineAdd(`${valueProp}: ${valueData.valueAsJsCode},`);
-        untab();
-        lineAdd(`},`);
-    }
-    function lineAppend(str) {
-        const i = lines.length - 1;
-        lines[i] = lines[i] += str;
-    }
-    function lineAdd(str) {
-        lines.push(`${tabspace}${str}`);
-    }
-    function tab() {
-        tabspace += '  ';
-    }
-    function untab() {
-        tabspace = tabspace.slice(2);
-    }
-}
-function getValueSerializedWithImport(configValueSource, importStatements, filesEnv, configName) {
-    assert(!configValueSource.valueIsFilePath);
-    const { valueIsDefinedByPlusValueFile, definedAt, configEnv } = configValueSource;
-    assert(!definedAt.definedBy);
-    const { filePathAbsoluteVite, fileExportName } = definedAt;
-    if (valueIsDefinedByPlusValueFile)
-        assert(fileExportName === undefined);
-    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*', filesEnv, configEnv, configName);
-    return {
-        type: valueIsDefinedByPlusValueFile ? 'plus-file' : 'pointer-import',
-        valueAsJsCode: importName,
-    };
-}
-function getValueSerializedWithJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
-    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv);
-    return {
-        type: 'js-serialized',
-        valueAsJsCode,
-    };
-}
-function valueToJson(value, configName, definedAtData, importStatements, filesEnv, configEnv) {
-    const valueName = `config${getPropAccessNotation(configName)}`;
-    let configValueSerialized;
-    try {
-        configValueSerialized = stringify(value, {
-            valueName,
-            ...stringifyOptions,
-            // Replace import strings with import variables.
-            // - We don't need this anymore and could remove it.
-            //   - We temporarily needed it for nested document configs (`config.document.{title,description,favicon}`), but we finally decided to go for flat document configs instead (`config.{title,description,favicon}`).
-            //   - https://github.com/vikejs/vike-react/pull/113
-            replacer(_, value) {
-                if (typeof value === 'string') {
-                    const importData = parsePointerImportData(value);
-                    if (importData) {
-                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName, filesEnv, configEnv, configName);
-                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
-                        return { replacement };
-                    }
-                }
-            },
-        });
-    }
-    catch (err) {
-        logJsonSerializeError(err, configName, definedAtData);
-        assert(false);
-    }
-    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
-    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
-    assert(!configValueSerialized.includes(REPLACE_ME_BEFORE));
-    assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
-    return configValueSerialized;
-}
-function isJsonValue(value) {
-    try {
-        stringify(value, stringifyOptions);
-    }
-    catch (err) {
-        return false;
-    }
-    return true;
-}
-function logJsonSerializeError(err, configName, definedAtData) {
-    /*
-    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
-    let serializationErrMsg = ''
-    if (isJsonSerializerError(err)) {
-      serializationErrMsg = err.messageCore
-    } else {
-      // When a property getter throws an error
-      console.error('Serialization error:')
-      console.error(err)
-      serializationErrMsg = 'see serialization error printed above'
-    }
-    //*/
-    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
-    assert(configValueFilePathToShowToUser);
-    assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined using a separate file ${pc.bold(`+${configName}.js`)}, see https://vike.dev/error/runtime-in-config`);
-}
-function getConfigValuesBase(pageConfig, runtimeEnv, isEager) {
-    const fromComputed = Object.entries(pageConfig.configValuesComputed ?? {}).map(([configName, valueInfo]) => {
-        const { configEnv, value } = valueInfo;
-        if (!isRuntimeEnvMatch(configEnv, runtimeEnv))
-            return 'SKIP';
-        // AFAICT this should never happen: I ain't aware of a use case for overriding computed values. If there is a use case, then configValueSources has higher precedence.
-        if (pageConfig.configValueSources[configName])
-            return 'SKIP';
-        const configValueBase = {
-            type: 'computed',
-            definedAtData: null,
-        };
-        return { configValueBase, value, configName, configEnv };
-    });
-    const fromSources = Object.entries(pageConfig.configValueSources).map(([configName]) => {
-        const configDef = pageConfig.configDefinitions[configName];
-        assert(configDef);
-        if (isEager !== null && isEager !== !!configDef.eager)
-            return 'SKIP';
-        if (!configDef.cumulative) {
-            const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
-            const source = sourcesRelevant[0];
-            if (!source)
-                return 'SKIP';
-            assert(sourcesRelevant.length === 1);
-            const definedAtFile = getDefinedAtFileSource(source);
-            const configValueBase = {
-                type: 'standard',
-                definedAtData: definedAtFile,
-            };
-            return { configValueBase, sourceRelevant: source, configName };
-        }
-        else {
-            const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
-            if (sourcesRelevant.length === 0)
-                return 'SKIP';
-            const definedAtData = [];
-            sourcesRelevant.forEach((source) => {
-                const definedAtFile = getDefinedAtFileSource(source);
-                definedAtData.push(definedAtFile);
-            });
-            const configValueBase = {
-                type: 'cumulative',
-                definedAtData,
-            };
-            return { configValueBase, sourcesRelevant, configName };
-        }
-    });
-    return [...fromComputed, ...fromSources].filter((r) => r !== 'SKIP');
-}
-function getDefinedAtFileSource(source) {
-    const { definedAt } = source;
-    if (definedAt.definedBy)
-        return definedAt;
-    const definedAtFile = {
-        filePathToShowToUser: definedAt.filePathToShowToUser,
-        fileExportPathToShowToUser: definedAt.fileExportPathToShowToUser,
-    };
-    return definedAtFile;
-}
-/*
- * Naming:
- *   `import { someExport as someImport } from './some-file'`
- * <=>
- *   `{`
- *      `importPath: './some-file',`
- *      `exportName: 'someExport',`
- *      `importName: 'someImport',`
- *    `}`
- */
-function addImportStatement(importStatements, importPath, exportName, filesEnv, configEnv, configName) {
-    const importCounter = importStatements.length + 1;
-    const importName = `import${importCounter}`;
-    const importLiteral = (() => {
-        if (exportName === '*') {
-            return `* as ${importName}`;
-        }
-        if (exportName === 'default') {
-            return importName;
-        }
-        return `{ ${exportName} as ${importName} }`;
-    })();
-    const importStatement = `import ${importLiteral} from '${importPath}';`;
-    importStatements.push(importStatement);
-    assertFileEnv(importPath, configEnv, configName, filesEnv);
-    return { importName };
-}
-function assertFileEnv(importPath, configEnv, configName, filesEnv) {
-    assert(!isImportPathRelative(importPath));
-    const key = importPath;
-    assert(key);
-    assertPosixPath(key);
-    if (!filesEnv.has(key)) {
-        filesEnv.set(key, []);
-    }
-    const fileEnvs = filesEnv.get(key);
-    const fileEnvNew = { configEnv, configName };
-    fileEnvs.push(fileEnvNew);
-    const fileEnvDiff = fileEnvs.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
-    if (fileEnvDiff) {
-        assertUsage(false, [
-            `${importPath} defines the value of configs living in different environments:`,
-            ...[fileEnvDiff, fileEnvNew].map((c) => `  - config ${pc.code(c.configName)} which value lives in environment ${pc.code(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports',
-        ].join('\n'));
-    }
-}

package/dist/esm/shared/prepareGlobalContextForPublicUsage.d.ts

@@ -1,10 +0,0 @@
-export { prepareGlobalContextForPublicUsage };
-export type { GlobalContextPrepareMinimum };
-type GlobalContextPrepareMinimum = {
-    _isOriginalObject: true;
-    isGlobalContext: true;
-};
-declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext & {
-    _isProxyObject: true;
-    dangerouslyUseInternals: GlobalContext;
-};

package/dist/esm/shared/preparePageContextForPublicUsage.d.ts

@@ -1,14 +0,0 @@
-export { preparePageContextForPublicUsage };
-export { assertPropertyGetters };
-export type { PageContextPrepareMinimum };
-import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
-type PageContextPrepareMinimum = {
-    _isOriginalObject: true;
-    isPageContext: true;
-    _globalContext: GlobalContextPrepareMinimum;
-};
-declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
-    _isProxyObject: true;
-    dangerouslyUseInternals: PageContext;
-};
-declare function assertPropertyGetters(pageContext: Record<string, unknown>): void;