vike 0.4.171-commit-f9548df → 0.4.171-commit-3b2cb88

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

@@ -1,95 +0,0 @@
-export { getConfigValuesSerialized };
-export { assertConfigValueIsSerializable };
-import { assert, assertUsage, getPropAccessNotation } from '../../../utils.js';
-import { stringify } from '@brillout/json-serializer/stringify';
-import pc from '@brillout/picocolors';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
-import { serializeConfigValue } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
-import { getConfigValueSourcesNotOverriden } from '../../../shared/getConfigValueSourcesNotOverriden.js';
-import { parsePointerImportData } from './getVikeConfig/transformFileImports.js';
-import { addImportStatement } from '../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];
-        assert(configValue);
-        const { value, ...common } = configValue;
-        assert(value === configValuesComputed.value);
-        const valueSerialized = getConfigValueSerialized(value, configName, configValue.definedAtData, importStatements);
-        const configValueSerialized = { valueSerialized, ...common };
-        serializeConfigValue(lines, configName, configValueSerialized);
-    });
-    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 };
-        serializeConfigValue(lines, configName, configValueSerialized);
-    });
-    const code = lines.join('\n');
-    return code;
-}
-function assertConfigValueIsSerializable(value, configName, definedAtData) {
-    // Contains asserts
-    getConfigValueSerialized(value, configName, definedAtData, []);
-}
-function getConfigValueSerialized(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/node/plugin/shared/getConfigValueSourcesNotOverriden.d.ts

@@ -1,5 +0,0 @@
-export { getConfigValueSourcesNotOverriden };
-import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
-declare function getConfigValueSourcesNotOverriden(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
-    configName: string;
-})[];

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

@@ -1,11 +0,0 @@
-export { getConfigValueSourcesNotOverriden };
-import { assert, assertIsNotBrowser } from '../../shared/utils.js';
-assertIsNotBrowser();
-function getConfigValueSourcesNotOverriden(pageConfig) {
-    const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
-        const configValueSource = sources[0];
-        assert(configValueSource);
-        return { configName, ...configValueSource };
-    });
-    return configValueSourcesRelevant;
-}

package/dist/esm/node/shared/getClientEntry.d.ts

@@ -1,3 +0,0 @@
-export { getClientEntry };
-import type { PageConfigRuntime, PageConfigBuildTime } from '../../shared/page-configs/PageConfig.js';
-declare function getClientEntry(pageConfig: PageConfigRuntime | PageConfigBuildTime): null | string;

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

@@ -1,9 +0,0 @@
-export { getClientEntry };
-import { getConfigValue } from '../../shared/page-configs/getConfigValue.js';
-function getClientEntry(pageConfig) {
-    const configName = 'client';
-    const configValue = getConfigValue(pageConfig, configName, 'string');
-    if (!configValue)
-        return null;
-    return configValue.value;
-}

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

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

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

