vike 0.4.171-commit-f9548df → 0.4.171-commit-6e37128

package/dist/esm/shared/page-configs/serialize/parsePageConfigs.js

@@ -1,21 +1,17 @@
 export { parsePageConfigs };
-import { parseConfigValuesImported } from './parseConfigValuesImported.js';
+export { parseConfigValuesSerialized };
 import { assert, assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
-import { parseConfigValuesSerialized } from './parseConfigValuesSerialized.js';
+import { parseTransform } from '@brillout/json-serializer/parse';
+import { assertPlusFileExport } from '../assertPlusFileExport.js';
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = parseConfigValuesSerialized_tmp(configValuesSerialized);
+    return configValues;
+}
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+    // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
-        const configValues = {};
-        {
-            const { configValuesSerialized } = pageConfigSerialized;
-            const configValuesAddendum = parseConfigValuesSerialized(configValuesSerialized);
-            Object.assign(configValues, configValuesAddendum);
-        }
-        {
-            const { configValuesImported } = pageConfigSerialized;
-            const configValuesAddendum = parseConfigValuesImported(configValuesImported);
-            Object.assign(configValues, configValuesAddendum);
-        }
+        const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);
         const { pageId, isErrorPage, routeFilesystem, loadConfigValuesAll } = pageConfigSerialized;
         assertRouteConfigValue(configValues);
         return {
@@ -26,10 +22,11 @@ function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
             loadConfigValuesAll
         };
     });
+    // pageConfigsGlobal
     const pageConfigGlobal = { configValues: {} };
     {
-        const configValuesAddendum = parseConfigValuesImported(pageConfigGlobalSerialized.configValuesImported);
-        Object.assign(pageConfigGlobal.configValues, configValuesAddendum);
+        const configValues = parseConfigValuesSerialized(pageConfigGlobalSerialized.configValuesSerialized);
+        Object.assign(pageConfigGlobal.configValues, configValues);
     }
     return { pageConfigs, pageConfigGlobal };
 }
@@ -52,3 +49,100 @@ function assertRouteConfigValue(configValues) {
    }
    */
 }
