vike 0.4.239 → 0.4.240

package/dist/cjs/shared/page-configs/resolveVikeConfigPublic.js

@@ -1,287 +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.resolveGlobalConfigPublic = resolveGlobalConfigPublic;
-exports.resolvePageContextConfig = resolvePageContextConfig;
-exports.resolveGlobalContextConfig = resolveGlobalContextConfig;
-const assert_exports_old_design_js_1 = require("../getPageFiles/assert_exports_old_design.js");
-const getConfigDefinedAt_js_1 = require("./getConfigDefinedAt.js");
-const helpers_js_1 = require("./helpers.js");
-const utils_js_1 = require("../utils.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-function resolveGlobalConfigPublicPage(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigPublic_ = resolvePageConfigPublic({ pageConfigGlobalValues, pageConfigValues });
-    const pageConfigPublic = getPublicCopy(pageConfigPublic_);
-    const page = (() => {
-        if (!pageConfig.isErrorPage) {
-            const route = pageConfigPublic.config.route ?? pageConfig.routeFilesystem.routeString;
-            return {
-                ...pageConfigPublic,
-                route,
-            };
-        }
-        else {
-            return {
-                ...pageConfigPublic,
-                isErrorPage: true,
-            };
-        }
-    })();
-    return [pageConfig.pageId, page];
-}
-function getPublicCopy(configInternal) {
-    const configPublic = {
-        config: configInternal.config,
-        // TO-DO/soon/flat-pageContext: expose publicly?
-        _source: configInternal.source,
-        _sources: configInternal.sources,
-        _from: configInternal.from,
-    };
-    return configPublic;
-}
-function resolvePageConfigPublic({ pageConfigGlobalValues, pageConfigValues, }) {
-    const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return resolveConfigPublic_V1Design({ configValues });
-}
-function resolvePageContextConfig(pageFiles, // V0.4 design
-pageConfig, // V1 design
-pageConfigGlobal) {
-    const config = {};
-    const configEntries = {}; // TO-DO/next-major-release: remove
-    const exportsAll = {}; // TO-DO/next-major-release: remove
-    // V0.4 design
-    // TO-DO/next-major-release: remove
-    pageFiles.forEach((pageFile) => {
-        const exportValues = getExportValues(pageFile);
-        exportValues.forEach(({ exportName, exportValue, isFromDefaultExport }) => {
-            (0, utils_js_1.assert)(exportName !== 'default');
-            exportsAll[exportName] = exportsAll[exportName] ?? [];
-            exportsAll[exportName].push({
-                exportValue,
-                exportSource: `${pageFile.filePath} > ${isFromDefaultExport ? `\`export default { ${exportName} }\`` : `\`export { ${exportName} }\``}`,
-                filePath: pageFile.filePath,
-                _filePath: pageFile.filePath, // TO-DO/next-major-release: remove
-                _fileType: pageFile.fileType,
-                _isFromDefaultExport: isFromDefaultExport,
-            });
-        });
-    });
-    let source;
-    let sources;
-    let from;
-    if (pageConfig) {
-        const res = resolvePageConfigPublic({
-            pageConfigGlobalValues: pageConfigGlobal.configValues,
-            pageConfigValues: pageConfig.configValues,
-        });
-        source = res.source;
-        sources = res.sources;
-        from = res.from;
-        Object.assign(config, res.config);
-        Object.assign(configEntries, res.configEntries);
-        Object.assign(exportsAll, res.exportsAll);
-    }
-    else {
-        source = {};
-        sources = {};
-        from = {
-            configsStandard: {},
-            configsCumulative: {},
-            configsComputed: {},
-        };
-    }
-    const pageExports = {};
-    const exports = {};
-    Object.entries(exportsAll).forEach(([exportName, values]) => {
-        values.forEach(({ exportValue, _fileType, _isFromDefaultExport }) => {
-            exports[exportName] = exports[exportName] ?? exportValue;
-            // Legacy pageContext.pageExports
-            if (_fileType === '.page' && !_isFromDefaultExport) {
-                if (!(exportName in pageExports)) {
-                    pageExports[exportName] = exportValue;
-                }
-            }
-        });
-    });
-    (0, utils_js_1.assert)(!('default' in exports));
-    (0, utils_js_1.assert)(!('default' in exportsAll));
-    const pageContextAddendum = {
-        config: config,
-        from,
-        source,
-        sources,
-        // TO-DO/soon/flat-pageContext: deprecate every prop below
-        configEntries,
-        exports,
-        exportsAll,
-    };
-    // TO-DO/next-major-release: remove
-    (0, utils_js_1.objectDefineProperty)(pageContextAddendum, 'pageExports', {
-        get: () => {
-            // We only show the warning in Node.js because when using Client Routing Vue integration uses `Object.assign(pageContextReactive, pageContext)` which will wrongully trigger the warning. There is no cross-browser way to catch whether the property accessor was initiated by an `Object.assign()` call.
-            if (!(0, utils_js_1.isBrowser)()) {
-                (0, utils_js_1.assertWarning)(false, 'pageContext.pageExports is outdated, use pageContext.exports instead', {
-                    onlyOnce: true,
-                    showStackTrace: true,
-                });
-            }
-            return pageExports;
-        },
-        enumerable: false,
-        configurable: true,
-    });
-    return pageContextAddendum;
-}
-function resolveGlobalContextConfig(pageConfigs, pageConfigGlobal) {
-    const globalContextAddendum = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, (c) => c.configValues);
-    return globalContextAddendum;
-}
-function resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues) {
-    // global
-    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal, true);
-    const globalConfigPublicBase_ = resolveConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
-    const globalConfigPublicBase = getPublicCopy(globalConfigPublicBase_);
-    // pages
-    const pages = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        const pageConfigValues = getConfigValues(pageConfig);
-        return resolveGlobalConfigPublicPage(pageConfigGlobalValues, pageConfig, pageConfigValues);
-    }));
-    const globalConfigPublic = {
-        ...globalConfigPublicBase,
-        pages,
-    };
-    return {
-        ...globalConfigPublic,
-        _globalConfigPublic: globalConfigPublic,
-    };
-}
-// V1 design
-function resolveConfigPublic_V1Design(pageConfig) {
-    const config = {};
-    const configEntries = {};
-    const exportsAll = {};
-    const source = {};
-    const sources = {};
-    const from = {
-        configsStandard: {},
-        configsCumulative: {},
-        configsComputed: {},
-    };
-    const addSrc = (src, configName) => {
-        source[configName] = src;
-        sources[configName] ?? (sources[configName] = []);
-        sources[configName].push(src);
-    };
-    const addLegacy = (configName, value, definedAtData) => {
-        const configValueFilePathToShowToUser = (0, helpers_js_1.getConfigValueFilePathToShowToUser)(definedAtData);
-        const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAtOptional)('Config', configName, definedAtData);
-        configEntries[configName] = configEntries[configName] ?? [];
-        configEntries[configName].push({
-            configValue: value,
-            configDefinedAt,
-            configDefinedByFile: configValueFilePathToShowToUser,
-        });
-        // TO-DO/next-major-release: remove
-        const exportName = configName;
-        exportsAll[exportName] = exportsAll[exportName] ?? [];
-        exportsAll[exportName].push({
-            exportValue: value,
-            exportSource: configDefinedAt,
-            filePath: configValueFilePathToShowToUser,
-            _filePath: configValueFilePathToShowToUser,
-            _fileType: null,
-            _isFromDefaultExport: null,
-        });
-    };
-    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-        const { value } = configValue;
-        config[configName] = config[configName] ?? value;
-        if (configValue.type === 'standard') {
-            const src = {
-                type: 'configsStandard',
-                value: configValue.value,
-                definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName),
-            };
-            addSrc(src, configName);
-            from.configsStandard[configName] = src;
-            addLegacy(configName, value, configValue.definedAtData);
-        }
-        if (configValue.type === 'cumulative') {
-            const src = {
-                type: 'configsCumulative',
-                definedAt: (0, getConfigDefinedAt_js_1.getDefinedAtString)(configValue.definedAtData, configName),
-                values: configValue.value.map((value, i) => {
-                    const definedAtFile = configValue.definedAtData[i];
-                    (0, utils_js_1.assert)(definedAtFile);
-                    const definedAt = (0, getConfigDefinedAt_js_1.getDefinedAtString)(definedAtFile, configName);
-                    addLegacy(configName, value, definedAtFile);
-                    return {
-                        value,
-                        definedAt,
-                    };
-                }),
-            };
-            addSrc(src, configName);
-            from.configsCumulative[configName] = src;
-        }
-        if (configValue.type === 'computed') {
-            const src = {
-                type: 'configsComputed',
-                definedAt: 'Vike', // Vike currently doesn't support user-land computed configs => computed configs are always defined by Vike => there isn't any file path to show.
-                value: configValue.value,
-            };
-            addSrc(src, configName);
-            from.configsComputed[configName] = src;
-            addLegacy(configName, value, configValue.definedAtData);
-        }
-    });
-    return {
-        config: config,
-        configEntries,
-        exportsAll,
-        source,
-        sources,
-        from,
-    };
-}
-// V0.4 design
-// TO-DO/next-major-release: remove
-function getExportValues(pageFile) {
-    const { filePath, fileExports } = pageFile;
-    (0, utils_js_1.assert)(fileExports); // assume pageFile.loadFile() was called
-    (0, utils_js_1.assert)((0, utils_js_1.isScriptFile)(filePath));
-    const exportValues = [];
-    Object.entries(fileExports)
-        .sort((0, utils_js_1.makeLast)(([exportName]) => exportName === 'default')) // `export { bla }` should override `export default { bla }`
-        .forEach(([exportName, exportValue]) => {
-        let isFromDefaultExport = exportName === 'default';
-        if (isFromDefaultExport) {
-            if ((0, utils_js_1.isTemplateFile)(filePath)) {
-                exportName = 'Page';
-            }
-            else {
-                (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(exportValue), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object.`);
-                Object.entries(exportValue).forEach(([defaultExportName, defaultExportValue]) => {
-                    (0, assert_exports_old_design_js_1.assertDefaultExports)(defaultExportName, filePath);
-                    exportValues.push({
-                        exportName: defaultExportName,
-                        exportValue: defaultExportValue,
-                        isFromDefaultExport,
-                    });
-                });
-                return;
-            }
-        }
-        exportValues.push({
-            exportName,
-            exportValue,
-            isFromDefaultExport,
-        });
-    });
-    exportValues.forEach(({ exportName, isFromDefaultExport }) => {
-        (0, utils_js_1.assert)(!(isFromDefaultExport && assert_exports_old_design_js_1.forbiddenDefaultExports.includes(exportName)));
-    });
-    return exportValues;
-}

