vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFilePageConfigValuesAll = void 0;
+const utils_js_1 = require("../../../utils.js");
+const generateEagerImport_js_1 = require("../generateEagerImport.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+const getVikeConfig_js_1 = require("./getVikeConfig.js");
+const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
+const debug_js_1 = require("./debug.js");
+const path_1 = __importDefault(require("path"));
+const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const getConfigValueSource_js_1 = require("../../../shared/getConfigValueSource.js");
+const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+    const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
+    (0, utils_js_1.assert)(result);
+    /* This assertion fails when using includeAssetsImportedByServer
+    {
+      const isForClientSide = !config.build.ssr
+      assert(result.isForClientSide === isForClientSide)
+    }
+    */
+    const { pageId, isForClientSide } = result;
+    const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+    const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
+    (0, utils_js_1.assert)(pageConfig);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
+    (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+exports.getVirtualFilePageConfigValuesAll = getVirtualFilePageConfigValuesAll;
+function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+    const configValue = (0, utils_js_2.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
+    const isClientRouting = configValue?.value ?? false;
+    const lines = [];
+    const importStatements = [];
+    lines.push('export default [');
+    let varCounter = 0;
+    (0, getConfigValueSource_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
+        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+        if (!valueIsImportedAtRuntime)
+            return;
+        if (configValueSource.valueIsFilePath)
+            return;
+        if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+            return;
+        const { filePath, fileExportPath } = definedAtInfo;
+        (0, utils_js_1.assertPosixPath)(filePath);
+        const fileName = path_1.default.posix.basename(filePath);
+        const isPlusFile = fileName.startsWith('+');
+        const fileExportName = fileExportPath[0];
+        (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
+        (0, utils_js_1.assert)(fileExportName);
+        const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(filePath, varCounter++, isPlusFile ? undefined : fileExportName);
+        importStatements.push(importStatement);
+        lines.push(`  {`);
+        lines.push(`    configName: '${configName}',`);
+        lines.push(`    importFilePath: '${filePath}',`);
+        lines.push(`    isPlusFile: ${JSON.stringify(isPlusFile)},`);
+        if (isPlusFile) {
+            lines.push(`    importFileExports: ${importVar},`);
+        }
+        else {
+            lines.push(`    importFileExportValue: ${importVar},`);
+            (0, utils_js_1.assert)(fileExportName);
+            lines.push(`    importFileExportName: ${JSON.stringify(fileExportName)},`);
+        }
+        lines.push(`  },`);
+    });
+    lines.push('];');
+    if (includeAssetsImportedByServer && isForClientSide && !isDev) {
+        lines.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);
+    }
+    const code = [...importStatements, ...lines].join('\n');
+    return code;
+}

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

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFilePageConfigs = void 0;
+const utils_js_1 = require("../../../utils.js");
+const generateEagerImport_js_1 = require("../generateEagerImport.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+const debug_js_1 = require("./debug.js");
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const helpers_js_1 = require("./helpers.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const getVikeConfig_js_1 = require("./getVikeConfig.js");
+const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
+async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await (0, getVikeConfig_js_1.getVikeConfig)(userRootDir, isDev, configVike.extensions, true);
+    return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+}
+exports.getVirtualFilePageConfigs = getVirtualFilePageConfigs;
+function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+    const lines = [];
+    const importStatements = [];
+    lines.push('export const pageConfigs = [');
+    pageConfigs.forEach((pageConfig) => {
+        const { pageId, routeFilesystem, isErrorPage } = pageConfig;
+        const virtualFileIdPageConfigValuesAll = (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, isForClientSide);
+        lines.push(`  {`);
+        lines.push(`    pageId: ${JSON.stringify(pageId)},`);
+        lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
+        lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
+        lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
+        lines.push(`    configValues: {`);
+        Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
+            const configValue = pageConfig.configValues[configName];
+            if (configValue) {
+                const configEnv = (0, helpers_js_1.getConfigEnv)(pageConfig, configName);
+                (0, utils_js_1.assert)(configEnv, configName);
+                if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
+                    return;
+                const { value, definedAtInfo } = configValue;
+                // TODO: use @brillout/json-serializer
+                //  - re-use getConfigValueSerialized()?
+                const valueSerialized = JSON.stringify(value);
+                serializeConfigValue(lines, configName, { definedAtInfo }, valueSerialized);
+            }
+            else {
+                const configValueSource = sources[0];
+                (0, utils_js_1.assert)(configValueSource);
+                if (configValueSource.configEnv === '_routing-eager') {
+                    const { definedAtInfo } = configValueSource;
+                    const configValue = { configName, definedAtInfo };
+                    (0, utils_js_1.assert)(!configValueSource.isComputed);
+                    const { filePath, fileExportPath } = configValueSource.definedAtInfo;
+                    const [exportName] = fileExportPath;
+                    (0, utils_js_1.assert)(exportName);
+                    const configValueEagerImport = getConfigValueEagerImport(filePath, exportName, importStatements);
+                    serializeConfigValue(lines, configName, configValue, configValueEagerImport);
+                }
+            }
+        });
+        lines.push(`    },`);
+        lines.push(`  },`);
+    });
+    lines.push('];');
+    lines.push('export const pageConfigGlobal = {');
+    (0, utils_js_1.objectEntries)(pageConfigGlobal).forEach(([configName, configValueSource]) => {
+        if (configName === 'onBeforeRoute') {
+            // if( isForClientSide && !isClientRouting ) return
+        }
+        else if (configName === 'onPrerenderStart') {
+            if (isDev || isForClientSide) {
+                // Only load onPrerenderStart() in server production runtime
+                configValueSource = null;
+            }
+        }
+        else {
+            (0, utils_js_1.assert)(false);
+        }
+        let whitespace = '  ';
+        let content;
+        if (configValueSource === null) {
+            content = 'null,';
+        }
+        else {
+            content = serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, true);
+            (0, utils_js_1.assert)(content.startsWith('{') && content.endsWith('},') && content.includes('\n'));
+        }
+        content = `${whitespace}[${JSON.stringify(configName)}]: ${content}`;
+        lines.push(content);
+    });
+    lines.push('};');
+    const code = [...importStatements, ...lines].join('\n');
+    (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function serializeConfigValue(lines, configName, configValue, valueSerialized) {
+    let whitespace = '      ';
+    lines.push(`${whitespace}['${configName}']: {`);
+    whitespace += '  ';
+    lines.push(`${whitespace}  value: ${valueSerialized},`);
+    Object.entries(configValue).forEach(([key, val]) => {
+        if (key === 'value')
+            return;
+        // if (val === undefined) return
+        lines.push(`${whitespace}  ${key}: ${JSON.stringify(val)},`);
+    });
+    whitespace = whitespace.slice(2);
+    lines.push(`${whitespace}},`);
+}
+function serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, isGlobalConfig) {
+    (0, utils_js_1.assert)(!configValueSource.isComputed);
+    const { definedAtInfo, configEnv } = configValueSource;
+    const lines = [];
+    lines.push(`{`);
+    lines.push(`${whitespace}  definedAtInfo: ${JSON.stringify(definedAtInfo)},`);
+    lines.push(`${whitespace}  configEnv: ${JSON.stringify(configEnv)},`);
+    const eager = configValueSource.configEnv === '_routing-eager' || isGlobalConfig;
+    if ((0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting) || eager) {
+        if ('value' in configValueSource) {
+            const { value } = configValueSource;
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo.filePath);
+            lines.push(`${whitespace}  valueSerialized: ${valueSerialized}`);
+        }
+        else if (eager) {
+            const { filePath, fileExportPath } = configValueSource.definedAtInfo;
+            const [exportName] = fileExportPath;
+            (0, utils_js_1.assert)(exportName);
+            const configValueEagerImport = getConfigValueEagerImport(filePath, exportName, importStatements);
+            lines.push(`${whitespace}  value: ${configValueEagerImport},`);
+        }
+    }
+    lines.push(`${whitespace}},`);
+    return lines.join('\n');
+}
+function getConfigValueSerialized(value, configName, configDefinedByFile) {
+    let configValueSerialized;
+    const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    try {
+        configValueSerialized = (0, stringify_1.stringify)(value, { valueName });
+    }
+    catch (err) {
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
+        (0, utils_js_1.assertUsage)(false, [
+            `The value of the config ${picocolors_1.default.cyan(configName)} cannot be defined inside the file ${configDefinedByFile}.`,
+            `Its value must be defined in an another file and then imported by ${configDefinedByFile} (because it isn't serializable: ${err.messageCore}).`,
+            `Only serializable config values can be defined inside ${configDefinedByFile}, see https://vike.dev/header-file.`
+        ].join(' '));
+    }
+    configValueSerialized = JSON.stringify(configValueSerialized);
+    return configValueSerialized;
+}
+function getConfigValueEagerImport(importFilePath, exportName, importStatements) {
+    let configValueEagerImport;
+    const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importFilePath);
+    importStatements.push(importStatement);
+    // TODO: expose all exports so that assertDefaultExport can be applied
+    configValueEagerImport = `${importVar}[${JSON.stringify(exportName)}]`;
+    return configValueEagerImport;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigSet = exports.getConfigEnv = void 0;
+const getConfigValueSource_js_1 = require("../../../shared/getConfigValueSource.js");
+const utils_js_1 = require("../../../utils.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+function getConfigEnv(pageConfig, configName) {
+    const configValueSource = (0, getConfigValueSource_js_1.getConfigValueSource)(pageConfig, configName);
+    if (!configValueSource)
+        return null;
+    if (configValueSource) {
+        return configValueSource.configEnv;
+    }
+    else {
+        // In case of effect/computed config values, there isn't any configValueSource
+        // TODO: make it work for custom config definitions
+        //  - Ideally set configValueSource also for effect/computed config values?
+        (0, utils_js_1.assert)(false, 'TODO');
+        /*
+        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
+        if (!configDef) return null
+        return configDef.env
+        */
+    }
+}
+exports.getConfigEnv = getConfigEnv;
+function isConfigSet(pageConfig, configName) {
+    const configValueSource = (0, getConfigValueSource_js_1.getConfigValueSource)(pageConfig, configName);
+    // Enable users to suppress global config values by overriding the config's value to null
+    if (configValueSource?.value === null)
+        return false;
+    return !!configValueSource;
+}
+exports.isConfigSet = isConfigSet;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigEnvMatch = void 0;
+function isConfigEnvMatch(configEnv, isForClientSide, isClientRouting) {
+    if (configEnv === '_routing-eager' || configEnv === 'config-only')
+        return false;
+    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
+        return false;
+    if (configEnv === '_routing-lazy' && isForClientSide && !isClientRouting)
+        return false;
+    return true;
+}
+exports.isConfigEnvMatch = isConfigEnvMatch;

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

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImportData = exports.parseImportData = exports.replaceImportStatements = void 0;
+// Playground: https://github.com/brillout/acorn-playground
+const acorn_1 = require("acorn");
+const utils_js_1 = require("../../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function replaceImportStatements(code, filePathToShowToUser) {
+    const spliceOperations = [];
+    const fileImports = [];
+    const imports = getImports(code);
+    if (imports.length === 0)
+        return { noImportStatement: true };
+    imports.forEach((node) => {
+        if (node.type !== 'ImportDeclaration')
+            return;
+        const importFilePath = node.source.value;
+        (0, utils_js_1.assert)(typeof importFilePath === 'string');
+        const { start, end } = node;
+        const importStatementCode = code.slice(start, end);
+        // No variable imported
+        if (node.specifiers.length === 0) {
+            const isWarning = !utils_js_1.styleFileRE.test(importFilePath);
+            let quote = indent(importStatementCode);
+            if (isWarning) {
+                quote = picocolors_1.default.cyan(quote);
+            }
+            else {
+                quote = picocolors_1.default.bold(picocolors_1.default.red(quote));
+            }
+            const errMsg = [
+                `As explained in https://vike.dev/header-file the following import in ${filePathToShowToUser} has no effect:`,
+                quote
+            ].join('\n');
+            if (!isWarning) {
+                (0, utils_js_1.assertUsage)(false, errMsg);
+            }
+            (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
+        }
+        let replacement = '';
+        node.specifiers.forEach((specifier) => {
+            (0, utils_js_1.assert)(specifier.type === 'ImportSpecifier' ||
+                specifier.type === 'ImportDefaultSpecifier' ||
+                specifier.type === 'ImportNamespaceSpecifier');
+            const importLocalName = specifier.local.name;
+            const importFileExportName = (() => {
+                if (specifier.type === 'ImportDefaultSpecifier')
+                    return 'default';
+                if (specifier.type === 'ImportNamespaceSpecifier')
+                    return '*';
+                {
+                    const imported = specifier.imported;
+                    if (imported)
+                        return imported.name;
+                }
+                return importLocalName;
+            })();
+            const importDataString = serializeImportData({ importFilePath, importFileExportName, importWasGenerated: true });
+            replacement += `const ${importLocalName} = '${importDataString}';`;
+            fileImports.push({
+                importStatementCode,
+                importDataString,
+                importLocalName
+            });
+        });
+        spliceOperations.push({
+            start,
+            end,
+            replacement
+        });
+    });
+    const codeMod = spliceMany(code, spliceOperations);
+    return { code: codeMod, fileImports, noImportStatement: false };
+}
+exports.replaceImportStatements = replaceImportStatements;
+function getImports(code) {
+    const { body } = (0, acorn_1.parse)(code, {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+        // https://github.com/acornjs/acorn/issues/1136
+    });
+    const imports = [];
+    body.forEach((node) => {
+        if (node.type === 'ImportDeclaration')
+            imports.push(node);
+    });
+    return imports;
+}
+const import_ = 'import';
+const SEP = ':';
+const zeroWidthSpace = '\u200b';
+function serializeImportData({ importFilePath, importFileExportName, importWasGenerated }) {
+    const tag = importWasGenerated ? zeroWidthSpace : '';
+    // `import:${importFilePath}:${importFilePath}`
+    return `${tag}${import_}${SEP}${importFilePath}${SEP}${importFileExportName}`;
+}
+function isImportData(str) {
+    return str.startsWith(import_ + SEP) || str.startsWith(zeroWidthSpace + import_ + SEP);
+}
+exports.isImportData = isImportData;
+function parseImportData(importDataString) {
+    if (!isImportData(importDataString)) {
+        return null;
+    }
+    let importWasGenerated = false;
+    if (importDataString.startsWith(zeroWidthSpace)) {
+        importWasGenerated = true;
+        (0, utils_js_1.assert)(zeroWidthSpace.length === 1);
+        importDataString = importDataString.slice(1);
+    }
+    const parts = importDataString.split(SEP).slice(1);
+    if (!importWasGenerated && parts.length === 1) {
+        const importFileExportName = 'default';
+        const importFilePath = parts[0];
+        return { importFilePath, importFileExportName, importWasGenerated, importDataString };
+    }
+    (0, utils_js_1.assert)(parts.length >= 2);
+    const importFileExportName = parts[parts.length - 1];
+    const importFilePath = parts.slice(0, -1).join(SEP);
+    return { importFilePath, importFileExportName, importWasGenerated, importDataString };
+}
+exports.parseImportData = parseImportData;
+function spliceMany(str, operations) {
+    let strMod = '';
+    let endPrev;
+    operations.forEach(({ start, end, replacement }) => {
+        if (endPrev !== undefined) {
+            (0, utils_js_1.assert)(endPrev < start);
+        }
+        else {
+            endPrev = 0;
+        }
+        const replaced = str.slice(start, end);
+        strMod +=
+            str.slice(endPrev, start) +
+                replacement +
+                // Preserve number of lines for source map
+                Array(replaced.split('\n').length - replacement.split('\n').length)
+                    .fill('\n')
+                    .join('');
+        endPrev = end;
+    });
+    strMod += str.slice(endPrev, str.length - 1);
+    return strMod;
+}
+function indent(str) {
+    return str
+        .split('\n')
+        .map((s) => `  ${s}`)
+        .join('\n');
+}