vike 0.4.247-commit-903de25 → 0.4.247-commit-c3d567b

package/dist/types/PageConfig.d.ts

@@ -0,0 +1,153 @@
+export type { PageConfigRuntime };
+export type { PageConfigRuntimeLoaded };
+export type { PageConfigBuildTime };
+export type { PageConfigCommon };
+export type { PageConfigRoute };
+export type { ConfigEnv };
+export type { ConfigEnvInternal };
+export type { PageConfigGlobalRuntime };
+export type { PageConfigGlobalBuildTime };
+export type { ConfigValue };
+export type { ConfigValueStandard };
+export type { ConfigValueCumulative };
+export type { ConfigValueComputed };
+export type { ConfigValues };
+export type { ConfigValueSource };
+export type { ConfigValueSources };
+export type { ConfigValuesComputed };
+export type { DefinedAtData };
+export type { DefinedAtFile };
+export type { DefinedAt };
+export type { DefinedBy };
+export type { DefinedAtFilePath };
+export type { VirtualFileExportsPageEntry };
+import type { ConfigValueSerialized } from '../shared-server-client/page-configs/serialize/PageConfigSerialized.js';
+import type { LocationId } from '../node/vite/shared/resolveVikeConfigInternal/filesystemRouting.js';
+import type { FilePath } from './FilePath.js';
+import type { ConfigDefinitionsInternal } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFilesAll.js';
+import type { ApiOperation } from '../node/api/types.js';
+type PageConfigCommon = {
+    pageId: string;
+} & PageConfigRoute;
+type PageConfigRoute = {
+    isErrorPage: true;
+    routeFilesystem?: undefined;
+} | {
+    isErrorPage?: undefined;
+    routeFilesystem: {
+        routeString: string;
+        definedAtLocation: string;
+    };
+};
+/** Page config, runtime data structure */
+type PageConfigRuntime = PageConfigCommon & {
+    configValues: ConfigValues;
+    /** Load config values that are lazily loaded such as config.Page */
+    loadVirtualFilePageEntry: LoadVirtualFilePageEntry;
+};
+/** Global config that applies to all pages, runtime data structure */
+type PageConfigGlobalRuntime = {
+    configValues: ConfigValues;
+};
+/** Page config, build-time data structure */
+type PageConfigBuildTime = PageConfigCommon & {
+    configDefinitions: ConfigDefinitionsInternal;
+    plusFiles: PlusFile[];
+    configValueSources: ConfigValueSources;
+    configValuesComputed: ConfigValuesComputed;
+};
+/** Global config that applies to all pages, build-time data structure */
+type PageConfigGlobalBuildTime = {
+    configValueSources: ConfigValueSources;
+    configDefinitions: ConfigDefinitionsInternal;
+    configValuesComputed?: undefined;
+};
+/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
+type PageConfigRuntimeLoaded = PageConfigRuntime & {
+    /** Whether loadVirtualFilePageEntry() was called */
+    isPageEntryLoaded: true;
+};
+type LoadVirtualFilePageEntry = () => {
+    moduleId: string;
+    moduleExportsPromise: Promise<VirtualFileExportsPageEntry>;
+};
+type VirtualFileExportsPageEntry = {
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+};
+/** In what environment(s) the config value is loaded.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigEnv = {
+    client?: boolean;
+    server?: boolean;
+    config?: boolean;
+};
+/** For Vike internal use */
+type ConfigEnvInternal = Omit<ConfigEnv, 'client'> & {
+    client?: boolean | 'if-client-routing';
+    /** Load value only in production, or only in development. */
+    production?: boolean;
+};
+type ConfigValueSources = Record<string, // configName
+ConfigValueSource[]>;
+type ConfigValueSource = {
+    configEnv: ConfigEnvInternal;
+    definedAt: DefinedAtFilePath | DefinedBy;
+    plusFile: PlusFile | null;
+    locationId: LocationId;
+    /** Whether the config value is loaded at runtime, for example config.Page or config.onBeforeRender */
+    valueIsLoadedWithImport: boolean;
+    /** Whether the config value is a file path, this is currently only true for +client */
+    valueIsFilePath?: true;
+    /** Whether the config value is defined by a +{configName}.js file */
+    valueIsDefinedByPlusValueFile: boolean;
+} & ({
+    valueIsLoaded: false;
+} | {
+    valueIsLoaded: true;
+    value: unknown;
+});
+type DefinedAtFilePath = DefinedAtFile & FilePath & {
+    fileExportName?: string;
+};
+type ConfigValuesComputed = Record<string, // configName
+{
+    configEnv: ConfigEnvInternal;
+    value: unknown;
+}>;
+type ConfigValues = Record<string, // configName
+ConfigValue>;
+type ConfigValue = ConfigValueStandard | ConfigValueCumulative | ConfigValueComputed;
+/** Defined by a unique source (thus unique file path). */
+type ConfigValueStandard = {
+    type: 'standard';
+    value: unknown;
+    definedAtData: DefinedAt;
+};
+/** Defined by multiple sources (thus multiple file paths). */
+type ConfigValueCumulative = {
+    type: 'cumulative';
+    value: unknown[];
+    definedAtData: DefinedAt[];
+};
+/** Defined by Vike. */
+type ConfigValueComputed = {
+    type: 'computed';
+    value: unknown;
+    definedAtData: null;
+};
+type DefinedAtData = DefinedAt | DefinedAt[] | null;
+type DefinedAt = DefinedAtFile | DefinedBy;
+type DefinedBy = {
+    definedBy: 'cli' | 'env';
+} | {
+    definedBy: 'api';
+    operation: ApiOperation;
+};
+type DefinedAtFile = {
+    filePathToShowToUser: string;
+    fileExportPathToShowToUser: null | string[];
+    definedBy?: undefined;
+};