package/dist/cjs/shared/page-configs/serialize/PageConfigSerialized.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/page-configs/serialize/assertPageConfigsSerialized.js

@@ -1 +0,0 @@
-"use strict";

package/dist/cjs/shared/page-configs/serialize/parsePageConfigsSerialized.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePageConfigsSerialized = parsePageConfigsSerialized;
-exports.parseConfigValuesSerialized = parseConfigValuesSerialized;
-const utils_js_1 = require("../../utils.js");
-const getConfigDefinedAt_js_1 = require("../getConfigDefinedAt.js");
-const parse_1 = require("@brillout/json-serializer/parse");
-const assertPlusFileExport_js_1 = require("../assertPlusFileExport.js");
-function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
-    // pageConfigs
-    const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
-        const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);
-        assertRouteConfigValue(configValues);
-        const pageConfig = { ...pageConfigSerialized, configValues };
-        return pageConfig;
-    });
-    // pageConfigsGlobal
-    const pageConfigGlobal = { configValues: {} };
-    {
-        const configValues = parseConfigValuesSerialized(pageConfigGlobalSerialized.configValuesSerialized);
-        Object.assign(pageConfigGlobal.configValues, configValues);
-    }
-    return { pageConfigs, pageConfigGlobal };
-}
-function assertRouteConfigValue(configValues) {
-    const configName = 'route';
-    const configValue = configValues[configName];
-    if (!configValue)
-        return;
-    const { value, definedAtData } = configValue;
-    const configValueType = typeof value;
-    (0, utils_js_1.assert)(definedAtData);
-    const configDefinedAt = (0, getConfigDefinedAt_js_1.getConfigDefinedAt)('Config', configName, definedAtData);
-    (0, utils_js_1.assertUsage)(configValueType === 'string' || (0, utils_js_1.isCallable)(value), `${configDefinedAt} 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`)
-   }
-   */
-}
-function parseConfigValuesSerialized(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];
-                    (0, utils_js_1.assert)(definedAtFile);
-                    return definedAtFile;
-                });
-                addSideExports(sideExports);
-                return value;
-            });
-            configValue = { value, ...common };
-        }
-        else {
-            const { valueSerialized, ...common } = configValueSeriliazed;
-            const { value, sideExports } = parseValueSerialized(valueSerialized, configName, () => {
-                (0, utils_js_1.assert)(configValueSeriliazed.type !== 'computed');
-                const { definedAtData } = configValueSeriliazed;
-                const definedAtFile = Array.isArray(definedAtData) ? definedAtData[0] : definedAtData;
-                return definedAtFile;
-            });
-            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 = (0, parse_1.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;
-        (0, utils_js_1.assert)(!definedAtFile.definedBy);
-        (0, assertPlusFileExport_js_1.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;
-                // Already asserted by assertPlusFileExport() call above.
-                (0, utils_js_1.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],
-                        },
-                    },
-                });
-            }
-        });
-        // Already asserted by assertPlusFileExport() call above.
-        (0, utils_js_1.assert)(valueWasFound);
-        return { value, sideExports };
-    }
-    (0, utils_js_1.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}`
-  )
-}
-*/