vike 0.4.142 → 0.4.143-commit-dc6fea0

package/dist/esm/shared/getPageFiles/parsePageConfigsSerialized.js

@@ -0,0 +1,59 @@
+export { parsePageConfigsSerialized };
+import { parse } from '@brillout/json-serializer/parse';
+import { parseConfigValuesImported } from '../page-configs/parseConfigValuesImported.js';
+import { assert, assertUsage, isCallable } from '../utils.js';
+function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
+        const configValues = {};
+        {
+            const { configValuesSerialized } = pageConfigSerialized;
+            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+                {
+                    const { valueSerialized, definedAtInfo } = configValueSeriliazed;
+                    assert(valueSerialized);
+                    assert(!configValues[configName]);
+                    configValues[configName] = {
+                        value: parse(valueSerialized),
+                        definedAtInfo
+                    };
+                }
+            });
+        }
+        {
+            const { configValuesImported } = pageConfigSerialized;
+            const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+            Object.assign(configValues, configValuesAddendum);
+        }
+        const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
+        assertRouteConfigValue(configValues);
+        return {
+            pageId,
+            isErrorPage,
+            routeFilesystem,
+            configValues,
+            loadConfigValuesAll
+        };
+    });
+    const pageConfigGlobal = { configValues: {} };
+    {
+        const configValuesAddendum = parseConfigValuesImported(pageConfigGlobalSerialized.configValuesImported);
+        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+    }
+    return { pageConfigs, pageConfigGlobal };
+}
+function assertRouteConfigValue(configValues) {
+    if (!configValues.route)
+        return;
+    const { value, definedAtInfo } = configValues.route;
+    const configValueType = typeof value;
+    assert(definedAtInfo);
+    assertUsage(configValueType === 'string' || isCallable(value), `${definedAtInfo.filePath} has an invalid type '${configValueType}': it should be a string or a function instead, see https://vike.dev/route`);
+    /* We don't use assertRouteString() in order to avoid unnecessarily bloating the client-side bundle when using Server Routing:
+    * - When using Server Routing, this file is loaded => loading assertRouteString() would bloat the client bundle.
+    * - assertRouteString() is already called on the server-side
+    * - When using Server Routing, client-side validation is superfluous as Route Strings only need to be validated on the server-side
+   if (typeof configValue === 'string') {
+     assertRouteString(configValue, `${configElement.configDefinedAt} defines an`)
+   }
+   */
+}

package/dist/esm/shared/getPageFiles/setPageFiles.d.ts

@@ -2,12 +2,12 @@ export { setPageFiles };
 export { setPageFilesAsync };
 export { getPageFilesAll };
 import type { PageFile } from './getPageFileObject.js';
-import type { PageConfig, PageConfigGlobal } from '../page-configs/PageConfig.js';
+import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
 declare function setPageFiles(pageFilesExports: unknown): void;
 declare function setPageFilesAsync(getPageFilesExports: () => Promise<unknown>): void;
 declare function getPageFilesAll(isClientSide: boolean, isProduction?: boolean): Promise<{
     pageFilesAll: PageFile[];
     allPageIds: string[];
-    pageConfigs: PageConfig[];
-    pageConfigGlobal: PageConfigGlobal;
+    pageConfigs: PageConfigRuntime[];
+    pageConfigGlobal: PageConfigGlobalRuntime;
 }>;

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

@@ -3,15 +3,202 @@ export type { ConfigBuiltIn };
 export type { ConfigNameBuiltIn };
 export type { ConfigMeta };
 export type { HookName };