+function parseConfigValuesSerialized_tmp(configValuesSerialized) {
+    const configValues = {};
+    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+        let configValue;
+        if (configValueSeriliazed.type === 'cumulative') {
+            const { valueSerialized, ...common } = configValueSeriliazed;
+            const value = valueSerialized.map((valueSerializedElement, i) => {
+                const { value, sideExports } = parseValueSerialized(valueSerializedElement, configName, () => {
+                    const definedAtFile = configValueSeriliazed.definedAtData[i];
+                    assert(definedAtFile);
+                    return definedAtFile;
+                });
+                addSideExports(sideExports);
+                return value;
+            });
+            configValue = { value, ...common };
+        }
+        else {
+            const { valueSerialized, ...common } = configValueSeriliazed;
+            const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
+                assert(configValueSeriliazed.type !== 'computed');
+                return configValueSeriliazed.definedAtData;
+            });
+            addSideExports(sideExports);
+            configValue = { value, ...common };
+        }
+        configValues[configName] = configValue;
+    });
+    return configValues;
+    function addSideExports(sideExports) {
+        sideExports.forEach((sideExport) => {
+            const { configName, configValue } = sideExport;
+            if (!configValues[configName]) {
+                configValues[configName] = configValue;
+            }
+            else {
+                // Side-exports have lower precedence.
+                // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
+            }
+        });
+    }
+}
+function parseValueSerialized(valueSerialized, configName, getDefinedAtFile) {
+    if (valueSerialized.type === 'js-serialized') {
+        let { value } = valueSerialized;
+        value = parseTransform(value);
+        return { value, sideExports: [] };
+    }
+    if (valueSerialized.type === 'pointer-import') {
+        const { value } = valueSerialized;
+        return { value, sideExports: [] };
+    }
+    if (valueSerialized.type === 'plus-file') {
+        const definedAtFile = getDefinedAtFile();
+        const { exportValues } = valueSerialized;
+        assertPlusFileExport(exportValues, definedAtFile.filePathToShowToUser, configName);
+        let value;
+        let valueWasFound = false;
+        const sideExports = [];
+        Object.entries(exportValues).forEach(([exportName, exportValue]) => {
+            const isSideExport = exportName !== 'default' && exportName !== configName;
+            if (!isSideExport) {
+                value = exportValue;
+                assert(!valueWasFound);
+                valueWasFound = true;
+            }
+            else {
+                sideExports.push({
+                    configName: exportName,
+                    configValue: {
+                        type: 'standard', // We don't support side exports for cumulative values. We could support it but it isn't trivial.
+                        value: exportValue,
+                        definedAtData: {
+                            filePathToShowToUser: definedAtFile.filePathToShowToUser,
+                            fileExportPathToShowToUser: [exportName]
+                        }
+                    }
+                });
+            }
+        });
+        assert(valueWasFound);
+        return { value, sideExports };
+    }
+    assert(false);
+}
+/* [NULL_HANDLING] Do we really need this?
+function assertIsNotNull(configValue: unknown, configName: string, filePathToShowToUser: string) {
+  assert(!filePathToShowToUser.includes('+config.'))
+  // Re-use this for:
+  //  - upcoming config.requestPageContextOnNavigation
+  //  - for cumulative values in the future: we don't need this for now because, currently, cumulative values are never imported.
+  assertUsage(
+    configValue !== null,
+    `Set ${pc.cyan(configName)} to ${pc.cyan('null')} in a +config.js file instead of ${filePathToShowToUser}`
+  )
+}
+*/

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -0,0 +1,5 @@
+export { serializeConfigValues };
+import type { ConfigEnvInternal, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../PageConfig.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | (PageConfigGlobalBuildTime & {
+    configValuesComputed?: undefined;
+}), importStatements: string[], isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string): string[];

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.js

