vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,399 @@
+export { renderPage };
+export { renderPage_addWrapper };
+import { getRenderContext, getPageContextInitEnhanced, renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
+import { route } from '../../shared/route/index.js';
+import { assert, hasProp, objectAssign, isParsable, parseUrl, assertEnv, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, addUrlOrigin } from './utils.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
+import { getGlobalContext, initGlobalContext } from './globalContext.js';
+import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
+import { createHttpResponseObjectRedirect, createHttpResponsePageContextJson } from './renderPage/createHttpResponseObject.js';
+import { logRuntimeError, logRuntimeInfo } from './renderPage/loggerRuntime.js';
+import { isNewError } from './renderPage/isNewError.js';
+import { assertArguments } from './renderPage/assertArguments.js';
+import { log404 } from './renderPage/log404/index.js';
+import { isConfigInvalid } from './renderPage/isConfigInvalid.js';
+import pc from '@brillout/picocolors';
+import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
+import { getErrorPageId } from '../../shared/error-page.js';
+import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
+import { loadPageFilesServerSide } from './renderPage/loadPageFilesServerSide.js';
+import { resolveRedirects } from '../../shared/route/resolveRedirects.js';
+const globalObject = getGlobalObject('runtime/renderPage.ts', {
+    httpRequestsCount: 0,
+    pendingRequestsCount: 0
+});
+let renderPage_wrapper = async (_httpRequestId, ret) => ({
+    pageContextReturn: await ret(),
+    onRequestDone: () => { }
+});
+const renderPage_addWrapper = (wrapper) => {
+    renderPage_wrapper = wrapper;
+};
+// `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
+async function renderPage(pageContextInit) {
+    assertArguments(...arguments);
+    assert(hasProp(pageContextInit, 'urlOriginal', 'string'));
+    assertEnv();
+    if (skipRequest(pageContextInit.urlOriginal)) {
+        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
+        checkType(pageContextHttpReponseNull);
+        return pageContextHttpReponseNull;
+    }
+    const httpRequestId = getRequestId();
+    const urlToShowToUser = pageContextInit.urlOriginal;
+    logHttpRequest(urlToShowToUser, httpRequestId);
+    globalObject.pendingRequestsCount++;
+    const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn);
+    globalObject.pendingRequestsCount--;
+    onRequestDone();
+    checkType(pageContextReturn);
+    return pageContextReturn;
+}
+async function renderPageAndPrepare(pageContextInit, httpRequestId) {
+    // Invalid config
+    const handleInvalidConfig = () => {
+        logRuntimeInfo?.(pc.bold(pc.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
+        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpReponseNull;
+    };
+    if (isConfigInvalid) {
+        return handleInvalidConfig();
+    }
+    // Prepare context
+    let renderContext;
+    try {
+        await initGlobalContext();
+        renderContext = await getRenderContext();
+    }
+    catch (err) {
+        // Errors are expected since assertUsage() is used in both initGlobalContext() and getRenderContext().
+        // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
+        assert(!isAbortError(err));
+        logRuntimeError(err, httpRequestId);
+        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpReponseNull;
+    }
+    if (isConfigInvalid) {
+        return handleInvalidConfig();
+    }
+    else {
+        // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
+    }
+    {
+        const pageContextHttpReponse = normalizeUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpReponse)
+            return pageContextHttpReponse;
+    }
+    {
+        const pageContextHttpReponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        if (pageContextHttpReponse)
+            return pageContextHttpReponse;
+    }
+    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
+}
+async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, pageContextsFromRewrite) {
+    assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, 
+    // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
+    // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
+    0);
+    let pageContextNominalPageSuccess;
+    let pageContextNominalPageInit = {};
+    {
+        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+        objectAssign(pageContextNominalPageInit, pageContextFromAllRewrites);
+    }
+    {
+        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
+        objectAssign(pageContextNominalPageInit, pageContextInitEnhanced);
+    }
+    let errNominalPage;
+    {
+        try {
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+        }
+        catch (err) {
+            errNominalPage = err;
+            assert(errNominalPage);
+            logRuntimeError(errNominalPage, httpRequestId);
+        }
+        if (!errNominalPage) {
+            assert(pageContextNominalPageSuccess === pageContextNominalPageInit);
+        }
+    }
+    // Log upon 404
+    if (pageContextNominalPageSuccess &&
+        'is404' in pageContextNominalPageSuccess &&
+        pageContextNominalPageSuccess.is404 === true) {
+        await log404(pageContextNominalPageSuccess);
+    }
+    if (errNominalPage === undefined) {
+        assert(pageContextNominalPageSuccess);
+        return pageContextNominalPageSuccess;
+    }
+    else {
+        assert(errNominalPage);
+        assert(pageContextNominalPageSuccess === undefined);
+        assert(pageContextNominalPageInit);
+        assert(hasProp(pageContextNominalPageInit, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, renderContext, httpRequestId);
+        if (isAbortError(errNominalPage)) {
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+            if (handled.pageContextReturn) {
+                // - throw redirect()
+                // - throw render(url)
+                // - throw render(abortStatusCode) if .pageContext.json request
+                return handled.pageContextReturn;
+            }
+            else {
+                // - throw render(abortStatusCode) if not .pageContext.json request
+            }
+            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        }
+        {
+            const errorPageId = getErrorPageId(renderContext.pageFilesAll, renderContext.pageConfigs);
+            if (!errorPageId) {
+                objectAssign(pageContextErrorPageInit, { _pageId: null });
+                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
+            }
+            else {
+                objectAssign(pageContextErrorPageInit, { _pageId: errorPageId });
+            }
+        }
+        let pageContextErrorPage;
+        try {
+            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
+        }
+        catch (errErrorPage) {
+            if (isAbortError(errErrorPage)) {
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+                // throw render(abortStatusCode)
+                if (!handled.pageContextReturn) {
+                    const pageContextAbort = errErrorPage._pageContextAbort;
+                    assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                    const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+                    return pageContextHttpReponseNull;
+                }
+                // `throw redirect()` / `throw render(url)`
+                return handled.pageContextReturn;
+            }
+            if (isNewError(errErrorPage, errNominalPage)) {
+                logRuntimeError(errErrorPage, httpRequestId);
+            }
+            const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+            return pageContextHttpReponseNull;
+        }
+        return pageContextErrorPage;
+    }
+}
+function logHttpRequest(urlToShowToUser, httpRequestId) {
+    const clearErrors = globalObject.pendingRequestsCount === 0;
+    logRuntimeInfo?.(`HTTP request: ${pc.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+}
+function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+    const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
+    const isSuccess = statusCode !== null && statusCode >= 200 && statusCode <= 399;
+    const isNominal = isSuccess || statusCode === 404;
+    const color = (s) => pc.bold(isSuccess ? pc.green(String(s)) : pc.red(String(s)));
+    const isRedirect = statusCode && 300 <= statusCode && statusCode <= 399;
+    const type = isRedirect ? 'redirect' : 'response';
+    if (isRedirect) {
+        assert(pageContextReturn.httpResponse);
+        const headerRedirect = pageContextReturn.httpResponse.headers
+            .slice()
+            .reverse()
+            .find((header) => header[0] === 'Location');
+        assert(headerRedirect);
+        const urlRedirect = headerRedirect[1];
+        urlToShowToUser = urlRedirect;
+    }
+    logRuntimeInfo?.(`HTTP ${type} ${pc.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+}
+function getPageContextHttpResponseNullWithError(err, pageContextInit) {
+    const pageContextHttpReponseNull = {};
+    objectAssign(pageContextHttpReponseNull, pageContextInit);
+    objectAssign(pageContextHttpReponseNull, {
+        httpResponse: null,
+        errorWhileRendering: err
+    });
+    return pageContextHttpReponseNull;
+}
+function getPageContextHttpResponseNull(pageContextInit) {
+    const pageContextHttpReponseNull = {};
+    objectAssign(pageContextHttpReponseNull, pageContextInit);
+    objectAssign(pageContextHttpReponseNull, {
+        httpResponse: null,
+        errorWhileRendering: null
+    });
+    return pageContextHttpReponseNull;
+}
+async function renderPageNominal(pageContext) {
+    objectAssign(pageContext, { errorWhileRendering: null });
+    // Check Base URL
+    {
+        const { urlWithoutPageContextRequestSuffix } = handlePageContextRequestUrl(pageContext.urlOriginal);
+        const hasBaseServer = parseUrl(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
+        if (!hasBaseServer) {
+            objectAssign(pageContext, { httpResponse: null });
+            return pageContext;
+        }
+    }
+    // Route
+    {
+        const routeResult = await route(pageContext);
+        objectAssign(pageContext, routeResult.pageContextAddendum);
+        objectAssign(pageContext, { is404: pageContext._pageId ? null : true });
+        if (pageContext._pageId === null) {
+            const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+            if (!errorPageId) {
+                assert(hasProp(pageContext, '_pageId', 'null'));
+                return handleErrorWithoutErrorPage(pageContext);
+            }
+            objectAssign(pageContext, { _pageId: errorPageId });
+        }
+    }
+    assert(hasProp(pageContext, '_pageId', 'string'));
+    // Render
+    const pageContextAfterRender = await renderPageAlreadyRouted(pageContext);
+    assert(pageContext === pageContextAfterRender);
+    return pageContextAfterRender;
+}
+async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, renderContext, httpRequestId) {
+    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, null, httpRequestId);
+    assert(errNominalPage);
+    const pageContext = {
+        ...pageContextInitEnhanced,
+        is404: false,
+        errorWhileRendering: errNominalPage,
+        routeParams: {}
+    };
+    objectAssign(pageContext, {
+        _routeMatches: pageContextNominalPagePartial._routeMatches || 'ROUTE_ERROR'
+    });
+    assert(pageContext.errorWhileRendering);
+    return pageContext;
+}
+function getPageContextInitEnhancedSSR(pageContextInit, renderContext, urlRewrite, httpRequestId) {
+    const { isClientSideNavigation, _urlHandler } = handleUrl(pageContextInit.urlOriginal, urlRewrite);
+    const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext, {
+        ssr: {
+            urlRewrite,
+            urlHandler: _urlHandler,
+            isClientSideNavigation
+        }
+    });
+    objectAssign(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
+    return pageContextInitEnhanced;
+}
+function handleUrl(urlOriginal, urlRewrite) {
+    assert(isUrlValid(urlOriginal));
+    assert(urlRewrite === null || isUrlValid(urlRewrite));
+    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
+    const pageContextAddendum = {
+        isClientSideNavigation: isPageContextRequest,
+        _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix
+    };
+    return pageContextAddendum;
+}
+function isUrlValid(url) {
+    return url.startsWith('/') || url.startsWith('http');
+}
+function getRequestId() {
+    const httpRequestId = ++globalObject.httpRequestsCount;
+    assert(httpRequestId >= 1);
+    return httpRequestId;
+}
+function skipRequest(urlOriginal) {
+    const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
+    assertWarning(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    return (urlOriginal.endsWith('/__vite_ping') ||
+        urlOriginal.endsWith('/favicon.ico') ||
+        !isParsable(urlOriginal) ||
+        isViteClientRequest);
+}
+function normalizeUrl(pageContextInit, httpRequestId) {
+    const { trailingSlash, disableUrlNormalization } = getGlobalContext();
+    if (disableUrlNormalization)
+        return null;
+    const { urlOriginal } = pageContextInit;
+    const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash);
+    if (!urlNormalized)
+        return null;
+    logRuntimeInfo?.(`URL normalized from ${pc.cyan(urlOriginal)} to ${pc.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    return pageContextHttpResponse;
+}
+function getPermanentRedirect(pageContextInit, httpRequestId) {
+    const { redirects, baseServer } = getGlobalContext();
+    const urlWithoutBase = removeBaseServer(pageContextInit.urlOriginal, baseServer);
+    let urlOriginalPathnameWithouBase;
+    let origin = null;
+    let urlTarget = modifyUrlPathname(urlWithoutBase, (urlPathname) => {
+        urlOriginalPathnameWithouBase = urlPathname;
+        const urlTargetWithOrigin = resolveRedirects(redirects, urlPathname);
+        if (urlTargetWithOrigin === null)
+            return null;
+        const { urlModified, origin: origin_ } = removeUrlOrigin(urlTargetWithOrigin);
+        origin = origin_;
+        return urlModified;
+    });
+    if (origin)
+        urlTarget = addUrlOrigin(urlTarget, origin);
+    assert(urlOriginalPathnameWithouBase);
+    if (urlTarget === urlWithoutBase)
+        return null;
+    logRuntimeInfo?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
+    urlTarget = prependBase(urlTarget, baseServer);
+    assert(urlTarget !== pageContextInit.urlOriginal);
+    const httpResponse = createHttpResponseObjectRedirect({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    return pageContextHttpResponse;
+}
+async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit) {
+    logAbortErrorHandled(errAbort, getGlobalContext().isProduction, pageContextNominalPageInit);
+    const pageContextAbort = errAbort._pageContextAbort;
+    let pageContextSerialized;
+    if (pageContextNominalPageInit.isClientSideNavigation) {
+        if (pageContextAbort.abortStatusCode) {
+            const errorPageId = getErrorPageId(renderContext.pageFilesAll, renderContext.pageConfigs);
+            const abortCall = pageContextAbort._abortCall;
+            assert(abortCall);
+            assertUsage(errorPageId, `You called ${pc.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
+            const pageContext = {
+                _pageId: errorPageId,
+                ...pageContextAbort,
+                ...pageContextErrorPageInit,
+                ...renderContext
+            };
+            objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+            // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
+            pageContextSerialized = serializePageContextClientSide(pageContext);
+        }
+        else {
+            pageContextSerialized = serializePageContextAbort(pageContextAbort);
+        }
+        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        const pageContextReturn = { httpResponse };
+        return { pageContextReturn };
+    }
+    if (pageContextAbort._urlRewrite) {
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, [
+            ...pageContextsFromRewrite,
+            pageContextAbort
+        ]);
+        Object.assign(pageContextReturn, pageContextAbort);
+        return { pageContextReturn };
+    }
+    if (pageContextAbort._urlRedirect) {
+        const pageContextReturn = {
+            ...pageContextInit,
+            ...pageContextAbort
+        };
+        const httpResponse = createHttpResponseObjectRedirect(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        objectAssign(pageContextReturn, { httpResponse });
+        return { pageContextReturn };
+    }
+    assert(pageContextAbort.abortStatusCode);
+    return { pageContextAbort };
+}

package/dist/esm/node/runtime/utils.d.ts

@@ -0,0 +1,52 @@
+import '../../utils/trackLogs.js';
+export * from '../../utils/assert.js';
+export * from '../../utils/cast.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/isPromise.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/parseUrl-extras.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/sorter.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/PromiseType.js';
+export * from '../../utils/compareString.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/stringifyStringArray.js';
+export * from '../../utils/unique.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/getOutDirs.js';
+export * from '../../utils/capitalizeFirstLetter.js';
+export * from '../../utils/debugGlob.js';
+export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/styleFileRE.js';
+export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/debug.js';
+export * from '../../utils/urlToFile.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/isStemPackageName.js';
+export * from '../../utils/freezePartial.js';
+export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isScriptFile.js';
+export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/objectEntries.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/getFileExtension.js';
+export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/virtual-files.js';
+export * from '../../utils/path-shim.js';
+export * from '../../utils/nodeEnv.js';
+export * from '../../utils/isHtml.js';
+export * from '../../utils/warnIfErrorIsNotObject.js';
+export * from '../../utils/dynamicImport.js';
+export * from '../../utils/stripAnsi.js';
+export * from '../../utils/getTerminWidth.js';
+export * from '../../utils/truncateString.js';
+export * from '../../utils/autoRetry.js';

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

@@ -0,0 +1,55 @@
+import '../../utils/trackLogs.js';
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from './onLoad.js';
+onLoad();
+export * from '../../utils/assert.js';
+export * from '../../utils/cast.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/isBrowser.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/isPromise.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/parseUrl-extras.js';
+export * from '../../utils/slice.js';
+export * from '../../utils/sorter.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/PromiseType.js';
+export * from '../../utils/compareString.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/stringifyStringArray.js';
+export * from '../../utils/unique.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/getOutDirs.js';
+export * from '../../utils/capitalizeFirstLetter.js';
+export * from '../../utils/debugGlob.js';
+export * from '../../utils/isEquivalentError.js';
+export * from '../../utils/styleFileRE.js';
+export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/debug.js';
+export * from '../../utils/urlToFile.js';
+export * from '../../utils/getGlobalObject.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/isStemPackageName.js';
+export * from '../../utils/freezePartial.js';
+export * from '../../utils/isNpmPackage.js';
+export * from '../../utils/isNotNullish.js';
+export * from '../../utils/isScriptFile.js';
+export * from '../../utils/removeFileExtention.js';
+export * from '../../utils/objectEntries.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/getFileExtension.js';
+export * from '../../utils/assertIsNotProductionRuntime.js';
+export * from '../../utils/virtual-files.js';
+export * from '../../utils/path-shim.js';
+export * from '../../utils/nodeEnv.js';
+export * from '../../utils/isHtml.js';
+export * from '../../utils/warnIfErrorIsNotObject.js';
+export * from '../../utils/dynamicImport.js';
+export * from '../../utils/stripAnsi.js';
+export * from '../../utils/getTerminWidth.js';
+export * from '../../utils/truncateString.js';
+export * from '../../utils/autoRetry.js';

package/dist/esm/node/shared/ViteManifest.d.ts

@@ -0,0 +1,13 @@
+export type { ViteManifest };
+export type { ViteManifestEntry };
+type ViteManifestEntry = {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+};
+type ViteManifest = Record<string, ViteManifestEntry>;

package/dist/esm/node/shared/ViteManifest.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/node/shared/assertPluginManifest.d.ts

@@ -0,0 +1,14 @@
+export { assertPluginManifest };
+export type { PluginManifest };
+type PluginManifest = {
+    version: string;
+    baseServer: string;
+    baseAssets: string | null;
+    usesClientRouter: boolean;
+    includeAssetsImportedByServer: boolean;
+    manifestKeyMap: Record<string, string>;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+};
+declare function assertPluginManifest(pluginManifest: unknown): asserts pluginManifest is PluginManifest;

package/dist/esm/node/shared/assertPluginManifest.js

@@ -0,0 +1,21 @@
+export { assertPluginManifest };
+import { assertRuntimeManifest } from './assertRuntimeManifest.js';
+import { assert, assertUsage, isPlainObject, projectInfo, checkType, hasProp, isStringRecord, objectAssign } from './utils.js';
+function assertPluginManifest(pluginManifest) {
+    assert(isPlainObject(pluginManifest));
+    assertUsage(pluginManifest.version === projectInfo.projectVersion, `Re-build your app (you're using vike@${projectInfo.projectVersion} but your app was built with vike@${pluginManifest.version})`);
+    assertRuntimeManifest(pluginManifest);
+    assert(hasProp(pluginManifest, 'usesClientRouter', 'boolean'));
+    assert(hasProp(pluginManifest, 'version', 'string'));
+    assert(hasProp(pluginManifest, 'manifestKeyMap', 'object'));
+    const { manifestKeyMap } = pluginManifest;
+    assert(isStringRecord(manifestKeyMap));
+    // Avoid:
+    // ```
+    // Uncaught (in promise) TypeError: Cannot set property manifestKeyMap of #<Object> which has only a getter
+    // ```
+    // See https://github.com/vikejs/vike/issues/596
+    const pluginManifestClone = { ...pluginManifest };
+    objectAssign(pluginManifestClone, { manifestKeyMap });
+    checkType(pluginManifestClone);
+}

package/dist/esm/node/shared/assertRuntimeManifest.d.ts

@@ -0,0 +1,11 @@
+export { assertRuntimeManifest };
+export type { RuntimeManifest };
+type RuntimeManifest = {
+    baseServer: string;
+    baseAssets: string;
+    includeAssetsImportedByServer: boolean;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+};
+declare function assertRuntimeManifest(obj: unknown): asserts obj is RuntimeManifest & Record<string, unknown>;

package/dist/esm/node/shared/assertRuntimeManifest.js

@@ -0,0 +1,16 @@
+export { assertRuntimeManifest };
+import { assert, castType, checkType, hasProp, isBaseAssets, isBaseServer, isObject } from './utils.js';
+function assertRuntimeManifest(obj) {
+    assert(obj);
+    assert(isObject(obj));
+    assert(hasProp(obj, 'baseServer', 'string'));
+    assert(hasProp(obj, 'baseAssets', 'string'));
+    assert(isBaseServer(obj.baseServer));
+    assert(isBaseAssets(obj.baseAssets));
+    assert(hasProp(obj, 'includeAssetsImportedByServer', 'boolean'));
+    assert(hasProp(obj, 'redirects', 'object'));
+    castType(obj);
+    assert(hasProp(obj, 'trailingSlash', 'boolean'));
+    assert(hasProp(obj, 'disableUrlNormalization', 'boolean'));
+    checkType(obj);
+}

package/dist/esm/node/shared/extractAssetsQuery.d.ts

@@ -0,0 +1,4 @@
+export { extractAssetsAddQuery };
+export { extractAssetsRemoveQuery };
+declare function extractAssetsAddQuery(id: string): string;
+declare function extractAssetsRemoveQuery(id: string): string;

package/dist/esm/node/shared/extractAssetsQuery.js

@@ -0,0 +1,26 @@
+export { extractAssetsAddQuery };
+export { extractAssetsRemoveQuery };
+// We import from node/utils.ts insead of node/plugin/utils.ts because this file is loaded by the server runtime
+import { assert, getFileExtension } from './utils.js';
+const query = 'extractAssets';
+function extractAssetsAddQuery(id) {
+    const fileExtension = getFileExtension(id);
+    assert(fileExtension || id.includes('virtual:vike:'));
+    if (!fileExtension)
+        return `${id}?${query}`;
+    if (id.includes('?')) {
+        id = id.replace('?', `?${query}&`);
+    }
+    else {
+        id = `${id}?${query}&lang.${fileExtension}`;
+    }
+    return id;
+}
+function extractAssetsRemoveQuery(id) {
+    if (!id.includes('?'))
+        return id;
+    const suffix = `?${query}`;
+    // Only supports 'virtual:vike:' IDs
+    assert(id.endsWith(query));
+    return id.slice(0, -1 * suffix.length);
+}

package/dist/esm/node/shared/getClientEntryFilePath.d.ts

@@ -0,0 +1,3 @@
+export { getClientEntryFilePath };
+import type { PageConfig, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
+declare function getClientEntryFilePath(pageConfig: PageConfig | PageConfigBuildTime): null | string;

package/dist/esm/node/shared/getClientEntryFilePath.js

@@ -0,0 +1,15 @@
+export { getClientEntryFilePath };
+import { getConfigDefinedAtInfo, getConfigValue } from '../../shared/page-configs/utils.js';
+import { assert } from './utils.js';
+function getClientEntryFilePath(pageConfig) {
+    const configName = 'client';
+    const configValue = getConfigValue(pageConfig, configName, 'string');
+    if (!configValue)
+        return null;
+    const definedAtInfo = getConfigDefinedAtInfo(pageConfig, configName);
+    const { value } = configValue;
+    // Users should be able to suppress client entry by setting its value to null
+    assert(value !== null);
+    const clientEntryFilePath = definedAtInfo.filePath;
+    return clientEntryFilePath;
+}

package/dist/esm/node/shared/getConfigVike.d.ts

@@ -0,0 +1,3 @@
+export { getConfigVike };
+import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
+declare function getConfigVike(config: Record<string, unknown>): Promise<ConfigVikeResolved>;

package/dist/esm/node/shared/getConfigVike.js

@@ -0,0 +1,5 @@
+export { getConfigVike };
+async function getConfigVike(config) {
+    const configVike = (await config.configVikePromise);
+    return configVike;
+}