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

package/dist/esm/shared/page-configs/Config.d.ts

@@ -0,0 +1,131 @@
+export type { Config };
+export type { ConfigBuiltIn };
+export type { ConfigNameBuiltIn };
+export type { ConfigMeta };
+export type { HookName };
+import type { PrefetchStaticAssets } from '../../client/client-routing-runtime/prefetch/getPrefetchSettings.js';
+import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
+import type { ConfigVikeUserProvided } from '../ConfigVike.js';
+import type { Vike, VikePackages } from '../VikeNamespace.js';
+type HookName = 'onHydrationEnd' | 'onBeforePrerender' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onBeforeRoute' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onPrerenderStart' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'render';
+type ConfigNameBuiltInPublic = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender';
+type ConfigNameBuiltInInternal = 'isClientSideRenderable' | 'onBeforeRenderEnv';
+type ConfigNameBuiltIn = ConfigNameBuiltInPublic | ConfigNameBuiltInInternal;
+type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
+/** Page configuration.
+ *
+ * https://vike.dev/config
+ */
+type ConfigBuiltIn = {
+    /** The page's root component */
+    Page?: unknown;
+    /** The page's URL(s).
+     *
+     *  https://vike.dev/route
+     */
+    route?: string | Function | ImportString;
+    /** Protect page(s), e.g. forbid unauthorized access.
+     *
+     *  https://vike.dev/guard
+     */
+    guard?: Function | ImportString;
+    /**
+     * Whether to pre-render the page(s).
+     *
+     * https://vike.dev/pre-rendering
+     */
+    prerender?: boolean | ImportString;
+    /**
+     * Inherit from other configurations.
+     *
+     * https://vike.dev/extends
+     */
+    extends?: Config | Config[] | ImportString | ImportString[];
+    /** Hook called before the page is rendered, usually for fetching data.
+     *
+     *  https://vike.dev/onBeforeRender
+     */
+    onBeforeRender?: Function | ImportString | null;
+    /** Determines what pageContext properties are sent to the client-side.
+     *
+     * https://vike.dev/passToClient
+     */
+    passToClient?: string[] | ImportString;
+    /** Hook called when page is rendered on the client-side.
+     *
+     * https://vike.dev/onRenderClient
+     */
+    onRenderClient?: Function | ImportString;
+    /** Hook called when page is rendered to HTML on the server-side.
+     *
+     * https://vike.dev/onRenderHtml
+     */
+    onRenderHtml?: Function | ImportString;
+    /** Enable async Route Functions.
+     *
+     * https://vike.dev/route-function#async
+     */
+    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportString;
+    /** Change the URL root of Filesystem Routing.
+     *
+     * https://vike.dev/filesystemRoutingRoot
+     */
+    filesystemRoutingRoot?: string | ImportString;
+    /** Page Hook called when pre-rendering starts.
+     *
+     * https://vike.dev/onPrerenderStart
+     */
+    onPrerenderStart?: Function | ImportString;
+    /** Global Hook called before the whole pre-rendering process starts.
+     *
+     * https://vike.dev/onBeforePrerenderStart
+     */
+    onBeforePrerenderStart?: Function | ImportString;
+    /** Hook called before the URL is routed to a page.
+     *
+     * https://vike.dev/onBeforeRoute
+     */
+    onBeforeRoute?: Function | ImportString;
+    /** Hook called after the page is hydrated.
+     *
+     * https://vike.dev/clientRouting
+     */
+    onHydrationEnd?: Function | ImportString;
+    /** Hook called before the user navigates to a new page.
+     *
+     * https://vike.dev/clientRouting
+     */
+    onPageTransitionStart?: Function | ImportString;
+    /** Hook called after the user navigates to a new page.
+     *
+     * https://vike.dev/clientRouting
+     */
+    onPageTransitionEnd?: Function | ImportString;
+    /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
+     *
+     * https://vike.dev/clientRouting
+     */
+    hydrationCanBeAborted?: boolean | ImportString;
+    /** Additional client code.
+     *
+     * https://vike.dev/client
+     */
+    client?: string | ImportString;
+    /** Enable Client Routing.
+     *
+     * https://vike.dev/clientRouting
+     */
+    clientRouting?: boolean | ImportString;
+    /** Create new or modify existing configurations.
+     *
+     * https://vike.dev/meta
+     */
+    meta?: ConfigMeta | ImportString;
+    /** Prefetch links.
+     *
+     * https://vike.dev/clientRouting#link-prefetching
+     */
+    prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+};
+type ConfigMeta = Record<string, ConfigDefinition>;
+type ImportString = `import:${string}`;

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

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

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -0,0 +1,97 @@
+export type { PageConfig };
+export type { PageConfigLoaded };
+export type { PageConfigBuildTime };
+export type { PageConfigCommon };
+export type { ConfigEnvInternal };
+export type { ConfigEnv };
+export type { PageConfigGlobal };
+export type { PageConfigGlobalData };
+export type { ConfigSource };
+export type { ConfigValue };
+export type { ConfigValues };
+export type { ConfigValueSource };
+export type { ConfigValueSources };
+export type { DefinedAtInfo };
+export type { DefinedAtInfoFull };
+type ConfigEnv = 'client-only' | 'server-only' | 'server-and-client' | 'config-only';
+type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
+type PageConfigBuildTime = PageConfigCommon & {
+    configValueSources: ConfigValueSources;
+};
+type PageConfigCommon = {
+    pageId: string;
+    isErrorPage: boolean;
+    routeFilesystem: null | {
+        routeString: string;
+        definedBy: string;
+    };
+    configValues: ConfigValues;
+};
+type ConfigValueSource = {
+    configEnv: ConfigEnvInternal;
+    valueSerialized?: string;
+    value?: unknown;
+    valueIsImportedAtRuntime: boolean;
+    valueIsFilePath?: true;
+} & ({
+    isComputed: false;
+    definedAtInfo: DefinedAtInfo;
+} | {
+    isComputed: true;
+    definedAtInfo: null;
+    valueIsImportedAtRuntime: false;
+});
+type ConfigValueSources = Record<string, ConfigValueSource[]>;
+type ConfigValue = {
+    value: unknown;
+    definedAtInfo: null | DefinedAtInfo;
+};
+type ConfigValues = Record<string, ConfigValue>;
+type DefinedAtInfo = {
+    filePath: string;
+    fileExportPath: string[];
+};
+type DefinedAtInfoFull = {
+    filePathRelativeToUserRootDir?: string;
+    filePathAbsolute: string;
+    fileExportPath: string[];
+};
+type ConfigSource = {
+    configSourceFile: string;
+} & ({
+    configSourceFileExportName: string;
+    configSourceFileDefaultExportKey?: undefined;
+} | {
+    configSourceFileDefaultExportKey: string;
+    configSourceFileExportName?: undefined;
+});
+type PageConfig = PageConfigCommon & {
+    loadConfigValuesAll: LoadConfigValuesAll;
+    isLoaded?: true;
+};
+type PageConfigLoaded = PageConfig & {
+    isLoaded: true;
+};
+type PageConfigGlobalData = {
+    onPrerenderStart: null | ConfigValueSource;
+    onBeforeRoute: null | ConfigValueSource;
+};
+type PageConfigGlobal = {
+    onPrerenderStart: null | (ConfigValueSource & {
+        value: unknown;
+    });
+    onBeforeRoute: null | (ConfigValueSource & {
+        value: unknown;
+    });
+};
+type LoadConfigValuesAll = () => Promise<({
+    configName: string;
+    importFilePath: string;
+} & ({
+    isPlusFile: true;
+    importFileExports: Record<string, unknown>;
+} | {
+    isPlusFile: false;
+    importFileExportName: string;
+    importFileExportValue: unknown;
+}))[]>;

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

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

