vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.d.ts

@@ -0,0 +1,3 @@
+export { getVirtualFilePageConfigValuesAll };
+import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
+declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;

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

@@ -0,0 +1,73 @@
+export { getVirtualFilePageConfigValuesAll };
+import { assert, assertPosixPath } from '../../../utils.js';
+import { generateEagerImport } from '../generateEagerImport.js';
+import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { getVikeConfig } from './getVikeConfig.js';
+import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
+import { debug } from './debug.js';
+import path from 'path';
+import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSource.js';
+import { isConfigEnvMatch } from './isConfigEnvMatch.js';
+async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
+    const result = isVirtualFileIdPageConfigValuesAll(id);
+    assert(result);
+    /* This assertion fails when using includeAssetsImportedByServer
+    {
+      const isForClientSide = !config.build.ssr
+      assert(result.isForClientSide === isForClientSide)
+    }
+    */
+    const { pageId, isForClientSide } = result;
+    const { pageConfigs } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+    const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
+    assert(pageConfig);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
+    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+    const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
+    const isClientRouting = configValue?.value ?? false;
+    const lines = [];
+    const importStatements = [];
+    lines.push('export default [');
+    let varCounter = 0;
+    getConfigValueSourcesRelevant(pageConfig).forEach((configValueSource) => {
+        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+        if (!valueIsImportedAtRuntime)
+            return;
+        if (configValueSource.valueIsFilePath)
+            return;
+        if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
+            return;
+        const { filePath, fileExportPath } = definedAtInfo;
+        assertPosixPath(filePath);
+        const fileName = path.posix.basename(filePath);
+        const isPlusFile = fileName.startsWith('+');
+        const fileExportName = fileExportPath[0];
+        assert(!configValueSource.valueIsFilePath);
+        assert(fileExportName);
+        const { importVar, importStatement } = 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},`);
+            assert(fileExportName);
+            lines.push(`    importFileExportName: ${JSON.stringify(fileExportName)},`);
+        }
+        lines.push(`  },`);
+    });
+    lines.push('];');
+    if (includeAssetsImportedByServer && isForClientSide && !isDev) {
+        lines.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
+    }
+    const code = [...importStatements, ...lines].join('\n');
+    return code;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.d.ts

@@ -0,0 +1,3 @@
+export { getVirtualFilePageConfigs };
+import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
+declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;

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

@@ -0,0 +1,154 @@
+export { getVirtualFilePageConfigs };
+import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
+import { generateEagerImport } from '../generateEagerImport.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { debug } from './debug.js';
+import { stringify } from '@brillout/json-serializer/stringify';
+import { getConfigEnv } from './helpers.js';
+import pc from '@brillout/picocolors';
+import { getVikeConfig } from './getVikeConfig.js';
+import { isConfigEnvMatch } from './isConfigEnvMatch.js';
+async function getVirtualFilePageConfigs(userRootDir, isForClientSide, isDev, id, configVike, isClientRouting) {
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(userRootDir, isDev, configVike.extensions, true);
+    return getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+}
+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 = 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 = getConfigEnv(pageConfig, configName);
+                assert(configEnv, configName);
+                if (!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];
+                assert(configValueSource);
+                if (configValueSource.configEnv === '_routing-eager') {
+                    const { definedAtInfo } = configValueSource;
+                    const configValue = { configName, definedAtInfo };
+                    assert(!configValueSource.isComputed);
+                    const { filePath, fileExportPath } = configValueSource.definedAtInfo;
+                    const [exportName] = fileExportPath;
+                    assert(exportName);
+                    const configValueEagerImport = getConfigValueEagerImport(filePath, exportName, importStatements);
+                    serializeConfigValue(lines, configName, configValue, configValueEagerImport);
+                }
+            }
+        });
+        lines.push(`    },`);
+        lines.push(`  },`);
+    });
+    lines.push('];');
+    lines.push('export const pageConfigGlobal = {');
+    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 {
+            assert(false);
+        }
+        let whitespace = '  ';
+        let content;
+        if (configValueSource === null) {
+            content = 'null,';
+        }
+        else {
+            content = serializeConfigValueSource(configValueSource, configName, whitespace, isForClientSide, isClientRouting, importStatements, true);
+            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');
+    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) {
+    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 (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;
+            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${getPropAccessNotation(configName)}`;
+    try {
+        configValueSerialized = stringify(value, { valueName });
+    }
+    catch (err) {
+        assert(hasProp(err, 'messageCore', 'string'));
+        assertUsage(false, [
+            `The value of the config ${pc.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 } = generateEagerImport(importFilePath);
+    importStatements.push(importStatement);
+    // TODO: expose all exports so that assertDefaultExport can be applied
+    configValueEagerImport = `${importVar}[${JSON.stringify(exportName)}]`;
+    return configValueEagerImport;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/helpers.d.ts

@@ -0,0 +1,5 @@
+export { getConfigEnv };
+export { isConfigSet };
+import type { ConfigEnvInternal, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+declare function getConfigEnv(pageConfig: PageConfigBuildTime, configName: string): null | ConfigEnvInternal;
+declare function isConfigSet(pageConfig: PageConfigBuildTime, configName: string): boolean;

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

@@ -0,0 +1,31 @@
+export { getConfigEnv };
+export { isConfigSet };
+import { getConfigValueSource } from '../../../shared/getConfigValueSource.js';
+import { assert, assertIsNotProductionRuntime } from '../../../utils.js';
+assertIsNotProductionRuntime();
+function getConfigEnv(pageConfig, configName) {
+    const configValueSource = 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?
+        assert(false, 'TODO');
+        /*
+        const configDef = configDefinitionsBuiltIn[configName as keyof typeof configDefinitionsBuiltIn]
+        if (!configDef) return null
+        return configDef.env
+        */
+    }
+}
+function isConfigSet(pageConfig, configName) {
+    const configValueSource = 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;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/isConfigEnvMatch.d.ts

@@ -0,0 +1,3 @@
+export { isConfigEnvMatch };
+import type { ConfigEnvInternal } from '../../../../../shared/page-configs/PageConfig.js';
+declare function isConfigEnvMatch(configEnv: ConfigEnvInternal, isForClientSide: boolean, isClientRouting: boolean): boolean;

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

@@ -0,0 +1,10 @@
+export { isConfigEnvMatch };
+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;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/replaceImportStatements.d.ts

@@ -0,0 +1,31 @@
+export { replaceImportStatements };
+export { parseImportData };
+export { isImportData };
+export type { FileImport };
+export type { ImportData };
+type FileImport = {
+    importStatementCode: string;
+    importDataString: string;
+    importLocalName: string;
+};
+declare function replaceImportStatements(code: string, filePathToShowToUser: string): {
+    noImportStatement: true;
+} | {
+    noImportStatement: false;
+    code: string;
+    fileImports: FileImport[];
+};
+type ImportData = {
+    importFilePath: string;
+    importFileExportName: string;
+    importWasGenerated: boolean;
+    importDataString: string;
+};
+declare function isImportData(str: string): boolean;
+declare function parseImportData(importDataString: string): null | ImportData;
+declare module 'estree' {
+    interface BaseNodeWithoutComments {
+        start: number;
+        end: number;
+    }
+}

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

@@ -0,0 +1,148 @@
+export { replaceImportStatements };
+export { parseImportData };
+export { isImportData };
+// Playground: https://github.com/brillout/acorn-playground
+import { parse } from 'acorn';
+import { assert, assertUsage, assertWarning, styleFileRE } from '../../../utils.js';
+import pc from '@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;
+        assert(typeof importFilePath === 'string');
+        const { start, end } = node;
+        const importStatementCode = code.slice(start, end);
+        // No variable imported
+        if (node.specifiers.length === 0) {
+            const isWarning = !styleFileRE.test(importFilePath);
+            let quote = indent(importStatementCode);
+            if (isWarning) {
+                quote = pc.cyan(quote);
+            }
+            else {
+                quote = pc.bold(pc.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) {
+                assertUsage(false, errMsg);
+            }
+            assertWarning(false, errMsg, { onlyOnce: true });
+        }
+        let replacement = '';
+        node.specifiers.forEach((specifier) => {
+            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 };
+}
+function getImports(code) {
+    const { body } = 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);
+}
+function parseImportData(importDataString) {
+    if (!isImportData(importDataString)) {
+        return null;
+    }
+    let importWasGenerated = false;
+    if (importDataString.startsWith(zeroWidthSpace)) {
+        importWasGenerated = true;
+        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 };
+    }
+    assert(parts.length >= 2);
+    const importFileExportName = parts[parts.length - 1];
+    const importFilePath = parts.slice(0, -1).join(SEP);
+    return { importFilePath, importFileExportName, importWasGenerated, importDataString };
+}
+function spliceMany(str, operations) {
+    let strMod = '';
+    let endPrev;
+    operations.forEach(({ start, end, replacement }) => {
+        if (endPrev !== undefined) {
+            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');
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/transpileAndExecuteFile.d.ts

@@ -0,0 +1,12 @@
+export { transpileAndExecuteFile };
+export { getConfigBuildErrorFormatted };
+export { getConfigExececutionErrorIntroMsg };
+export { isTmpFile };
+import 'source-map-support/register.js';
+import { type FilePath } from './getFilePathToShowToUser.js';
+declare function transpileAndExecuteFile(filePath: FilePath, isValueFile: boolean, userRootDir: string): Promise<{
+    fileExports: Record<string, unknown>;
+}>;
+declare function getConfigBuildErrorFormatted(err: unknown): null | string;
+declare function getConfigExececutionErrorIntroMsg(err: unknown): string | null;
+declare function isTmpFile(filePath: string): boolean;