+export type { GuardAsync };
+export type { GuardSync };
+export type { OnBeforePrerenderStartAsync };
+export type { OnBeforePrerenderStartSync };
+export type { OnBeforeRenderAsync };
+export type { OnBeforeRenderSync };
+export type { OnBeforeRouteAsync };
+export type { OnBeforeRouteSync };
+export type { OnHydrationEndAsync };
+export type { OnHydrationEndSync };
+export type { OnPageTransitionEndAsync };
+export type { OnPageTransitionEndSync };
+export type { OnPageTransitionStartAsync };
+export type { OnPageTransitionStartSync };
+export type { OnPrerenderStartAsync };
+export type { OnPrerenderStartSync };
+export type { OnRenderClientAsync };
+export type { OnRenderClientSync };
+export type { OnRenderHtmlAsync };
+export type { OnRenderHtmlSync };
+export type { RouteAsync };
+export type { RouteSync };
 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 { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { ConfigVikeUserProvided } from '../ConfigVike.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
+import type { PageContextClient, PageContextServer } from '../types.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 ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientSideRenderable' | 'onBeforeRenderEnv';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte);
+/** Protect page(s), e.g. forbid unauthorized access.
+ *
+ *  https://vike.dev/guard
+ */
+type GuardAsync = (pageContext: PageContextServer) => Promise<void>;
+/** Protect page(s), e.g. forbid unauthorized access.
+ *
+ *  https://vike.dev/guard
+ */
+type GuardSync = (pageContext: PageContextServer) => void;
+/** Global Hook called before the whole pre-rendering process starts.
+ *
+ * https://vike.dev/onBeforePrerenderStart
+ */
+type OnBeforePrerenderStartAsync = () => Promise<(string | {
+    url: string;
+    pageContext: Partial<Vike.PageContext>;
+})[]>;
+/** Global Hook called before the whole pre-rendering process starts.
+ *
+ * https://vike.dev/onBeforePrerenderStart
+ */
+type OnBeforePrerenderStartSync = () => (string | {
+    url: string;
+    pageContext: Partial<Vike.PageContext>;
+})[];
+/** Hook called before the page is rendered, usually for fetching data.
+ *
+ *  https://vike.dev/onBeforeRender
+ */
+type OnBeforeRenderAsync = (pageContext: PageContextServer) => Promise<{
+    pageContext: Partial<Vike.PageContext>;
+} | void>;
+/** Hook called before the page is rendered, usually for fetching data.
+ *
+ *  https://vike.dev/onBeforeRender
+ */
+type OnBeforeRenderSync = (pageContext: PageContextServer) => {
+    pageContext: Partial<Vike.PageContext>;
+} | void;
+/** Hook called before the URL is routed to a page.
+ *
+ * https://vike.dev/onBeforeRoute
+ */
+type OnBeforeRouteAsync = (pageContext: PageContextServer) => Promise<{
+    pageContext: Partial<{
+        /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+         *
+         * https://vike.dev/renderPage
+         */
+        urlOriginal: string;
+    } | Vike.PageContext>;
+}>;
+/** Hook called before the URL is routed to a page.
+ *
+ * https://vike.dev/onBeforeRoute
+ */
+type OnBeforeRouteSync = (pageContext: PageContextServer) => {
+    pageContext: Partial<{
+        /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+         *
+         * https://vike.dev/renderPage
+         */
+        urlOriginal: string;
+    } | Vike.PageContext>;
+};
+/** Hook called after the page is hydrated.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnHydrationEndAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called after the page is hydrated.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnHydrationEndSync = (pageContext: PageContextClient) => void;
+/** Hook called after the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionEndAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called after the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionEndSync = (pageContext: PageContextClient) => void;
+/** Hook called before the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionStartAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called before the user navigates to a new page.
+ *
+ * https://vike.dev/clientRouting
+ */
+type OnPageTransitionStartSync = (pageContext: PageContextClient) => void;
+/** Page Hook called when pre-rendering starts.
+ *
+ * https://vike.dev/onPrerenderStart
+ */
+type OnPrerenderStartAsync = (prerenderContext: {
+    pageContexts: PageContextServer[];
+}) => Promise<{
+    prerenderContext: {
+        pageContexts: PageContextServer[];
+    };
+}>;
+/** Page Hook called when pre-rendering starts.
+ *
+ * https://vike.dev/onPrerenderStart
+ */
+type OnPrerenderStartSync = (prerenderContext: {
+    pageContexts: PageContextServer[];
+}) => {
+    prerenderContext: {
+        pageContexts: PageContextServer[];
+    };
+};
+/** Hook called when page is rendered on the client-side.
+ *
+ * https://vike.dev/onRenderClient
+ */
+type OnRenderClientAsync = (pageContext: PageContextClient) => Promise<void>;
+/** Hook called when page is rendered on the client-side.
+ *
+ * https://vike.dev/onRenderClient
+ */
+type OnRenderClientSync = (pageContext: PageContextClient) => void;
+/** Hook called when page is rendered to HTML on the server-side.
+ *
+ * https://vike.dev/onRenderHtml
+ */
+type OnRenderHtmlAsync = (pageContext: PageContextServer) => Promise<DocumentHtml | {
+    documentHtml: DocumentHtml;
+    pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
+}>;
+/** Hook called when page is rendered to HTML on the server-side.
+ *
+ * https://vike.dev/onRenderHtml
+ */
+type OnRenderHtmlSync = (pageContext: PageContextServer) => DocumentHtml | {
+    documentHtml: DocumentHtml;
+    pageContext: OnRenderHtmlPageContextReturn | (() => Promise<OnRenderHtmlPageContextReturn> | OnRenderHtmlPageContextReturn);
+};
+type OnRenderHtmlPageContextReturn = Partial<Vike.PageContext & {
+    /** See https://vike.dev/stream */
+    enableEagerStreaming: boolean;
+}>;
+/** @deprecated Use a sync route() with an async guard() instead */
+type RouteAsync = (pageContext: PageContextServer | PageContextClient) => Promise<{
+    routeParams?: Record<string, string>;
+    precedence?: number;
+} | boolean>;
+/** The page's URL(s).
+ *
+ *  https://vike.dev/route
+ */
+type RouteSync = (pageContext: PageContextServer | PageContextClient) => {
+    routeParams?: Record<string, string>;
+    precedence?: number;
+} | boolean;
+/** The page's URL(s).
+ *
+ *  https://vike.dev/route
+ */
 /** Page configuration.
  *
  * https://vike.dev/config
@@ -23,12 +210,12 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: string | Function | ImportString;
+    route?: string | RouteAsync | RouteSync | ImportString;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard
      */