package/dist/esm/shared/page-configs/findPageConfig.d.ts

@@ -0,0 +1,3 @@
+export { findPageConfig };
+import type { PageConfig } from './PageConfig.js';
+declare function findPageConfig(pageConfigs: PageConfig[], pageId: string): null | PageConfig;

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

@@ -0,0 +1,8 @@
+export { findPageConfig };
+import { assert } from '../utils.js';
+function findPageConfig(pageConfigs, pageId) {
+    const result = pageConfigs.filter((p) => p.pageId === pageId);
+    assert(result.length <= 1);
+    const pageConfig = result[0] ?? null;
+    return pageConfig;
+}

package/dist/esm/shared/page-configs/getExportPath.d.ts

@@ -0,0 +1,2 @@
+export { getExportPath };
+declare function getExportPath(fileExportPath: string[]): null | string;

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

@@ -0,0 +1,28 @@
+export { getExportPath };
+import { assert } from '../utils.js';
+// TODO: return null instead of 'export default'
+//  - Also return null insead of 'export *'?
+function getExportPath(fileExportPath) {
+    let prefix = '';
+    let suffix = '';
+    let [exportName, ...exportObjectPath] = fileExportPath;
+    if (!exportName)
+        return null;
+    if (exportName === '*') {
+        assert(exportObjectPath.length === 0);
+        return 'export *';
+    }
+    else if (exportName === 'default') {
+        prefix = 'export default';
+    }
+    else {
+        prefix = 'export';
+        exportObjectPath = [exportName, ...exportObjectPath];
+    }
+    exportObjectPath.forEach((prop) => {
+        prefix = `${prefix} { ${prop}`;
+        suffix = ` }${suffix}`;
+    });
+    const exportPath = prefix + suffix;
+    return exportPath;
+}