@@ -0,0 +1,192 @@
+export { serializeConfigValues };
+import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
+import { assert, assertUsage, getPropAccessNotation } from '../../../node/plugin/utils.js';
+import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
+import { parsePointerImportData } from '../../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transformFileImports.js';
+import { getConfigValueFilePathToShowToUser } from '../helpers.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+import pc from '@brillout/picocolors';
+const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
+const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
+// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with parsePageConfigs()
+// - vike/shared/page-configs/serialize/parsePageConfigs.ts
+// - parsePageConfigs() is loaded on both the client- and server-side.
+assertIsNotProductionRuntime();
+function serializeConfigValues(pageConfig, importStatements, isEnvMatch, tabspace) {
+    const lines = [];
+    tabspace += '  ';
+    Object.entries(pageConfig.configValuesComputed ?? {}).forEach(([configName, configValuesComputed]) => {
+        if (!isEnvMatch(configValuesComputed.configEnv))
+            return;
+        // Is there a use case for overriding computed values? If yes, then configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const valueData = serializeWithJson(configValuesComputed.value, configName, null, importStatements);
+        const configValueBase = {
+            type: 'computed',
+            definedAtData: null
+        };
+        serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+    });
+    Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+        const configDef = pageConfig.configDefinitions[configName];
+        assert(configDef);
+        if (!configDef.cumulative) {
+            const configValueSource = sources[0];
+            assert(configValueSource);
+            assert(sources.slice(1).every((s) => s.isOverriden === true));
+            if (!isEnvMatch(configValueSource.configEnv))
+                return;
+            const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+            const configValueBase = {
+                type: 'standard',
+                definedAtData: definedAtFile
+            };
+            serializeConfigValue(configValueBase, valueData, configName, lines, tabspace);
+        }
+        else {
+            const valueDataList = [];
+            const definedAtData = [];
+            sources
+                .filter((s) => !s.isOverriden)
+                .forEach((configValueSource) => {
+                if (!isEnvMatch(configValueSource.configEnv))
+                    return;
+                const { valueData, definedAtFile } = serializeConfigValueSource(configValueSource, configName, importStatements);
+                valueDataList.push(valueData);
+                definedAtData.push(definedAtFile);
+            });
+            if (valueDataList.length === 0)
+                return;
+            const configValueBase = {
+                type: 'cumulative',
+                definedAtData
+            };
+            serializeConfigValue(configValueBase, valueDataList, configName, lines, tabspace);
+        }
+    });
+    return lines;
+}
+function serializeConfigValueSource(configValueSource, configName, importStatements) {
+    assert(configValueSource.isOverriden === false);
+    let valueData;
+    if ('value' in configValueSource) {
+        valueData = serializeWithJson(configValueSource.value, configName, configValueSource.definedAtFilePath, importStatements);
+    }
+    else {
+        valueData = serializeWithImport(configValueSource, importStatements);
+    }
+    const definedAtFile = {
+        filePathToShowToUser: configValueSource.definedAtFilePath.filePathToShowToUser,
+        fileExportPathToShowToUser: configValueSource.definedAtFilePath.fileExportPathToShowToUser
+    };
+    return { valueData, definedAtFile };
+}
+function serializeConfigValue(configValueBase, valueData, configName, lines, tabspace) {
+    lineAdd(`[${JSON.stringify(configName)}]: {`);
+    {
+        tab();
+        lineAdd(`type: "${configValueBase.type}",`);
+        lineAdd(`definedAtData: ${JSON.stringify(configValueBase.definedAtData)},`);
+        lineAdd(`valueSerialized:`);
+        if (!Array.isArray(valueData)) {
+            serializeValueData(valueData);
+        }
+        else {
+            lineAppend(' [');
+            valueData.forEach(serializeValueData);
+            lineAppend(` ],`);
+        }
+        untab();
+    }
+    lineAdd('},');
+    return;
+    function serializeValueData(valueData) {
+        lineAppend(` {`);
+        tab();
+        lineAdd(`type: "${valueData.type}",`);
+        const valueProp = valueData.type !== 'plus-file' ? 'value' : 'exportValues';
+        lineAdd(`${valueProp}: ${valueData.valueAsJsCode},`);
+        untab();
+        lineAdd(`},`);
+    }
+    function lineAppend(str) {
+        const i = lines.length - 1;
+        lines[i] = lines[i] += str;
+    }
+    function lineAdd(str) {
+        lines.push(`${tabspace}${str}`);
+    }
+    function tab() {
+        tabspace += '  ';
+    }
+    function untab() {
+        tabspace = tabspace.slice(2);
+    }
+}
+function serializeWithImport(configValueSource, importStatements) {
+    assert(!configValueSource.valueIsFilePath);
+    const { valueIsImportedAtRuntime, valueIsDefinedByPlusFile, definedAtFilePath } = configValueSource;
+    assert(valueIsImportedAtRuntime);
+    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
+    if (valueIsDefinedByPlusFile)
+        assert(fileExportName === undefined);
+    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*');
+    return {
+        type: valueIsDefinedByPlusFile ? 'plus-file' : 'pointer-import',
+        valueAsJsCode: importName
+    };
+}
+function serializeWithJson(value, configName, definedAtData, importStatements) {
+    const valueAsJsCode = valueToJson(value, configName, definedAtData, importStatements);
+    return {
+        type: 'js-serialized',
+        valueAsJsCode
+    };
+}
+function valueToJson(value, configName, definedAtData, importStatements) {
+    const valueName = `config${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = stringify(value, {
+            valueName,
+            forbidReactElements: true,
+            replacer(_, value) {
+                if (typeof value === 'string') {
+                    const importData = parsePointerImportData(value);
+                    if (importData) {
+                        const { importName } = addImportStatement(importStatements, importData.importPath, importData.exportName);
+                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
+                        return { replacement };
+                    }
+                }
+            }
+        });
+    }
+    catch (err) {
+        logJsonSerializeError(err, configName, definedAtData);
+        assert(false);
+    }
+    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
+    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
+    assert(!configValueSerialized.includes(REPLACE_ME_BEFORE));
+    assert(!configValueSerialized.includes(REPLACE_ME_AFTER));
+    return configValueSerialized;
+}
+function logJsonSerializeError(err, configName, definedAtData) {
+    /*
+    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
+    let serializationErrMsg = ''
+    if (isJsonSerializerError(err)) {
+      serializationErrMsg = err.messageCore
+    } else {
+      // When a property getter throws an error
+      console.error('Serialization error:')
+      console.error(err)
+      serializationErrMsg = 'see serialization error printed above'
+    }
+    //*/
+    const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
+    assert(configValueFilePathToShowToUser);
+    assertUsage(false, `${pc.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
+}

package/dist/esm/shared/route/loadPageRoutes.js

@@ -3,7 +3,7 @@ import { isErrorPageId } from '../error-page.js';
 import { assert, assertUsage, hasProp, slice } from './utils.js';
 import { deduceRouteStringFromFilesystemPath } from './deduceRouteStringFromFilesystemPath.js';
 import { isCallable } from '../utils.js';
-import { getConfigValue } from '../page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../page-configs/getConfigValue.js';
 import { getDefinedAtString } from '../page-configs/getConfigDefinedAt.js';
 import { warnDeprecatedAllowKey } from './resolveRouteFunction.js';
 import { getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../hooks/getHook.js';
@@ -28,7 +28,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             let pageRoute = null;
             {
                 const configName = 'route';
-                const configValue = getConfigValue(pageConfig, configName);
+                const configValue = getConfigValueRuntime(pageConfig, configName);
                 if (configValue) {
                     const route = configValue.value;
                     assert(configValue.definedAtData);
@@ -44,7 +44,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
                     }
                     else {
                         assert(isCallable(route));
-                        if (getConfigValue(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
+                        if (getConfigValueRuntime(pageConfig, 'iKnowThePerformanceRisksOfAsyncRouteFunctions', 'boolean'))
                             warnDeprecatedAllowKey();
                         pageRoute = {
                             pageId,

package/dist/esm/utils/hasProp.d.ts

@@ -1,15 +1,6 @@
 export { hasProp };
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'boolean'): obj is ObjectType & Record<PropName, boolean>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'number'): obj is ObjectType & Record<PropName, number>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string'): obj is ObjectType & Record<PropName, string>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'object'): obj is ObjectType & Record<PropName, Record<string, unknown>>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'array'): obj is ObjectType & Record<PropName, unknown[]>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string[]'): obj is ObjectType & Record<PropName, string[]>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string{}'): obj is ObjectType & Record<PropName, Record<string, string>>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'function'): obj is ObjectType & Record<PropName, (...args: any[]) => unknown>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'undefined'): obj is ObjectType & Record<PropName, undefined>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'null'): obj is ObjectType & Record<PropName, null>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'true'): obj is ObjectType & Record<PropName, true>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'false'): obj is ObjectType & Record<PropName, false>;
+export type { ResolveTypeAsString };
+type TypeAsString = 'object' | 'string{}' | 'string[]' | 'array' | 'function' | 'number' | 'string' | 'boolean' | 'true' | 'false' | 'null' | 'undefined' | undefined;
+type ResolveTypeAsString<Type extends TypeAsString = undefined> = Type extends 'object' ? Record<string, unknown> : Type extends 'string{}' ? Record<string, string> : Type extends 'string[]' ? string[] : Type extends 'array' ? unknown[] : Type extends 'function' ? (...args: any[]) => unknown : Type extends 'number' ? number : Type extends 'string' ? string : Type extends 'boolean' ? boolean : Type extends 'true' ? true : Type extends 'false' ? false : Type extends 'null' ? null : Type extends 'undefined' ? undefined : Type extends undefined ? unknown : never;
+declare function hasProp<ObjectType, PropName extends PropertyKey, Type extends TypeAsString = undefined>(obj: ObjectType, prop: PropName, type?: Type): obj is ObjectType & Record<PropName, ResolveTypeAsString<Type>>;
 declare function hasProp<ObjectType, PropName extends PropertyKey, Enum>(obj: ObjectType, prop: PropName, type: Enum[]): obj is ObjectType & Record<PropName, Enum>;
-declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName): obj is ObjectType & Record<PropName, unknown>;

package/dist/esm/utils/hasProp.js

@@ -1,21 +1,22 @@
 export { hasProp };
-// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
-// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
 import { isCallable } from './isCallable.js';
 import { isObject } from './isObject.js';
 import { isArrayOfStrings } from './isArrayOfStrings.js';
 import { isObjectOfStrings } from './isObjectOfStrings.js';
 import { isArray } from './isArray.js';
-function hasProp(obj, prop, type = 'unknown') {
+function hasProp(obj, prop, type) {
     if (!isObject(obj))
         return false;
     if (!(prop in obj)) {
         return type === 'undefined';
     }
-    if (type === 'unknown') {
+    if (type === undefined) {
         return true;
     }
     const propValue = obj[prop];
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
     if (type === 'array') {
         return isArray(propValue);
     }
@@ -37,9 +38,6 @@ function hasProp(obj, prop, type = 'unknown') {
     if (type === 'null') {
         return propValue === null;
     }
-    if (type === 'undefined') {
-        return propValue === undefined;
-    }
     if (type === 'true') {
         return propValue === true;
     }

package/dist/esm/utils/projectInfo.d.ts

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.171-commit-f9548df";
+declare const PROJECT_VERSION: "0.4.171-commit-6e37128";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.171-commit-f9548df";
+    projectVersion: "0.4.171-commit-6e37128";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.171-commit-f9548df';
+const PROJECT_VERSION = '0.4.171-commit-6e37128';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.171-commit-f9548df",
+  "version": "0.4.171-commit-6e37128",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -212,7 +212,7 @@
     "rimraf": "^5.0.5",
     "sirv": "^2.0.4",
     "source-map-support": "^0.5.21",
-    "typescript": "^5.3.3",
+    "typescript": "^5.4.5",
     "vite": "npm:@brillout/vite@5.1.0-commit-3dc7abd"
   },
   "engines": {

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.js

@@ -1,101 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertConfigValueIsSerializable = exports.getConfigValuesSerialized = void 0;
-const utils_js_1 = require("../../../utils.js");
-const stringify_1 = require("@brillout/json-serializer/stringify");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
-const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
-const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
-const transformFileImports_js_1 = require("./getVikeConfig/transformFileImports.js");
-const addImportStatement_js_1 = require("../addImportStatement.js");
-const REPLACE_ME_BEFORE = '__VIKE__REPLACE_ME_BEFORE__';
-const REPLACE_ME_AFTER = '__VIKE__REPLACE_ME_AFTER__';
-function getConfigValuesSerialized(pageConfig, importStatements, isEnvMatch) {
-    const lines = [];
-    Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
-        const { configEnv } = configValuesComputed;
-        if (!isEnvMatch(configEnv))
-            return;
-        // configValeSources has higher precedence
-        if (pageConfig.configValueSources[configName])
-            return;
-        const configValue = pageConfig.configValues[configName];
-        (0, utils_js_1.assert)(configValue);
-        const { value, ...common } = configValue;
-        (0, utils_js_1.assert)(value === configValuesComputed.value);
-        const valueSerialized = getConfigValueSerialized(value, configName, configValue.definedAtData, importStatements);
-        const configValueSerialized = { valueSerialized, ...common };
-        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, configValueSerialized);
-    });
-    (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
-        const { configName, configEnv } = configValueSource;
-        const configValue = pageConfig.configValues[configName];
-        if (!configValue)
-            return;
-        if (!isEnvMatch(configEnv, configValueSource)) {
-            return;
-        }
-        const { value, ...common } = configValue;
-        const valueSerialized = getConfigValueSerialized(value, configName, configValue.definedAtData, importStatements);
-        const configValueSerialized = { valueSerialized, ...common };
-        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, configValueSerialized);
-    });
-    const code = lines.join('\n');
-    return code;
-}
-exports.getConfigValuesSerialized = getConfigValuesSerialized;
-function assertConfigValueIsSerializable(value, configName, definedAtData) {
-    // Contains asserts
-    getConfigValueSerialized(value, configName, definedAtData, []);
-}
-exports.assertConfigValueIsSerializable = assertConfigValueIsSerializable;
-function getConfigValueSerialized(value, configName, definedAtData, importStatements) {
-    const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
-    let configValueSerialized;
-    try {
-        configValueSerialized = (0, stringify_1.stringify)(value, {
-            valueName,
-            forbidReactElements: true,
-            replacer(_, value) {
-                if (typeof value === 'string') {
-                    const importData = (0, transformFileImports_js_1.parsePointerImportData)(value);
-                    if (importData) {
-                        const { importName } = (0, addImportStatement_js_1.addImportStatement)(importStatements, importData.importPath, importData.exportName);
-                        const replacement = [REPLACE_ME_BEFORE, importName, REPLACE_ME_AFTER].join('');
-                        return { replacement };
-                    }
-                }
-            }
-        });
-    }
-    catch (err) {
-        logJsonSerializeError(err, configName, definedAtData);
-        (0, utils_js_1.assert)(false);
-    }
-    configValueSerialized = configValueSerialized.replaceAll(`"${REPLACE_ME_BEFORE}`, '');
-    configValueSerialized = configValueSerialized.replaceAll(`${REPLACE_ME_AFTER}"`, '');
-    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_BEFORE));
-    (0, utils_js_1.assert)(!configValueSerialized.includes(REPLACE_ME_AFTER));
-    return configValueSerialized;
-}
-function logJsonSerializeError(err, configName, definedAtData) {
-    /*
-    // import { isJsonSerializerError } from '@brillout/json-serializer/stringify'
-    let serializationErrMsg = ''
-    if (isJsonSerializerError(err)) {
-      serializationErrMsg = err.messageCore
-    } else {
-      // When a property getter throws an error
-      console.error('Serialization error:')
-      console.error(err)
-      serializationErrMsg = 'see serialization error printed above'
-    }
-    //*/
-    const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
-    (0, utils_js_1.assert)(configValueFilePathToShowToUser);
-    (0, utils_js_1.assertUsage)(false, `${picocolors_1.default.cyan(configName)} defined by ${configValueFilePathToShowToUser} must be defined over a so-called "pointer import", see https://vike.dev/config#pointer-imports`);
-}

package/dist/cjs/node/plugin/shared/getConfigValueSourcesNotOverriden.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfigValueSourcesNotOverriden = void 0;
-const utils_js_1 = require("../../shared/utils.js");
-(0, utils_js_1.assertIsNotBrowser)();
-function getConfigValueSourcesNotOverriden(pageConfig) {
-    const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
-        const configValueSource = sources[0];
-        (0, utils_js_1.assert)(configValueSource);
-        return { configName, ...configValueSource };
-    });
-    return configValueSourcesRelevant;
-}
-exports.getConfigValueSourcesNotOverriden = getConfigValueSourcesNotOverriden;

package/dist/cjs/node/shared/getClientEntry.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getClientEntry = void 0;
-const getConfigValue_js_1 = require("../../shared/page-configs/getConfigValue.js");
-function getClientEntry(pageConfig) {
-    const configName = 'client';
-    const configValue = (0, getConfigValue_js_1.getConfigValue)(pageConfig, configName, 'string');
-    if (!configValue)
-        return null;
-    return configValue.value;
-}
-exports.getClientEntry = getClientEntry;