-    guard?: Function | ImportString;
+    guard?: GuardAsync | GuardSync | ImportString;
     /**
      * Whether to pre-render the page(s).
      *
@@ -45,7 +232,7 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/onBeforeRender
      */
-    onBeforeRender?: Function | ImportString | null;
+    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
     /** Determines what pageContext properties are sent to the client-side.
      *
      * https://vike.dev/passToClient
@@ -55,12 +242,12 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/onRenderClient
      */
-    onRenderClient?: Function | ImportString;
+    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportString;
     /** Hook called when page is rendered to HTML on the server-side.
      *
      * https://vike.dev/onRenderHtml
      */
-    onRenderHtml?: Function | ImportString;
+    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportString;
     /** Enable async Route Functions.
      *
      * https://vike.dev/route-function#async
@@ -75,32 +262,32 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/onPrerenderStart
      */
-    onPrerenderStart?: Function | ImportString;
+    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportString;
     /** Global Hook called before the whole pre-rendering process starts.
      *
      * https://vike.dev/onBeforePrerenderStart
      */
-    onBeforePrerenderStart?: Function | ImportString;
+    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportString;
     /** Hook called before the URL is routed to a page.
      *
      * https://vike.dev/onBeforeRoute
      */
-    onBeforeRoute?: Function | ImportString;
+    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
     /** Hook called after the page is hydrated.
      *
      * https://vike.dev/clientRouting
      */
-    onHydrationEnd?: Function | ImportString;
+    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
     /** Hook called before the user navigates to a new page.
      *
      * https://vike.dev/clientRouting
      */
-    onPageTransitionStart?: Function | ImportString;
+    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
     /** Hook called after the user navigates to a new page.
      *
      * https://vike.dev/clientRouting
      */
-    onPageTransitionEnd?: Function | ImportString;
+    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
      * https://vike.dev/clientRouting

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

@@ -1,35 +1,70 @@
-export type { PageConfig };
-export type { PageConfigLoaded };
+export type { PageConfigRuntime };
+export type { PageConfigRuntimeLoaded };
+export type { PageConfigRuntimeSerialized };
 export type { PageConfigBuildTime };
-export type { PageConfigCommon };
 export type { ConfigEnvInternal };
 export type { ConfigEnv };
-export type { PageConfigGlobal };
-export type { PageConfigGlobalData };
+export type { PageConfigGlobalRuntime };
+export type { PageConfigGlobalRuntimeSerialized };
+export type { PageConfigGlobalBuildTime };
 export type { ConfigSource };
 export type { ConfigValue };