@@ -1,82 +0,0 @@
-export { parseConfigValuesImported };
-import { assert } from '../../utils.js';
-import { assertPlusFileExport } from '../assertPlusFileExport.js';
-function parseConfigValuesImported(configValuesImported) {
-    const configValuesUnmerged = {};
-    configValuesImported
-        .filter((c) => c.configName !== 'client')
-        .forEach((configValueLoaded) => {
-        if (configValueLoaded.isValueFile) {
-            const { exportValues, importPath, configName } = configValueLoaded;
-            assertPlusFileExport(exportValues, importPath, configName);
-            Object.entries(exportValues).forEach(([exportName, exportValue]) => {
-                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
-                const configName = isSideExport ? exportName : configValueLoaded.configName;
-                configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
-                configValuesUnmerged[configName].push({
-                    value: exportValue,
-                    importPath,
-                    exportName,
-                    isSideExport
-                });
-            });
-        }
-        else {
-            const { configName, importPath, exportValue, exportName } = configValueLoaded;
-            configValuesUnmerged[configName] ?? (configValuesUnmerged[configName] = []);
-            configValuesUnmerged[configName].push({
-                value: exportValue,
-                importPath,
-                exportName,
-                isSideExport: false
-            });
-        }
-    });
-    const configValues = {};
-    Object.entries(configValuesUnmerged).forEach(([configName, values]) => {
-        const valuesWithoutSideExports = values.filter((v) => !v.isSideExport);
-        const isCumulative = valuesWithoutSideExports.length > 1;
-        const noSideExports = valuesWithoutSideExports.length === values.length;
-        if (isCumulative) {
-            // Vike currently doesn't support side exports for cumulative configs
-            assert(noSideExports);
-            // TODO: implement
-            assert(false);
-        }
-        else {
-            const val = valuesWithoutSideExports[0] ??
-                // We can't avoid side-export conflicts upstream. (We cannot know about side-exports at build-time.)
-                // Side-exports have lower precedence.
-                values[0];
-            assert(val);
-            const { value, importPath, exportName } = val;
-            configValues[configName] = {
-                type: 'standard',
-                value,
-                definedAtData: {
-                    // importPath cannot be relative to the current file, since the current file is a virtual file
-                    filePathToShowToUser: importPath,
-                    fileExportPathToShowToUser: [configName, 'default'].includes(exportName)
-                        ? []
-                        : [
-                            // Side-export
-                            exportName
-                        ]
-                }
-            };
-            assertIsNotNull(value, configName, importPath);
-        }
-    });
-    return configValues;
-}
-function assertIsNotNull(configValue, configName, importPath) {
-    assert(!importPath.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 ${importPath}`
-    )
-    */
-}

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

@@ -1,4 +0,0 @@
-export { parseConfigValuesSerialized };
-import type { ConfigValues } from '../PageConfig.js';
-import type { ConfigValueSerialized } from './PageConfigSerialized.js';
-declare function parseConfigValuesSerialized(configValuesSerialized: Record<string, ConfigValueSerialized>): ConfigValues;

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

@@ -1,21 +0,0 @@
-export { parseConfigValuesSerialized };
-import { assert, isArray } from '../../utils.js';
-import { parseTransform } from '@brillout/json-serializer/parse';
-function parseConfigValuesSerialized(configValuesSerialized) {
-    const configValues = {};
-    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
-        assert(!configValues[configName]);
-        const { valueSerialized, ...common } = configValueSeriliazed;
-        const value = parseTransform(valueSerialized);
-        let configValue;
-        if (common.type === 'cumulative') {
-            assert(isArray(value));
-            configValue = { value, ...common };
-        }
-        else {
-            configValue = { value, ...common };
-        }
-        configValues[configName] = configValue;
-    });
-    return configValues;
-}

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

@@ -1,6 +0,0 @@
-export { serializeConfigValue };
-export { serializeConfigValueImported };
-import { ConfigValueSource } from '../PageConfig.js';
-import { ConfigValueSerialized } from './PageConfigSerialized.js';
-declare function serializeConfigValue(lines: string[], configName: string, configValueSerialized: ConfigValueSerialized): void;
-declare function serializeConfigValueImported(configValueSource: ConfigValueSource, configName: string, whitespace: string, importStatements: string[]): string[];

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

@@ -1,46 +0,0 @@
-export { serializeConfigValue };
-export { serializeConfigValueImported };
-// This file is never loaded on the client-side but we save it under the vike/shared/ directory in order to collocate it with:
-//   - vike/shared/page-configs/serialize/parsePageConfigs.ts
-//   - vike/shared/page-configs/serialize/parseConfigValuesImported.ts
-// Both parsePageConfigs() parseConfigValuesImported() and are loaded on the client-side and server-side
-import { assertIsNotProductionRuntime } from '../../../utils/assertIsNotProductionRuntime.js';
-assertIsNotProductionRuntime();
-import { assert } from '../../utils.js';
-import { addImportStatement } from '../../../node/plugin/plugins/importUserCode/addImportStatement.js';
-function serializeConfigValue(lines, configName, configValueSerialized) {
-    let whitespace = '      ';
-    lines.push(`${whitespace}['${configName}']: {`);
-    whitespace += '  ';
-    Object.entries(configValueSerialized).forEach(([key, val]) => {
-        const valSerialized = key === 'valueSerialized' ? val : JSON.stringify(val);
-        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
-    });
-    whitespace = whitespace.slice(2);
-    lines.push(`${whitespace}},`);
-}
-function serializeConfigValueImported(configValueSource, configName, whitespace, importStatements) {
-    assert(!configValueSource.valueIsFilePath);
-    assert(whitespace.replaceAll(' ', '').length === 0);
-    const { valueIsImportedAtRuntime, valueIsDefinedByValueFile, definedAtFilePath } = configValueSource;
-    assert(valueIsImportedAtRuntime);
-    const { filePathAbsoluteVite, fileExportName } = definedAtFilePath;
-    if (valueIsDefinedByValueFile)
-        assert(fileExportName === undefined);
-    const { importName } = addImportStatement(importStatements, filePathAbsoluteVite, fileExportName || '*');
-    const lines = [];
-    lines.push(`  {`);
-    lines.push(`    configName: '${configName}',`);
-    lines.push(`    importPath: '${filePathAbsoluteVite}',`);
-    lines.push(`    isValueFile: ${JSON.stringify(valueIsDefinedByValueFile)},`);
-    if (valueIsDefinedByValueFile) {
-        lines.push(`    exportValues: ${importName},`);
-    }
-    else {
-        lines.push(`    exportValue: ${importName},`);
-        assert(fileExportName);
-        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
-    }
-    lines.push(`  },`);
-    return lines;
-}