package/dist/esm/shared/page-configs/loadPageCode.d.ts

@@ -0,0 +1,3 @@
+export { loadPageCode };
+import type { PageConfig, PageConfigLoaded } from './PageConfig.js';
+declare function loadPageCode(pageConfig: PageConfig, isDev: boolean): Promise<PageConfigLoaded>;

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

@@ -0,0 +1,57 @@
+export { loadPageCode };
+import { assert, assertDefaultExportUnknown, assertUsage, objectAssign } from '../utils.js';
+import pc from '@brillout/picocolors';
+async function loadPageCode(pageConfig, isDev) {
+    if (pageConfig.isLoaded &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const codeFiles = await pageConfig.loadConfigValuesAll();
+    // TODO: remove?
+    // pageConfig.configValuesOld = pageConfig.configValuesOld.filter((val) => !val.definedByCodeFile)
+    const addConfigValue = (configName, value, filePath, exportName) => {
+        /* TODO
+        assert(!isAlreadyDefined(val.configName), val.configName) // Conflicts are resolved upstream
+        */
+        pageConfig.configValues[configName] = {
+            value,
+            definedAtInfo: {
+                filePath,
+                fileExportPath: [exportName]
+            }
+            /* TODO: remove?
+            definedByCodeFile: true
+            */
+        };
+        assertIsNotNull(value, configName, filePath);
+    };
+    codeFiles.forEach((codeFile) => {
+        if (codeFile.isPlusFile) {
+            const { importFileExports, importFilePath } = codeFile;
+            if (codeFile.configName !== 'client') {
+                assertDefaultExportUnknown(importFileExports, importFilePath);
+            }
+            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : codeFile.configName;
+                if (isSideExport && configName in pageConfig.configValues) {
+                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
+                    // Side-exports have the lowest priority.
+                    return;
+                }
+                addConfigValue(configName, exportValue, importFilePath, exportName);
+            });
+        }
+        else {
+            const { configName, importFilePath, importFileExportValue, importFileExportName } = codeFile;
+            addConfigValue(configName, importFileExportValue, importFilePath, importFileExportName);
+        }
+    });
+    objectAssign(pageConfig, { isLoaded: true });
+    return pageConfig;
+}
+function assertIsNotNull(configValue, configName, importFilePath) {
+    assert(!importFilePath.includes('+config.'));
+    assertUsage(configValue !== null, `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.h.js file instead of ${importFilePath}`);
+}

package/dist/esm/shared/page-configs/utils.d.ts

