vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,15 @@
+// Logger used by the the server runtime. (Also during pre-rendering since it uses the sever runtime.)
+export let logRuntimeError;
+export let logRuntimeInfo = null; // logInfo is null in production
+export { overwriteRuntimeProductionLogger };
+import { logErrorProd } from './loggerProd.js';
+// Set production logger (which is overwritten by loggerNotProd.ts in non-production environments such as development and during pre-rendering)
+logRuntimeError =
+    // @ts-expect-error
+    logRuntimeError ??
+        // Default
+        logErrorProd;
+function overwriteRuntimeProductionLogger(logError_, logInfo_) {
+    logRuntimeError = logError_;
+    logRuntimeInfo = logInfo_;
+}

package/dist/esm/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.d.ts

@@ -0,0 +1,26 @@
+export { preparePageContextForUserConsumptionServerSide };
+export type { PageContextForUserConsumptionServerSide };
+import { PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { ConfigEntries, ExportsAll } from '../../../shared/getPageFiles/getExports.js';
+import { PageContextBuiltInServerInternal } from '../../../shared/types.js';
+type PageContextForUserConsumptionServerSide = PageContextBuiltInServerInternal & {
+    urlOriginal: string;
+    /** @deprecated */
+    url: string;
+    urlPathname: string;
+    urlParsed: PageContextUrlComputedPropsInternal['urlParsed'];
+    routeParams: Record<string, string>;
+    Page: unknown;
+    pageExports: Record<string, unknown>;
+    config: Record<string, unknown>;
+    configEntries: ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: ExportsAll;
+    _pageId: string;
+    _pageConfigs: PageConfig[];
+    is404: null | boolean;
+    isClientSideNavigation: boolean;
+    pageProps?: Record<string, unknown>;
+} & Record<string, unknown>;
+declare function preparePageContextForUserConsumptionServerSide(pageContext: PageContextForUserConsumptionServerSide): void;

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

@@ -0,0 +1,16 @@
+export { preparePageContextForUserConsumptionServerSide };
+import { assert, isPlainObject, isObject } from '../utils.js';
+import { sortPageContext } from '../../../shared/sortPageContext.js';
+import { assertPageContextUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
+import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
+function preparePageContextForUserConsumptionServerSide(pageContext) {
+    assertPageContextUrlComputedProps(pageContext);
+    assert(isPlainObject(pageContext.routeParams));
+    assert('Page' in pageContext);
+    assert(isObject(pageContext.pageExports));
+    assert(isObject(pageContext.exports));
+    assert(isObject(pageContext.exportsAll));
+    assert(typeof pageContext.isClientSideNavigation === 'boolean');
+    sortPageContext(pageContext);
+    addIs404ToPageProps(pageContext);
+}

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -0,0 +1,265 @@
+export { renderPageAlreadyRouted };
+export { prerenderPage };
+export { prerender404Page };
+export { getPageContextInitEnhanced };
+export { getRenderContext };
+export type { RenderContext };
+export type { PageContextAfterRender };
+export type { PageContextInitEnhanced };
+import { type PageFile } from '../../../shared/getPageFiles.js';
+import { type PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
+import { HttpResponse } from './createHttpResponseObject.js';
+import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
+import type { PageConfig, PageConfigGlobal } from '../../../shared/page-configs/PageConfig.js';
+import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
+import type { OnBeforeRouteHook } from '../../../shared/route/executeOnBeforeRouteHook.js';
+type PageContextAfterRender = {
+    httpResponse: null | HttpResponse;
+    errorWhileRendering: null | Error;
+};
+declare function renderPageAlreadyRouted<PageContext extends {
+    _pageId: string;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+    is404: null | boolean;
+    routeParams: Record<string, string>;
+    errorWhileRendering: null | Error;
+    _httpRequestId: number;
+} & PageContextInitEnhanced & PageContextUrlComputedPropsInternal & PageContext_loadPageFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles & {
+    routeParams: Record<string, string>;
+    _pageId: string;
+    _urlRewrite: null;
+    _httpRequestId: number | null;
+    _usesClientRouter: boolean;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+    is404: null | boolean;
+}): Promise<{
+    documentHtml: string;
+    pageContextSerialized: null;
+    pageContext: {
+        _objectCreatedByVike: boolean;
+        _baseServer: string;
+        _baseAssets: string | null;
+        _includeAssetsImportedByServer: boolean;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfig[];
+        _pageConfigGlobal: PageConfigGlobal;
+        _allPageIds: string[];
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _pageContextInit: {
+            urlOriginal: string;
+        };
+        _urlRewrite: string | null;
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+        urlOriginal: string;
+    } & import("../../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+        _urlRewrite: string | null;
+    } & {
+        config: Record<string, unknown>;
+        configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
+        pageExports: Record<string, unknown>;
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: string[];
+        _pageFilePathsLoaded: string[];
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        _pageId: string;
+        _urlRewrite: null;
+        _httpRequestId: number | null;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true | undefined;
+        is404: null | boolean;
+    } & {
+        isClientSideNavigation: boolean;
+        _urlHandler: null;
+    };
+} | {
+    documentHtml: string;
+    pageContextSerialized: string;
+    pageContext: {
+        _objectCreatedByVike: boolean;
+        _baseServer: string;
+        _baseAssets: string | null;
+        _includeAssetsImportedByServer: boolean;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfig[];
+        _pageConfigGlobal: PageConfigGlobal;
+        _allPageIds: string[];
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _pageContextInit: {
+            urlOriginal: string;
+        };
+        _urlRewrite: string | null;
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+        urlOriginal: string;
+    } & import("../../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+        _urlRewrite: string | null;
+    } & {
+        config: Record<string, unknown>;
+        configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
+        pageExports: Record<string, unknown>;
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: string[];
+        _pageFilePathsLoaded: string[];
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        _pageId: string;
+        _urlRewrite: null;
+        _httpRequestId: number | null;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true | undefined;
+        is404: null | boolean;
+    } & {
+        isClientSideNavigation: boolean;
+        _urlHandler: null;
+    };
+}>;
+declare function prerender404Page(renderContext: RenderContext, pageContextInit_: Record<string, unknown> | null): Promise<{
+    documentHtml: string;
+    pageContextSerialized: null;
+    pageContext: {
+        _objectCreatedByVike: boolean;
+        _baseServer: string;
+        _baseAssets: string | null;
+        _includeAssetsImportedByServer: boolean;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfig[];
+        _pageConfigGlobal: PageConfigGlobal;
+        _allPageIds: string[];
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _pageContextInit: {
+            urlOriginal: string;
+        };
+        _urlRewrite: string | null;
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+        urlOriginal: string;
+    } & import("../../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+        _urlRewrite: string | null;
+    } & {
+        config: Record<string, unknown>;
+        configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
+        pageExports: Record<string, unknown>;
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: string[];
+        _pageFilePathsLoaded: string[];
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        _pageId: string;
+        _urlRewrite: null;
+        _httpRequestId: number | null;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true | undefined;
+        is404: boolean | null;
+    } & {
+        isClientSideNavigation: boolean;
+        _urlHandler: null;
+    };
+} | {
+    documentHtml: string;
+    pageContextSerialized: string;
+    pageContext: {
+        _objectCreatedByVike: boolean;
+        _baseServer: string;
+        _baseAssets: string | null;
+        _includeAssetsImportedByServer: boolean;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfig[];
+        _pageConfigGlobal: PageConfigGlobal;
+        _allPageIds: string[];
+        _pageRoutes: PageRoutes;
+        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _pageContextInit: {
+            urlOriginal: string;
+        };
+        _urlRewrite: string | null;
+        _urlHandler: ((url: string) => string) | null;
+        isClientSideNavigation: boolean;
+        urlOriginal: string;
+    } & import("../../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+        _urlRewrite: string | null;
+    } & {
+        config: Record<string, unknown>;
+        configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
+        exports: Record<string, unknown>;
+        exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
+        pageExports: Record<string, unknown>;
+        Page: unknown;
+        _isHtmlOnly: boolean;
+        _passToClient: string[];
+        _pageFilePathsLoaded: string[];
+    } & {
+        __getPageAssets: () => Promise<import("./getPageAssets.js").PageAsset[]>;
+    } & {
+        routeParams: Record<string, string>;
+        _pageId: string;
+        _urlRewrite: null;
+        _httpRequestId: number | null;
+        _usesClientRouter: boolean;
+        _pageContextAlreadyProvidedByOnPrerenderHook?: true | undefined;
+        is404: boolean | null;
+    } & {
+        isClientSideNavigation: boolean;
+        _urlHandler: null;
+    };
+} | null>;
+type PageContextInitEnhanced = ReturnType<typeof getPageContextInitEnhanced>;
+declare function getPageContextInitEnhanced(pageContextInit: {
+    urlOriginal: string;
+}, renderContext: RenderContext, { urlComputedPropsNonEnumerable, ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
+    urlComputedPropsNonEnumerable?: boolean;
+    ssr?: {
+        urlRewrite: null | string;
+        urlHandler: null | ((url: string) => string);
+        isClientSideNavigation: boolean;
+    };
+}): {
+    _objectCreatedByVike: boolean;
+    _baseServer: string;
+    _baseAssets: string | null;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfig[];
+    _pageConfigGlobal: PageConfigGlobal;
+    _allPageIds: string[];
+    _pageRoutes: PageRoutes;
+    _onBeforeRouteHook: OnBeforeRouteHook | null;
+    _pageContextInit: {
+        urlOriginal: string;
+    };
+    _urlRewrite: string | null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+    urlOriginal: string;
+} & import("../../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
+    _urlRewrite: string | null;
+};
+type RenderContext = {
+    pageFilesAll: PageFile[];
+    pageConfigs: PageConfig[];
+    pageConfigGlobal: PageConfigGlobal;
+    allPageIds: string[];
+    pageRoutes: PageRoutes;
+    onBeforeRouteHook: OnBeforeRouteHook | null;
+};
+declare function getRenderContext(): Promise<RenderContext>;

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

@@ -0,0 +1,180 @@
+export { renderPageAlreadyRouted };
+export { prerenderPage };
+export { prerender404Page };
+export { getPageContextInitEnhanced };
+export { getRenderContext };
+import { getErrorPageId } from '../../../shared/error-page.js';
+import { getHtmlString } from '../html/renderHtml.js';
+import { getPageFilesAll } from '../../../shared/getPageFiles.js';
+import { assert, assertUsage, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
+import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
+import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
+import { getGlobalContext } from '../globalContext.js';
+import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
+import { loadPageFilesServerSide } from './loadPageFilesServerSide.js';
+import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
+import { executeOnBeforeRenderHooks } from './executeOnBeforeRenderHook.js';
+import { logRuntimeError } from './loggerRuntime.js';
+import { isNewError } from './isNewError.js';
+import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
+import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
+import pc from '@brillout/picocolors';
+async function renderPageAlreadyRouted(pageContext) {
+    // pageContext._pageId can either be the:
+    //  - ID of the page matching the routing, or the
+    //  - ID of the error page `_error.page.js`.
+    assert(hasProp(pageContext, '_pageId', 'string'));
+    const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
+    assert(isError === (pageContext._pageId === getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs)));
+    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    if (!isError) {
+        await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext));
+    }
+    if (!isError) {
+        await executeOnBeforeRenderHooks(pageContext);
+    }
+    else {
+        try {
+            await executeOnBeforeRenderHooks(pageContext);
+        }
+        catch (err) {
+            if (isNewError(err, pageContext.errorWhileRendering)) {
+                logRuntimeError(err, pageContext._httpRequestId);
+            }
+        }
+    }
+    if (pageContext.isClientSideNavigation) {
+        if (isError) {
+            objectAssign(pageContext, { _isError: true });
+        }
+        const pageContextSerialized = serializePageContextClientSide(pageContext);
+        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        objectAssign(pageContext, { httpResponse });
+        return pageContext;
+    }
+    const renderHookResult = await executeOnRenderHtmlHook(pageContext);
+    if (renderHookResult.htmlRender === null) {
+        objectAssign(pageContext, { httpResponse: null });
+        return pageContext;
+    }
+    else {
+        const { htmlRender, renderHook } = renderHookResult;
+        const httpResponse = await createHttpResponseObject(htmlRender, renderHook, pageContext);
+        objectAssign(pageContext, { httpResponse });
+        return pageContext;
+    }
+}
+async function prerenderPage(pageContext) {
+    objectAssign(pageContext, {
+        isClientSideNavigation: false,
+        _urlHandler: null
+    });
+    /* 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 executeOnBeforeRenderHooks(pageContext);
+    const { htmlRender, renderHook } = await executeOnRenderHtmlHook(pageContext);
+    assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
+    assert(pageContext.isClientSideNavigation === false);
+    const documentHtml = await getHtmlString(htmlRender);
+    assert(typeof documentHtml === 'string');
+    if (!pageContext._usesClientRouter) {
+        return { documentHtml, pageContextSerialized: null, pageContext };
+    }
+    else {
+        const pageContextSerialized = serializePageContextClientSide(pageContext);
+        return { documentHtml, pageContextSerialized, pageContext };
+    }
+}
+async function prerender404Page(renderContext, pageContextInit_) {
+    const errorPageId = getErrorPageId(renderContext.pageFilesAll, renderContext.pageConfigs);
+    if (!errorPageId) {
+        return null;
+    }
+    const pageContext = {
+        _pageId: errorPageId,
+        _httpRequestId: null,
+        _urlRewrite: null,
+        is404: true,
+        routeParams: {},
+        // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
+        _usesClientRouter: false,
+        _routeMatches: []
+    };
+    const pageContextInit = {
+        urlOriginal: '/fake-404-url',
+        ...pageContextInit_
+    };
+    {
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        objectAssign(pageContext, pageContextInitEnhanced);
+    }
+    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    return prerenderPage(pageContext);
+}
+function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+    urlRewrite: null,
+    urlHandler: null,
+    isClientSideNavigation: false
+} } = {}) {
+    assert(pageContextInit.urlOriginal);
+    const globalContext = getGlobalContext();
+    const pageContextInitEnhanced = {
+        ...pageContextInit,
+        _objectCreatedByVike: true,
+        // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
+        // TODO: use GloablContext instead
+        _pageFilesAll: renderContext.pageFilesAll,
+        _pageConfigs: renderContext.pageConfigs,
+        _pageConfigGlobal: renderContext.pageConfigGlobal,
+        _allPageIds: renderContext.allPageIds,
+        _pageRoutes: renderContext.pageRoutes,
+        _onBeforeRouteHook: renderContext.onBeforeRouteHook,
+        _pageContextInit: pageContextInit,
+        _urlRewrite: urlRewrite,
+        _urlHandler: urlHandler,
+        isClientSideNavigation
+    };
+    addUrlComputedProps(pageContextInitEnhanced, !urlComputedPropsNonEnumerable);
+    return pageContextInitEnhanced;
+}
+// TODO: remove getRenderContext() in favor of getGlobalObject() + reloadGlobalContext()
+// TODO: impl GlobalNodeContext + GlobalClientContext + GloablContext, and use GlobalContext instead of RenderContext
+async function getRenderContext() {
+    const globalContext = getGlobalContext();
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    assertNonMixedDesign(pageFilesAll, pageConfigs);
+    const renderContext = {
+        pageFilesAll: pageFilesAll,
+        pageConfigs,
+        pageConfigGlobal,
+        allPageIds: allPageIds,
+        pageRoutes,
+        onBeforeRouteHook
+    };
+    return renderContext;
+}
+function assertNonMixedDesign(pageFilesAll, pageConfigs) {
+    if (pageFilesAll.length === 0 || pageConfigs.length === 0)
+        return;
+    const indent = '- ';
+    const v1Files = unique(pageConfigs
+        .map((p) => Object.values(p.configValues)
+        .map(({ definedAtInfo }) => definedAtInfo)
+        .filter(isNotNullish)
+        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .flat(2));
+    assertUsage(false, [
+        'Mixing the new V1 design with the old V0.4 design is forbidden.',
+        'V1 files:',
+        ...v1Files,
+        'V0.4 files:',
+        ...pageFilesAll.map((p) => indent + p.filePath)
+    ].join('\n'));
+}

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

@@ -0,0 +1,17 @@
+export { renderPage };
+export { renderPage_addWrapper };
+import { HttpResponse } from './renderPage/createHttpResponseObject.js';
+import type { PageContextBuiltInServer } from '../../types/index.js';
+declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
+    pageContextReturn: Awaited<PageContext>;
+    onRequestDone: () => void;
+}>;
+declare const renderPage_addWrapper: (wrapper: typeof renderPage_wrapper) => void;
+declare function renderPage<PageContextUserAdded extends {}, PageContextInit extends {
+    /** @deprecated */
+    url?: string;
+    /** The URL of the HTTP request */
+    urlOriginal: string;
+}>(pageContextInit: PageContextInit): Promise<PageContextInit & {
+    httpResponse: HttpResponse | null;
+} & Partial<PageContextBuiltInServer & PageContextUserAdded>>;