package/dist/types/PageContext.d.ts

@@ -0,0 +1,314 @@
+export type { PageContext };
+export type { PageContextServer };
+export type { PageContextClient };
+export type { PageContextWithServerRouting };
+export type { PageContextClientWithServerRouting };
+export type { PageContextInternalServer };
+export type { PageContextInternalClient };
+export type { PageContextInternalClient_ServerRouting };
+export type { PageContextInternalClient_ClientRouting };
+export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
+export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
+export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
+import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from '../shared-server-client/getPageContextUrlComputed.js';
+import type { From, PageContextConfig, Source, Sources } from '../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import type { Config } from './Config.js';
+import type { AbortStatusCode } from '../shared-server-client/route/abort.js';
+import type { GlobalContextClient, GlobalContextServer, GlobalContextClientWithServerRouting } from './GlobalContext.js';
+import type { DangerouslyUseInternals } from '../shared-server-client/getProxyForPublicUsage.js';
+import type { PageContextInternalClientAfterRender } from '../client/runtime-client-routing/renderPageClient.js';
+import type { PageContextAfterRender } from '../server/runtime/renderPageServer/renderPageServerAfterRoute.js';
+import type { PageContextPublicProxyServer } from '../server/runtime/renderPageServer/preparePageContextForPublicUsageServer.js';
+import type { PageContextPublicProxyClient } from '../client/runtime-client-routing/preparePageContextForPublicUsageClient.js';
+type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextAfterRender & PageContextPublicProxyServer>;
+} & Vike.PageContext & Vike.PageContextServer;
+type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
+type PageContextClient<Data = unknown> = PageContextBuiltInClientWithClientRouting<Data> & {
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalClient_ClientRouting & PageContextInternalClientAfterRender & PageContextPublicProxyClient>;
+} & Vike.PageContext & Vike.PageContextClient;
+type PageContextWithServerRouting<Data = unknown> = PageContextClientWithServerRouting<Data> | PageContextServer<Data>;
+type PageContextClientWithServerRouting<Data = unknown> = PageContextBuiltInClientWithServerRouting<Data> & Vike.PageContext & Vike.PageContextClient;
+type PageContextBuiltInCommon<Data> = PageContextConfig & {
+    /**
+     * Useful for distinguishing `pageContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/pageContext#typescript
+     */
+    isPageContext: true;
+    /** The `export { Page }` of your `.page.js` file.
+     *
+     * https://vike.dev/Page
+     * https://vike.dev/pageContext#Page
+     */
+    Page: Config['Page'];
+    /** Route Parameters, e.g. `pageContext.routeParams.productId` for a Route String `/product/@productId`.
+     *
+     * https://vike.dev/route-string
+     * https://vike.dev/pageContext#routeParams
+     */
+    routeParams: Record<string, string>;
+    /** The page's data which was fetched using the data() hook.
+     *
+     * https://vike.dev/data
+     * https://vike.dev/pageContext#data
+     */
+    data: Data;
+    /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+     *
+     * https://vike.dev/renderPage
+     */
+    urlOriginal: string;
+    /**
+     * The HTTP request headers.
+     *
+     * As a string object normalized by Vike.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headers
+     */
+    headers: Record<string, string> | null;
+    /**
+     * The HTTP request headers.
+     *
+     * The original object provided by the server.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headersOriginal
+     */
+    headersOriginal?: unknown;
+    /**
+     * The HTTP response headers.
+     *
+     * https://vike.dev/headers#response
+     */
+    headersResponse: Headers;
+    /** If an error occurs, whether the error is a `404 Page Not Found`.
+     *
+     * https://vike.dev/error-page
+     */
+    is404: boolean | null;
+    /**
+     * Whether the page was navigated by the client-side router.
+     *
+     * https://vike.dev/pageContext#isClientSideNavigation
+     */
+    isClientSideNavigation: boolean;
+    /**
+     * The reason why the original page was aborted. Usually used for showing a custom message on the error page.
+     *
+     * https://vike.dev/render
+     * https://vike.dev/pageContext#abortReason
+     */
+    abortReason?: unknown;
+    /**
+     * The status code set by `throw render(abortStatusCode)`.
+     *
+     * https://vike.dev/render
+     * https://vike.dev/pageContext#abortStatusCode
+     */
+    abortStatusCode?: AbortStatusCode;
+    /**
+     * Error that occurred while rendering.
+     *
+     * https://vike.dev/error-tracking
+     * https://vike.dev/pageContext#errorWhileRendering
+     */
+    errorWhileRendering?: unknown;
+    /**
+     * The page's unique identifier.
+     */
+    pageId: string | null;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    from: From;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    source: Source;
+    /** @experimental https://github.com/vikejs/vike/issues/1268 */
+    sources: Sources;
+    /** @deprecated */
+    url: string;
+    /** @deprecated */
+    pageExports: Record<string, unknown>;
+    /**
+     * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
+     *
+     * https://vike.dev/base-url#setup
+     * https://vike.dev/pageContext#isBaseMissing
+     */
+    isBaseMissing?: true;
+};
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
+    /**
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
+     *
+     * https://vike.dev/pageContext#isClientSide
+     */
+    isClientSide: false;
+    /**
+     * Whether the page is being pre-rendered.
+     *
+     * The value is always `false` in development.
+     *
+     * https://vike.dev/pre-rendering
+     * https://vike.dev/pageContext#isPrerendering
+     */
+    isPrerendering: boolean;
+    /**
+     * Runtime information about your app.
+     *
+     * https://vike.dev/getGlobalContext
+     * https://vike.dev/pageContext#globalContext
+     */
+    globalContext: GlobalContextServer;
+    /**
+     * The CSP nonce.
+     *
+     * https://vike.dev/csp
+     */
+    cspNonce: string | null;
+    /**
+     * List of previous `pageContext` aborted by `throw redirect()` or `throw render()` that led to the final rendered page.
+     *
+     * https://vike.dev/pageContext#pageContextsAborted
+     */
+    pageContextsAborted: Partial<PageContextServer<Data>>[];
+    isHydration?: undefined;
+    isBackwardNavigation?: undefined;
+    isHistoryNavigation?: undefined;
+    previousPageContext?: undefined;
+};
+type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & PageContextClientCommon & {
+    /**
+     * Whether the page is the first page rendered.
+     *
+     * https://vike.dev/pageContext#isHydration
+     */
+    isHydration: boolean;
+    /**
+     * Whether the user is navigating backward in history.
+     *
+     * The value is `true` when the user clicks on his browser's backward navigation button, or when invoking `history.back()`.
+     *
+     * https://vike.dev/pageContext#isBackwardNavigation
+     */
+    isBackwardNavigation: boolean | null;
+    /**
+     * Whether the user is navigating back or forward in history.
+     *
+     * The value is `true` when the user clicks on his browser's backward/forward button, or when invoking `history.back()` or `history.forward()`.
+     *
+     * https://vike.dev/pageContext#isHistoryNavigation
+     */
+    isHistoryNavigation: boolean;
+    /**
+     * Upon client-side page navigation, you can use `pageContext.previousPageContext` to access the `pageContext` of the previous page.
+     *
+     * https://vike.dev/pageContext#previousPageContext
+     */
+    previousPageContext: PageContextClient<Data> | null;
+    /**
+     * List of previous `pageContext` aborted by `throw redirect()` or `throw render()` that led to the final rendered page.
+     *
+     * https://vike.dev/pageContext#pageContextsAborted
+     */
+    pageContextsAborted: Partial<PageContextClient<Data>>[];
+    globalContext: GlobalContextClient;
+} & PageContextUrlClient;
+type PageContextBuiltInClientWithServerRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'pageExports' | 'exports' | 'abortReason' | 'pageId' | 'data'> & PageContextClientCommon & {
+    /**
+     * Whether the page is the first page rendered.
+     *
+     * The value is always `true` when using Server Routing.
+     *
+     * https://vike.dev/pageContext#isHydration
+     */
+    isHydration: true;
+    /**
+     * Whether the user is navigating back in history.
+     *
+     * The `isBackwardNavigation` property only works with Client Routing. (The value is always `null` when using Server Routing.)
+     *
+     * https://vike.dev/pageContext#isBackwardNavigation
+     */
+    isBackwardNavigation: null;
+    /**
+     * Whether the user is navigating back or forward in history.
+     *
+     * The `isHistoryNavigation` property only works with Client Routing. (The value is always `null` when using Server Routing.)
+     *
+     * https://vike.dev/pageContext#isHistoryNavigation
+     */
+    isHistoryNavigation: null;
+    globalContext: GlobalContextClientWithServerRouting;
+};
+type PageContextClientCommon = {
+    /**
+     * Whether the environment is the client-side:
+     * - In the browser, the value is `true`.
+     * - Upon SSR and pre-rendering, the value is `false`.
+     *
+     * https://vike.dev/pageContext#isClientSide
+     */
+    isClientSide: true;
+    /**
+     * Whether the page is being pre-rendered.
+     *
+     * The value is always `false` in development.
+     *
+     * https://vike.dev/pre-rendering
+     * https://vike.dev/pageContext#isPrerendering
+     */
+    isPrerendering: false;
+};
+type PageContextInternalServer = Omit<PageContextBuiltInCommon<unknown> & PageContextUrlInternal, 'data' | 'globalContext'>;
+type OnlyUsers = 'data' | 'Page' | 'globalContext';
+type PageContextInternalClient = Omit<PageContextInternalClient_ClientRouting | PageContextInternalClient_ServerRouting, OnlyUsers>;
+type PageContextInternalClient_ClientRouting = Omit<PageContextBuiltInClientWithClientRouting<unknown>, OnlyUsers | 'previousPageContext' | 'pageContextsAborted'> & {
+    previousPageContext: {
+        pageId: string;
+    } | null;
+};
+type PageContextInternalClient_ServerRouting = Omit<PageContextBuiltInClientWithServerRouting<unknown>, OnlyUsers>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInServer } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextServer } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInServer_deprecated<_Page = never> = PageContextBuiltInServer<unknown>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClientWithClientRouting } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextClient } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInClientWithClientRouting_deprecated<_Page = never> = PageContextBuiltInClientWithClientRouting<unknown>;
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClientWithServerRouting } from 'vike/types'
+ *   ```
+ * With:
+ *   ```
+ *   import { PageContextClientWithServerRouting as PageContextClient } from 'vike/types'
+ *   ```
+ *
+ * See https://vike.dev/pageContext#typescript
+ */
+type PageContextBuiltInClientWithServerRouting_deprecated<_Page = never> = PageContextBuiltInClientWithServerRouting<unknown>;

package/dist/types/index.d.ts

@@ -0,0 +1,51 @@
+export type { PageContext, PageContextServer, PageContextClient, PageContextWithServerRouting, PageContextClientWithServerRouting, } from './PageContext.js';
+export type { GlobalContext, GlobalContextServer, GlobalContextClient, GlobalContextClientWithServerRouting, } from './GlobalContext.js';
+export type { PrerenderContextPublic as PrerenderContext } from '../node/prerender/runPrerender.js';
+export type { PageContextBuiltInServer } from './PageContext.js';
+export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';
+export type { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
+export type { Config, ConfigMeta as Meta, ImportString, KeepScrollPosition, } from './Config.js';
+export type { DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, } from './Config.js';
+export type { ConfigResolved } from './Config/ConfigResolved.js';
+export type { ConfigEnv } from './PageConfig.js';
+export type { ConfigDefinition, ConfigEffect, } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+export type { ConfigEntries } from '../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+export type { VikeConfig } from '../node/vite/shared/resolveVikeConfigInternal.js';
+export type { UrlPublic as Url } from '../utils/parseUrl.js';
+export type { InjectFilterEntry } from '../server/runtime/renderPageServer/html/injectAssets/getHtmlTags.js';
+export { defineConfig } from './defineConfig.js';
+export type { _LoadDeclareGlobal__VIKE__IS } from '../node/vite/plugins/pluginReplaceConstantsGlobalThis.js';
+import type { ConfigEnv } from './PageConfig.js';
+/** @deprecated Replace:
+ *   `import type { Env } from 'vike/types'`
+ * With:
+ *   `import type { ConfigEnv } from 'vike/types'`
+ */
+type Env = ConfigEnv;
+export type { Env };
+import type { ConfigEffect } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
+/** @deprecated Replace:
+ *   `import type { Effect } from 'vike/types'`
+ * With:
+ *   `import type { ConfigEffect } from 'vike/types'`
+ */
+type Effect = ConfigEffect;
+export type { Effect };
+import { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
+/** @deprecated Replace:
+ *   `import type { PageContextBuiltInClient } from 'vike/types'`
+ * With:
+ *   `import type { PageContextBuiltInClientWithServerRouting } from 'vike/types'`
+ * Or:
+ *   `import type { PageContextBuiltInClientWithClientRouting } from 'vike/types'`
+ */
+type PageContextBuiltInClient<Page = any> = PageContextBuiltInClientWithServerRouting<Page>;
+export type { PageContextBuiltInClient };
+import { PageContextBuiltInServer } from './PageContext.js';
+/** @deprecated Replace:
+ *   `import type { PageContextBuiltIn } from 'vike/types'`
+ * With:
+ *   `import type { PageContextBuiltInServer } from 'vike/types'`
+ */
+type PageContextBuiltIn<Page = any> = PageContextBuiltInServer<Page>;
+export type { PageContextBuiltIn };

package/dist/utils/PROJECT_VERSION.d.ts

@@ -0,0 +1 @@
+export declare const PROJECT_VERSION: "0.4.247-commit-c3d567b";

package/dist/utils/PROJECT_VERSION.js

@@ -0,0 +1,2 @@
+// Automatically updated by @brillout/release-me
+export const PROJECT_VERSION = '0.4.247-commit-c3d567b';

package/dist/utils/assert.d.ts

@@ -0,0 +1,26 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+export { addOnBeforeAssertLog };
+export { addOnBeforeAssertErr };
+export { isVikeBug };
+export { setAlwaysShowStackTrace };
+declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace, exitOnError }?: {
+    showStackTrace?: true;
+    exitOnError?: boolean;
+}): asserts condition;
+declare function getProjectError(errMsg: string): Error;
+declare function assertWarning(condition: unknown, msg: string, { onlyOnce, showStackTrace }: {
+    onlyOnce: boolean | string;
+    showStackTrace?: true;
+}): void;
+declare function assertInfo(condition: unknown, msg: string, { onlyOnce }: {
+    onlyOnce: boolean;
+}): void;
+declare function addOnBeforeAssertLog(onBeforeAssertLog: () => void): void;
+declare function addOnBeforeAssertErr(onBeforeAssertErr: (err: unknown) => void): void;
+declare function isVikeBug(err: unknown): boolean;
+declare function setAlwaysShowStackTrace(): void;