@@ -0,0 +1,28 @@
+export { getConfigValue };
+export { getPageConfig };
+export { getConfigDefinedAtString };
+export { getConfigDefinedAtInfo };
+export { getDefinedAtString };
+import type { DefinedAtInfo, PageConfig, PageConfigCommon } from './PageConfig.js';
+import type { ConfigNameBuiltIn } from './Config.js';
+type ConfigName = ConfigNameBuiltIn;
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | {
+    value: string;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'boolean'): null | {
+    value: boolean;
+};
+declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName): null | {
+    value: unknown;
+};
+declare function getConfigDefinedAtInfo(pageConfig: PageConfigCommon, configName: ConfigName): DefinedAtInfo;
+declare function getPageConfig(pageId: string, pageConfigs: PageConfig[]): PageConfig;
+type ConfigDefinedAtUppercase<ConfigName extends string> = `Config ${ConfigName}${string}`;
+type ConfigDefinedAtLowercase<ConfigName extends string> = `config ${ConfigName}${string}`;
+declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAtInfo }: {
+    definedAtInfo: null | DefinedAtInfo;
+}, sentenceBegin: true, append?: 'effect'): ConfigDefinedAtUppercase<ConfigName>;
+declare function getConfigDefinedAtString<ConfigName extends string>(configName: ConfigName, { definedAtInfo }: {
+    definedAtInfo: null | DefinedAtInfo;
+}, sentenceBegin: false, append?: 'effect'): ConfigDefinedAtLowercase<ConfigName>;
+declare function getDefinedAtString(definedAtInfo: DefinedAtInfo, append?: 'effect'): string;

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

@@ -0,0 +1,74 @@
+export { getConfigValue };
+export { getPageConfig };
+export { getConfigDefinedAtString };
+export { getConfigDefinedAtInfo };
+export { getDefinedAtString };
+import { assert, assertUsage, getValuePrintable } from '../utils.js';
+import pc from '@brillout/picocolors';
+import { getExportPath } from './getExportPath.js';
+// prettier-ignore
+function getConfigValue(pageConfig, configName, type) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    if (configValue === null)
+        return null;
+    const { value, definedAtInfo } = configValue;
+    if (type)
+        assertConfigValueType(value, type, configName, definedAtInfo);
+    return { value };
+}
+function getConfigDefinedAtInfo(pageConfig, configName) {
+    const configValue = getConfigValueEntry(pageConfig, configName);
+    // We assume the caller to have ensured that the config value exists prior to calling getConfigDefinedAtInfo()
+    assert(configValue);
+    const { definedAtInfo } = configValue;
+    // definedAtInfo is available only for config values that aren't:
+    //  - computed, nor
+    //  - cumulative
+    assert(definedAtInfo);
+    return definedAtInfo;
+}
+function getConfigValueEntry(pageConfig, configName) {
+    const configValue = pageConfig.configValues[configName];
+    if (!configValue)
+        return null;
+    const { value, definedAtInfo } = configValue;
+    // Enable users to suppress global config values by setting the local config value to null
+    if (value === null)
+        return null;
+    return { value, definedAtInfo };
+}
+function getPageConfig(pageId, pageConfigs) {
+    const pageConfig = pageConfigs.find((p) => p.pageId === pageId);
+    assert(pageConfigs.length > 0);
+    assert(pageConfig);
+    return pageConfig;
+}
+function assertConfigValueType(value, type, configName, definedAtInfo) {
+    assert(value !== null);
+    const typeActual = typeof value;
+    if (typeActual === type)
+        return;
+    const valuePrintable = getValuePrintable(value);
+    const problem = valuePrintable !== null ? `value ${pc.cyan(valuePrintable)}` : `type ${pc.cyan(typeActual)}`;
+    const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
+    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: is should be a ${pc.cyan(type)} instead`);
+}
+function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
+    let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)}`;
+    if (definedAtInfo !== null) {
+        configDefinedAt = `${configDefinedAt} defined at ${getDefinedAtString(definedAtInfo, append)}`;
+    }
+    return configDefinedAt;
+}
+function getDefinedAtString(definedAtInfo, append) {
+    const { filePath, fileExportPath } = definedAtInfo;
+    let definedAt = filePath;
+    const exportPath = getExportPath(fileExportPath);
+    if (exportPath) {
+        definedAt = `${definedAt} > ${pc.cyan(exportPath)}`;
+    }
+    if (append) {
+        definedAt = `${definedAt} > (${pc.blue(append)})`;
+    }
+    return definedAt;
+}

package/dist/esm/shared/route/abort.d.ts