+export type { ConfigValueSerialized };
+export type { ConfigValueImported };
 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 = {
+type PageConfigBase = {
     pageId: string;
-    isErrorPage: boolean;
-    routeFilesystem: null | {
+    isErrorPage?: true;
+    routeFilesystem?: {
         routeString: string;
         definedBy: string;
     };
+};
+/** Page config data structure available and used at runtime */
+type PageConfigRuntime = PageConfigBase & {
+    /** Loaded config values */
+    configValues: ConfigValues;
+    /** Load config values that are lazily loaded such as config.Page */
+    loadConfigValuesAll: LoadConfigValuesAll;
+};
+/** Same as PageConfigRuntime but also contains all lazily loaded config values such as config.Page */
+type PageConfigRuntimeLoaded = PageConfigRuntime & {
+    /** Whether loadConfigValuesAll() was called */
+    isLoaded: true;
+};
+/** page config data structure available and used at build-time */
+type PageConfigBuildTime = PageConfigBase & {
+    configValues: ConfigValues;
+    configValueSources: ConfigValueSources;
+};
+/** page config data structure serialized in virtual files: parsing it results in PageConfigRuntime */
+type PageConfigRuntimeSerialized = PageConfigBase & {
+    /** Config values that are loaded eagerly and serializable such as config.passToClient */
+    configValuesSerialized: Record<string, ConfigValueSerialized>;
+    /** Config values imported eagerly such as config.route */
+    configValuesImported: ConfigValueImported[];
+    /** Config values imported lazily such as config.page */
+    loadConfigValuesAll: LoadConfigValuesAll;
+};
+/** page config that applies to all pages */
+type PageConfigGlobalRuntime = {
     configValues: ConfigValues;
 };
+type PageConfigGlobalRuntimeSerialized = {
+    configValuesImported: ConfigValueImported[];
+};
+type PageConfigGlobalBuildTime = {
+    configValueSources: ConfigValueSources;
+};
+type ConfigEnv = 'client-only' | 'server-only' | 'server-and-client' | 'config-only';
+/** For Vike internal use */
+type ConfigEnvInternal = ConfigEnv | '_routing-eager' | '_routing-lazy';
 type ConfigValueSource = {
     configEnv: ConfigEnvInternal;
-    valueSerialized?: string;
     value?: unknown;
     valueIsImportedAtRuntime: boolean;
     valueIsFilePath?: true;
@@ -46,6 +81,10 @@ type ConfigValue = {
     value: unknown;
     definedAtInfo: null | DefinedAtInfo;
 };
+type ConfigValueSerialized = {
+    valueSerialized: string;
+    definedAtInfo: null | DefinedAtInfo;
+};
 type ConfigValues = Record<string, ConfigValue>;
 type DefinedAtInfo = {
     filePath: string;
@@ -65,33 +104,15 @@ type ConfigSource = {
     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<({
+type LoadConfigValuesAll = () => Promise<ConfigValueImported[]>;
+type ConfigValueImported = {
     configName: string;
-    importFilePath: string;
+    importPath: string;
 } & ({
-    isPlusFile: true;
+    isValueFile: true;
     importFileExports: Record<string, unknown>;
 } | {
-    isPlusFile: false;
-    importFileExportName: string;
+    isValueFile: false;
+    exportName: string;
     importFileExportValue: unknown;
-}))[]>;
+});

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

@@ -0,0 +1,6 @@
+export { assertExportsOfValueFile };
+export { assertExportsOfConfigFile };
+declare function assertExportsOfValueFile(fileExports: Record<string, unknown>, filePathToShowToUser: string, configName: string): void;
+declare function assertExportsOfConfigFile(fileExports: Record<string, unknown>, filePathToShowToUser: string): asserts fileExports is {
+    default: Record<string, unknown>;
+};

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

@@ -0,0 +1,54 @@
+export { assertExportsOfValueFile };
+export { assertExportsOfConfigFile };
+import { assert, assertUsage, assertWarning, isObject } from '../utils.js';
+import pc from '@brillout/picocolors';
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertExportsOfValueFile(fileExports, filePathToShowToUser, configName) {
+    assertExports(fileExports, filePathToShowToUser, configName);
+}
+function assertExportsOfConfigFile(fileExports, filePathToShowToUser) {
+    assertExports(fileExports, filePathToShowToUser);
+    const exportDefault = fileExports.default;
+    assertUsage(isObject(exportDefault), `The ${pc.cyan('export default')} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+function assertExports(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default' &&
+        // !!configName => isValueFile
+        e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsRelevant.length === 1) {
+            return;
+        }
+        else {
+            assert(exportsRelevant.length === 0);
+            let errMsg = `${filePathToShowToUser} doesn't export any value, but it should have a ${pc.cyan('export default')}`;
+            if (configName)
+                errMsg += ` or ${pc.cyan(`export { ${configName} }`)}`;
+            assertUsage(false, errMsg);
+        }
+    }
+    else {
+        // !configName => isConfigFile
+        if (!configName) {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            assertUsage(false, `${filePathToShowToUser} replace ${pc.cyan(`export { ${exportsInvalidStr} }`)} with ${pc.cyan(`export default { ${exportsInvalidStr} }`)}`);
+        }
+        // !!configName => isValueFile
+        else {
+            if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+                return;
+            exportsInvalid.forEach((exportInvalid) => {
+                assertWarning(false, `${filePathToShowToUser} should have only a single export: move ${pc.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+export { loadConfigValues };
+import { objectAssign } from '../utils.js';
+import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+async function loadConfigValues(pageConfig, isDev) {
+    if ('isLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const configValuesImported = await pageConfig.loadConfigValuesAll();
+    const configValuesAddendum = parseConfigValuesImported(configValuesImported);
+    Object.assign(pageConfig.configValues, configValuesAddendum);
+    objectAssign(pageConfig, { isLoaded: true });
+    return pageConfig;
+}

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

@@ -0,0 +1,3 @@
+export { parseConfigValuesImported };
+import type { ConfigValueImported, ConfigValues } from './PageConfig.js';
+declare function parseConfigValuesImported(configValuesImported: ConfigValueImported[]): ConfigValues;

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

@@ -0,0 +1,44 @@
+export { parseConfigValuesImported };
+import { assert, assertUsage } from '../utils.js';
+import { assertExportsOfValueFile } from './assertExports.js';
+import pc from '@brillout/picocolors';
+function parseConfigValuesImported(configValuesImported) {
+    const configValues = {};
+    const addConfigValue = (configName, value, filePath, exportName) => {
+        configValues[configName] = {
+            value,
+            definedAtInfo: {
+                filePath,
+                fileExportPath: [exportName]
+            }
+        };
+        assertIsNotNull(value, configName, filePath);
+    };
+    configValuesImported.forEach((configValueLoaded) => {
+        if (configValueLoaded.isValueFile) {
+            const { importFileExports, importPath, configName } = configValueLoaded;
+            if (configName !== 'client') {
+                assertExportsOfValueFile(importFileExports, importPath, configName);
+            }
+            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
+                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
+                const configName = isSideExport ? exportName : configValueLoaded.configName;
+                if (isSideExport && configName in 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, importPath, exportName);
+            });
+        }
+        else {
+            const { configName, importPath, importFileExportValue, exportName } = configValueLoaded;
+            addConfigValue(configName, importFileExportValue, importPath, exportName);
+        }
+    });
+    return configValues;
+}
+function assertIsNotNull(configValue, configName, importPath) {
+    assert(!importPath.includes('+config.'));
+    assertUsage(configValue !== null, `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.h.js file instead of ${importPath}`);
+}

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

@@ -3,8 +3,9 @@ export { getPageConfig };
 export { getConfigDefinedAtString };
 export { getConfigDefinedAtInfo };
 export { getDefinedAtString };
-import type { DefinedAtInfo, PageConfig, PageConfigCommon } from './PageConfig.js';
+import type { DefinedAtInfo, PageConfigRuntime, PageConfigBuildTime } from './PageConfig.js';
 import type { ConfigNameBuiltIn } from './Config.js';
+type PageConfigCommon = PageConfigRuntime | PageConfigBuildTime;
 type ConfigName = ConfigNameBuiltIn;
 declare function getConfigValue(pageConfig: PageConfigCommon, configName: ConfigName, type: 'string'): null | {
     value: string;
@@ -16,7 +17,7 @@ declare function getConfigValue(pageConfig: PageConfigCommon, configName: Config
     value: unknown;
 };
 declare function getConfigDefinedAtInfo(pageConfig: PageConfigCommon, configName: ConfigName): DefinedAtInfo;
-declare function getPageConfig(pageId: string, pageConfigs: PageConfig[]): PageConfig;
+declare function getPageConfig(pageId: string, pageConfigs: PageConfigRuntime[]): PageConfigRuntime;
 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 }: {

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

@@ -51,7 +51,7 @@ function assertConfigValueType(value, type, configName, definedAtInfo) {
     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`);
+    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`);
 }
 function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
     let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)}`;