@@ -0,0 +1,103 @@
+export { redirect };
+export { render };
+export { RenderErrorPage };
+export { isAbortError };
+export { isAbortPageContext };
+export { logAbortErrorHandled };
+export { getPageContextFromAllRewrites };
+export { AbortRender };
+export { assertNoInfiniteAbortLoop };
+export type { RedirectStatusCode };
+export type { AbortStatusCode };
+export type { ErrorAbort };
+export type { PageContextFromRewrite };
+export type { UrlRedirect };
+type RedirectStatusCode = number & Parameters<typeof redirect>[1];
+type AbortStatusCode = number & Parameters<typeof render>[0];
+type UrlRedirect = {
+    url: string;
+    statusCode: RedirectStatusCode;
+};
+type AbortRedirect = Error;
+type AbortReason = Required<({
+    abortReason?: unknown;
+} & Vike.PageContext)['abortReason']>;
+/**
+ * Abort the rendering of the current page, and redirect the user to another URL instead.
+ *
+ * https://vike.dev/redirect
+ *
+ * @param url The URL to redirect to.
+ * @param statusCode By default a temporary redirection (`302`) is performed. For permanent redirections (`301`), use `config.redirects` https://vike.dev/redirects instead or, alternatively, set the `statusCode` argument to `301`.
+ */
+declare function redirect(url: `/${string}` | `https://${string}` | `http://${string}`, statusCode?: 301 | 302): AbortRedirect;
+/**
+ * Abort the rendering of the current page, and render the error page instead.
+ *
+ * https://vike.dev/render
+ *
+ * @param abortStatusCode
+ * One of the following:
+ *   `401` Unauthorized (user isn't logged in)
+ *   `403` Forbidden (user is logged in but isn't allowed)
+ *   `404` Not Found
+ *   `410` Gone (use this instead of `404` if the page existed in the past, see https://github.com/vikejs/vike/issues/1097#issuecomment-1695260887)
+ *   `429` Too Many Requests (rate limiting)
+ *   `500` Internal Server Error (app has a bug)
+ *   `503` Service Unavailable (server is overloaded, a third-party API isn't responding)
+ * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503, abortReason?: AbortReason): Error;
+/**
+ * Abort the rendering of the current page, and render another page instead.
+ *
+ * https://vike.dev/render
+ *
+ * @param url The URL to render.
+ * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
+ */
+declare function render(url: `/${string}`, abortReason?: AbortReason): Error;
+type AbortCall = `throw redirect(${string})` | `throw render(${string})` | `throw RenderErrorPage()`;
+type PageContextAbort = {
+    _abortCall: AbortCall;
+} & (({
+    _abortCaller: 'throw redirect()';
+    _urlRedirect: UrlRedirect;
+} & Omit<AbortUndefined, '_urlRedirect'>) | ({
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    _urlRewrite: string;
+} & Omit<AbortUndefined, '_urlRewrite'>) | ({
+    _abortCaller: 'throw render()' | 'throw RenderErrorPage()';
+    abortReason: undefined | unknown;
+    abortStatusCode: number;
+} & Omit<AbortUndefined, 'abortStatusCode'>));
+type AbortUndefined = {
+    _urlRedirect?: undefined;
+    _urlRewrite?: undefined;
+    abortStatusCode?: undefined;
+};
+declare function AbortRender(pageContextAbort: PageContextAbort): Error;
+/**
+ * @deprecated Use `throw render()` or `throw redirect()` instead, see https://vike.dev/render'
+ */
+declare function RenderErrorPage({ pageContext }?: {
+    pageContext?: Record<string, unknown>;
+}): Error;
+type ErrorAbort = {
+    _pageContextAbort: PageContextAbort;
+};
+declare function isAbortError(thing: unknown): thing is ErrorAbort;
+declare function isAbortPageContext(pageContext: Record<string, unknown>): pageContext is PageContextAbort;
+declare function logAbortErrorHandled(err: ErrorAbort, isProduction: boolean, pageContext: {
+    urlOriginal: string;
+    _urlRewrite: null | string;
+}): void;
+type PageContextFromRewrite = {
+    _urlRewrite: string;
+} & Record<string, unknown>;
+type PageContextFromAllRewrites = {
+    _urlRewrite: null | string;
+} & Record<string, unknown>;
+declare function getPageContextFromAllRewrites(pageContextsFromRewrite: PageContextFromRewrite[]): PageContextFromAllRewrites;
+declare function assertNoInfiniteAbortLoop(rewriteCount: number, redirectCount: number): void;