vike 0.4.142-commit-acfc159 → 0.4.143

package/dist/cjs/node/plugin/plugins/buildConfig.js

@@ -53,8 +53,10 @@ function buildConfig() {
         },
         async writeBundle(options, bundle) {
             const manifestEntry = bundle[manifestTempFile];
-            if (generateManifest) {
-                (0, utils_js_1.assert)(manifestEntry);
+            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
+            assert(generateManifest === !!manifestEntry)
+            */
+            if (manifestEntry) {
                 const { dir } = options;
                 (0, utils_js_1.assert)(dir);
                 const manifestFilePathOld = path_1.default.join(dir, manifestEntry.fileName);
@@ -64,9 +66,6 @@ function buildConfig() {
                 const manifestFilePathNew = path_1.default.join(dir, '..', 'assets.json');
                 await promises_1.default.rename(manifestFilePathOld, manifestFilePathNew);
             }
-            else {
-                (0, utils_js_1.assert)(!manifestEntry);
-            }
         }
     };
 }

package/dist/cjs/node/plugin/plugins/commonConfig.js

@@ -19,12 +19,7 @@ function commonConfig() {
         {
             name: 'vike-commonConfig-1',
             config: () => ({
-                appType: 'custom',
-                ssr: {
-                    // Needed as long as Vike is published as CJS.
-                    // TODO: can we remove this once Vike is published as ESM?
-                    external: ['vike', 'vike/server']
-                }
+                appType: 'custom'
             }),
             configResolved(config) {
                 (0, require_shim_1.installRequireShim_setUserRootDir)(config.root);

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

@@ -18,6 +18,7 @@ const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/remove
 const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
+const getVirtualFilePageConfigs_js_1 = require("./getVirtualFilePageConfigs.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -1078,6 +1079,8 @@ function mergeCumulative(configName, configValueSources) {
         /* This is more confusing than adding value. For example, this explanation shouldn't be shown for the passToClient config.
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
+        // Make sure configValueSource.value is serializable
+        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, configValueSource.definedAtInfo);
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVirtualFilePageConfigs = void 0;
+exports.getConfigValueSerialized = 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");
@@ -39,23 +39,22 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 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);
+                const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
+                const configValue2 = { definedAtInfo, valueSerialized };
+                serializeConfigValue(lines, configName, configValue2);
             }
             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);
+                    const configValue = { definedAtInfo, value: configValueEagerImport };
+                    serializeConfigValue(lines, configName, configValue);
                 }
             }
         });
@@ -94,16 +93,13 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     (0, debug_js_1.debug)(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function serializeConfigValue(lines, configName, configValue, valueSerialized) {
+function serializeConfigValue(lines, configName, configValue) {
     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)},`);
+        const valSerialized = key === 'value' || key === 'valueSerialized' ? val : JSON.stringify(val);
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
     });
     whitespace = whitespace.slice(2);
     lines.push(`${whitespace}},`);
@@ -119,7 +115,7 @@ function serializeConfigValueSource(configValueSource, configName, whitespace, i
     if ((0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting) || eager) {
         if ('value' in configValueSource) {
             const { value } = configValueSource;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo.filePath);
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
             lines.push(`${whitespace}  valueSerialized: ${valueSerialized}`);
         }
         else if (eager) {
@@ -133,7 +129,7 @@ function serializeConfigValueSource(configValueSource, configName, whitespace, i
     lines.push(`${whitespace}},`);
     return lines.join('\n');
 }
-function getConfigValueSerialized(value, configName, configDefinedByFile) {
+function getConfigValueSerialized(value, configName, definedAtInfo) {
     let configValueSerialized;
     const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
     try {
@@ -141,15 +137,22 @@ function getConfigValueSerialized(value, configName, configDefinedByFile) {
     }
     catch (err) {
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(err, 'messageCore', 'string'));
+        // definedAtInfo is null when config value is:
+        //  - computed => all computed values defined by Vike can are serializable
+        //  - cumulative => the values are already ensured to be serializable
+        (0, utils_js_1.assert)(definedAtInfo);
+        const configDefinedByFile = definedAtInfo.filePath;
+        (0, utils_js_1.assert)(configDefinedByFile);
         (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.`
+            `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 the value isn't serializable: ${err.messageCore}.)`,
+            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);
     return configValueSerialized;
 }
+exports.getConfigValueSerialized = getConfigValueSerialized;
 function getConfigValueEagerImport(importFilePath, exportName, importStatements) {
     let configValueEagerImport;
     const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(importFilePath);

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

@@ -55,7 +55,9 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     const { code, fileImports } = res;
     if (!isHeader) {
         const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
-        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, {
+            onlyOnce: true
+        });
     }
     return { code, fileImports };
 }
@@ -231,11 +233,11 @@ function assertFileImports(fileImports, fileExports, filePath) {
     const importStatements = (0, utils_js_1.unique)(fileImportsUnused.map((fi) => fi.importStatementCode));
     const importNamesUnused = fileImportsUnused.map((fi) => picocolors_1.default.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
-    (0, utils_js_1.assertWarning)(fileImportsUnused.length === 0, [
+    (0, utils_js_1.assertUsage)(fileImportsUnused.length === 0, [
         `${filePath} imports the following:`,
         ...importStatements.map((s) => picocolors_1.default.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${picocolors_1.default.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'), { onlyOnce: true });
+    ].join('\n'));
 }
 function getExportedStrings(obj) {
     const exportedStrings = [];

package/dist/cjs/node/runtime/html/stream.js

@@ -627,7 +627,10 @@ exports.isStreamPipeWeb = isStreamPipeWeb;
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', { onlyOnce: true, showStackTrace: true });
+    (0, utils_js_1.assertWarning)(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+        onlyOnce: true,
+        showStackTrace: true
+    });
     return { [__streamPipeNode]: pipe };
 }
 exports.pipeNodeStream = pipeNodeStream;

package/dist/cjs/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -7,7 +7,7 @@ const idBase = 'virtual:vike:pageConfigValuesAll:';
 const idBaseClient = `${idBase}client:`;
 const idBaseServer = `${idBase}server:`;
 function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
-    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    const id = `${isForClientSide ? idBaseClient : idBaseServer}${pageId}`;
     return id;
 }
 exports.getVirtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll;

package/dist/cjs/shared/getPageFiles/parseGlobResults.js

@@ -6,6 +6,7 @@ const assertExports_js_1 = require("./assertExports.js");
 const getPageFileObject_js_1 = require("./getPageFileObject.js");
 const fileTypes_js_1 = require("./fileTypes.js");
 const assertPageConfigs_js_1 = require("./assertPageConfigs.js");
+const parse_1 = require("@brillout/json-serializer/parse");
 function parseGlobResults(pageFilesExports) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageFilesExports, 'isGeneratedFile'));
     (0, utils_js_1.assert)(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -91,22 +92,21 @@ function assertLoadModule(globValue) {
     (0, utils_js_1.assert)((0, utils_js_1.isCallable)(globValue));
 }
 function parsePageConfigs(pageConfigs) {
-    // TODO: remove
-    /*
     pageConfigs.forEach((pageConfig) => {
-      Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
-        {
-          const { configValueSerialized } = configElement
-          if (configValueSerialized !== undefined) {
-            configElement.configValue = parse(configValueSerialized)
-          }
-        }
-        if (configName === 'route') {
-          assertRouteConfigValue(configElement)
-        }
-      })
-    })
-    */
+        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+            {
+                const { valueSerialized } = configValue;
+                if (valueSerialized !== undefined) {
+                    configValue.value = (0, parse_1.parse)(valueSerialized);
+                }
+            }
+            /*
+            if (configName === 'route') {
+              assertRouteConfigValue(configElement)
+            }
+            */
+        });
+    });
 }
 // TODO: use again
 // function assertRouteConfigValue(configElement: ConfigElement) {

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

@@ -55,7 +55,7 @@ function assertConfigValueType(value, type, configName, definedAtInfo) {
     const valuePrintable = (0, utils_js_1.getValuePrintable)(value);
     const problem = valuePrintable !== null ? `value ${picocolors_1.default.cyan(valuePrintable)}` : `type ${picocolors_1.default.cyan(typeActual)}`;
     const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: is should be a ${picocolors_1.default.cyan(type)} instead`);
+    (0, utils_js_1.assertUsage)(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${picocolors_1.default.cyan(type)} instead`);
 }
 function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
     let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${picocolors_1.default.cyan(configName)}`;

package/dist/cjs/shared/route/resolvePrecedence.js

@@ -35,37 +35,58 @@ function sortMatches(routeMatch1, routeMatch2) {
     if (!routeMatch1.routeString) {
         return 0;
     }
+    /* DEBUG
+    console.log('routeMatch1.routeString', routeMatch1.routeString)
+    console.log('routeMatch2.routeString', routeMatch2.routeString)
+    console.log('parseRouteString(routeMatch1.routeString)', parseRouteString(routeMatch1.routeString))
+    console.log('parseRouteString(routeMatch2.routeString)', parseRouteString(routeMatch2.routeString))
+    //*/
     // Return route with highest number of static path segments at beginning first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegmentsBeginning;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticPartsBeginning;
         const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticPartsBeginning', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticPartsBeginning', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
     // Return route with highest number of static path segments in total first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticSegements;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfStaticParts;
         const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticParts', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticParts', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return route with most parameter segements first
+    // Return route with least amount of globs first
     {
-        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfParameterSegments;
-        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfGlobs;
+        const result = (0, utils_js_1.lowerFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfGlobs', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfGlobs', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return catch-all routes last
+    // Return route with highest number of parameters first
     {
-        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch2.routeString).isCatchAll) {
-            return -1;
-        }
-        if ((0, resolveRouteString_js_1.analyzeRouteString)(routeMatch1.routeString).isCatchAll) {
-            return 1;
+        const getValue = (routeString) => (0, resolveRouteString_js_1.analyzeRouteString)(routeString).numberOfParams;
+        const result = (0, utils_js_1.higherFirst)(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfParams', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfParams', getValue(routeMatch2.routeString))
+            //*/
+            return result;
         }
     }
     return 0;

package/dist/cjs/shared/route/resolveRouteString.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertRouteString = exports.analyzeRouteString = exports.isStaticRouteString = exports.getUrlFromRouteString = exports.resolveRouteString = void 0;
+exports.parseRouteString = exports.assertRouteString = exports.analyzeRouteString = exports.isStaticRouteString = exports.getUrlFromRouteString = exports.resolveRouteString = void 0;
 const utils_js_1 = require("../utils.js");
 const utils_js_2 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
@@ -11,44 +11,105 @@ const PARAM_TOKEN_NEW = '@';
 // TODO/v1-release: remove
 const PARAM_TOKEN_OLD = ':';
 function assertRouteString(routeString, errPrefix = 'Invalid') {
-    (0, utils_js_2.assert)(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
-    (0, utils_js_2.assertUsage)(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
-    (0, utils_js_2.assertUsage)(routeString.startsWith('/') || routeString === '*', `${errPrefix} Route String ${highlight(routeString)}: Route Strings should start with a leading slash ${highlight('/')} (or be ${highlight('*')})`);
+    let errPrefix2 = `${errPrefix} Route String ${highlight(routeString)}`;
+    (0, utils_js_2.assertUsage)(routeString !== '', `${errPrefix2} (empty string): set it to ${highlight('/')} instead`);
+    (0, utils_js_2.assertUsage)(['/', '*'].includes(routeString[0]), `${errPrefix2}: it should start with ${highlight('/')} or ${highlight('*')}`);
+    (0, utils_js_2.assertUsage)(!routeString.includes('**'), `${errPrefix2}: set it to ${highlight(routeString.split('**').join('*'))} instead`);
 }
 exports.assertRouteString = assertRouteString;
 function resolveRouteString(routeString, urlPathname) {
     assertRouteString(routeString);
-    (0, utils_js_2.assert)(urlPathname.startsWith('/'));
-    const routeSegments = routeString.split('/');
-    const urlSegments = urlPathname.split('/');
-    const routeParams = {};
-    assertGlob(routeString);
-    if (routeString === '*') {
-        routeString = '/*';
-    }
-    for (let i = 0; i < Math.max(routeSegments.length, urlSegments.length); i++) {
-        const routeSegment = routeSegments[i];
-        const urlSegment = urlSegments[i];
-        if (routeSegment === '*') {
-            routeParams['*'] = urlSegments.slice(Math.max(1, i)).join('/');
-            return { routeParams };
+    const segments = parseRouteString(routeString);
+    const routeRegexStrInner = segments
+        .map((segment) => {
+        if (segment.param) {
+            return '[^/]+';
         }
-        else if (routeSegment && isParam(routeSegment)) {
-            (0, utils_js_1.assertWarning)(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${picocolors_1.default.cyan(routeString)}, use ${picocolors_1.default.cyan(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead.`, { onlyOnce: true });
-            if (!urlSegment) {
-                return null;
+        if (segment.glob) {
+            if (segment.isLastDir) {
+                return '|/.*';
             }
-            routeParams[routeSegment.slice(1)] = urlSegment;
-        }
-        else {
-            if ((routeSegment || '') !== (urlSegment || '')) {
-                return null;
+            else {
+                return '.*';
             }
         }
-    }
+        // segment.static
+        return (0, utils_js_1.escapeRegex)(segment.static);
+    })
+        .map((s) => `(${s})`)
+        .join('');
+    const routeRegex = new RegExp(`^${routeRegexStrInner}/?$`);
+    const routeRegexMatch = urlPathname.match(routeRegex);
+    /* DEBUG
+    console.log()
+    console.log('routeString', routeString)
+    console.log('urlPathname', urlPathname)
+    console.log('routeSegments', segments)
+    console.log('routeRegex', routeRegex)
+    console.log('routeRegexMatch', routeRegexMatch)
+    //*/
+    if (!routeRegexMatch)
+        return null;
+    const routeParams = {};
+    const [_, ...segmentsValue] = routeRegexMatch;
+    let globIdx = 0;
+    const hasMultipleGlobs = segments.filter((segment) => segment.glob).length > 1;
+    segments.forEach((segment, i) => {
+        let val = segmentsValue[i];
+        if (segment.param) {
+            routeParams[segment.param] = val;
+        }
+        if (segment.glob) {
+            const param = `*${hasMultipleGlobs ? ++globIdx : ''}`;
+            if (segment.isLastDir)
+                val = val.slice(1);
+            routeParams[param] = val;
+        }
+    });
     return { routeParams };
 }
 exports.resolveRouteString = resolveRouteString;
+function parseRouteString(routeString) {
+    const segments = [];
+    const pushStatic = (s) => {
+        const segmentLast = segments[segments.length - 1];
+        if (segmentLast?.static) {
+            segmentLast.static += s;
+        }
+        else {
+            segments.push({ static: s });
+        }
+    };
+    const parts = routeString.split('/');
+    parts.forEach((s, i) => {
+        const isFirst = i === 0;
+        const isLast = i === parts.length - 1;
+        if (isParam(s)) {
+            (0, utils_js_1.assertWarning)(!s.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${highlight(routeString)}, use ${highlight(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead`, { onlyOnce: true });
+            if (!isFirst)
+                pushStatic('/');
+            segments.push({ param: s.slice(1) });
+        }
+        else {
+            if (s === '*' && isLast && routeString !== '*' && routeString !== '/*') {
+                segments.push({ glob: true, isLastDir: true });
+            }
+            else {
+                if (!isFirst)
+                    pushStatic('/');
+                s.split('*').forEach((s, i) => {
+                    if (i !== 0)
+                        segments.push({ glob: true });
+                    if (s !== '') {
+                        pushStatic(s);
+                    }
+                });
+            }
+        }
+    });
+    return segments;
+}
+exports.parseRouteString = parseRouteString;
 function getUrlFromRouteString(routeString) {
     (0, utils_js_2.assert)(routeString.startsWith('/'));
     if (isStaticRouteString(routeString)) {
@@ -58,24 +119,19 @@ function getUrlFromRouteString(routeString) {
     return null;
 }
 exports.getUrlFromRouteString = getUrlFromRouteString;
-function assertGlob(routeString) {
-    const numberOfGlobChars = routeString.split('*').length - 1;
-    (0, utils_js_2.assertUsage)(numberOfGlobChars <= 1, `Invalid Route String ${highlight(routeString)}: Route Strings aren't allowed to contain more than one glob ${highlight('*')} (use a Route Function instead)`);
-    (0, utils_js_2.assertUsage)(numberOfGlobChars === 0 || (numberOfGlobChars === 1 && routeString.endsWith('*')), `Invalid Route String ${highlight(routeString)}: make sure it ends with ${highlight('*')} or use a Route Function`);
-}
 function analyzeRouteString(routeString) {
-    const routeSegments = routeString.split('/').filter((routeSegment) => routeSegment !== '' && routeSegment !== '*');
-    let numberOfStaticSegmentsBeginning = 0;
-    for (const routeSegment of routeSegments) {
-        if (isParam(routeSegment)) {
+    const segments = parseRouteString(routeString);
+    const countStaticParts = (s) => s?.split('/').filter(Boolean).length || 0;
+    let numberOfStaticPartsBeginning = 0;
+    for (const segment of segments) {
+        if (!segment.static)
             break;
-        }
-        numberOfStaticSegmentsBeginning++;
+        numberOfStaticPartsBeginning += countStaticParts(segment.static);
     }
-    const numberOfStaticSegements = routeSegments.filter((s) => !isParam(s)).length;
-    const numberOfParameterSegments = routeSegments.filter((s) => isParam(s)).length;
-    const isCatchAll = routeString.endsWith('*');
-    return { numberOfParameterSegments, numberOfStaticSegmentsBeginning, numberOfStaticSegements, isCatchAll };
+    const numberOfStaticParts = segments.map((s) => countStaticParts(s.static)).reduce((sum, a) => sum + a, 0);
+    const numberOfParams = segments.filter((s) => s.param).length;
+    const numberOfGlobs = segments.filter((s) => s.glob).length;
+    return { numberOfStaticPartsBeginning, numberOfStaticParts, numberOfParams, numberOfGlobs };
 }
 exports.analyzeRouteString = analyzeRouteString;
 function isParam(routeSegment) {

package/dist/cjs/shared/utils.js

@@ -41,3 +41,4 @@ __exportStar(require("../utils/checkType.js"), exports);
 __exportStar(require("../utils/assertDefaultExport.js"), exports);
 __exportStar(require("../utils/objectEntries.js"), exports);
 __exportStar(require("../utils/getValuePrintable.js"), exports);
+__exportStar(require("../utils/escapeRegex.js"), exports);

package/dist/cjs/types/defineConfig.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+function defineConfig(config) {
+    return config;
+}
+exports.defineConfig = defineConfig;

package/dist/cjs/types/index.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+var defineConfig_js_1 = require("./defineConfig.js");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return defineConfig_js_1.defineConfig; } });

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.142-commit-acfc159';
+const PROJECT_VERSION = '0.4.143';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -18,7 +18,9 @@ const linkPrefetchHandlerAdded = new Map();
  * @param url - The URL of the page you want to prefetch.
  */
 async function prefetch(url) {
-    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', { showStackTrace: true });
+    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
+        showStackTrace: true
+    });
     assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`, { showStackTrace: true });
     if (isAlreadyPrefetched(url))
         return;

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -50,8 +50,10 @@ function buildConfig() {
         },
         async writeBundle(options, bundle) {
             const manifestEntry = bundle[manifestTempFile];
-            if (generateManifest) {
-                assert(manifestEntry);
+            /* Fails with @vitejs/plugin-legacy because writeBundle() is called twice during the client build (once for normal client assets and a second time for legacy assets), see reproduction at https://github.com/vikejs/vike/issues/1154
+            assert(generateManifest === !!manifestEntry)
+            */
+            if (manifestEntry) {
                 const { dir } = options;
                 assert(dir);
                 const manifestFilePathOld = path.join(dir, manifestEntry.fileName);
@@ -61,9 +63,6 @@ function buildConfig() {
                 const manifestFilePathNew = path.join(dir, '..', 'assets.json');
                 await fs.rename(manifestFilePathOld, manifestFilePathNew);
             }
-            else {
-                assert(!manifestEntry);
-            }
         }
     };
 }

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -14,12 +14,7 @@ function commonConfig() {
         {
             name: 'vike-commonConfig-1',
             config: () => ({
-                appType: 'custom',
-                ssr: {
-                    // Needed as long as Vike is published as CJS.
-                    // TODO: can we remove this once Vike is published as ESM?
-                    external: ['vike', 'vike/server']
-                }
+                appType: 'custom'
             }),
             configResolved(config) {
                 installRequireShim_setUserRootDir(config.root);

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

@@ -16,6 +16,7 @@ import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } fro
 import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
+import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -1072,6 +1073,8 @@ function mergeCumulative(configName, configValueSources) {
         /* This is more confusing than adding value. For example, this explanation shouldn't be shown for the passToClient config.
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
+        // Make sure configValueSource.value is serializable
+        getConfigValueSerialized(configValueSource.value, configName, configValueSource.definedAtInfo);
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';

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

@@ -1,3 +1,6 @@
 export { getVirtualFilePageConfigs };
+export { getConfigValueSerialized };
+import type { DefinedAtInfo } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
 declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
+declare function getConfigValueSerialized(value: unknown, configName: string, definedAtInfo: null | DefinedAtInfo): string;

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

@@ -1,4 +1,5 @@
 export { getVirtualFilePageConfigs };
+export { getConfigValueSerialized };
 import { assert, assertUsage, getPropAccessNotation, hasProp, objectEntries } from '../../../utils.js';
 import { generateEagerImport } from '../generateEagerImport.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -33,23 +34,22 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
                 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);
+                const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
+                const configValue2 = { definedAtInfo, valueSerialized };
+                serializeConfigValue(lines, configName, configValue2);
             }
             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);
+                    const configValue = { definedAtInfo, value: configValueEagerImport };
+                    serializeConfigValue(lines, configName, configValue);
                 }
             }
         });
@@ -88,16 +88,13 @@ function getContent(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, i
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
-function serializeConfigValue(lines, configName, configValue, valueSerialized) {
+function serializeConfigValue(lines, configName, configValue) {
     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)},`);
+        const valSerialized = key === 'value' || key === 'valueSerialized' ? val : JSON.stringify(val);
+        lines.push(`${whitespace}  ${key}: ${valSerialized},`);
     });
     whitespace = whitespace.slice(2);
     lines.push(`${whitespace}},`);
@@ -113,7 +110,7 @@ function serializeConfigValueSource(configValueSource, configName, whitespace, i
     if (isConfigEnvMatch(configEnv, isForClientSide, isClientRouting) || eager) {
         if ('value' in configValueSource) {
             const { value } = configValueSource;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo.filePath);
+            const valueSerialized = getConfigValueSerialized(value, configName, definedAtInfo);
             lines.push(`${whitespace}  valueSerialized: ${valueSerialized}`);
         }
         else if (eager) {
@@ -127,7 +124,7 @@ function serializeConfigValueSource(configValueSource, configName, whitespace, i
     lines.push(`${whitespace}},`);
     return lines.join('\n');
 }
-function getConfigValueSerialized(value, configName, configDefinedByFile) {
+function getConfigValueSerialized(value, configName, definedAtInfo) {
     let configValueSerialized;
     const valueName = `config${getPropAccessNotation(configName)}`;
     try {
@@ -135,10 +132,16 @@ function getConfigValueSerialized(value, configName, configDefinedByFile) {
     }
     catch (err) {
         assert(hasProp(err, 'messageCore', 'string'));
+        // definedAtInfo is null when config value is:
+        //  - computed => all computed values defined by Vike can are serializable
+        //  - cumulative => the values are already ensured to be serializable
+        assert(definedAtInfo);
+        const configDefinedByFile = definedAtInfo.filePath;
+        assert(configDefinedByFile);
         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.`
+            `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 the value isn't serializable: ${err.messageCore}.)`,
+            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);

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

@@ -7,7 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import pc from '@brillout/picocolors';
 import { import_ } from '@brillout/import';
-import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertDefaultExportObject, unique, assertWarning, isObject, toPosixPath } from '../../../utils.js';
+import { assertPosixPath, getRandomId, assertIsNotProductionRuntime, assert, assertDefaultExportObject, unique, assertWarning, isObject, toPosixPath, assertUsage } from '../../../utils.js';
 import { isImportData, replaceImportStatements } from './replaceImportStatements.js';
 import { vikeConfigDependencies } from './getVikeConfig.js';
 import 'source-map-support/register.js';
@@ -52,7 +52,9 @@ function transpileImports(codeOriginal, filePath, isValueFile) {
     const { code, fileImports } = res;
     if (!isHeader) {
         const filePathCorrect = appendHeaderFileExtension(filePathToShowToUser);
-        assertWarning(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, { onlyOnce: true });
+        assertWarning(false, `Rename ${filePathToShowToUser} to ${filePathCorrect}, see https://vike.dev/header-file`, {
+            onlyOnce: true
+        });
     }
     return { code, fileImports };
 }
@@ -225,11 +227,11 @@ function assertFileImports(fileImports, fileExports, filePath) {
     const importStatements = unique(fileImportsUnused.map((fi) => fi.importStatementCode));
     const importNamesUnused = fileImportsUnused.map((fi) => pc.cyan(fi.importLocalName)).join(', ');
     const singular = fileImportsUnused.length === 1;
-    assertWarning(fileImportsUnused.length === 0, [
+    assertUsage(fileImportsUnused.length === 0, [
         `${filePath} imports the following:`,
         ...importStatements.map((s) => pc.cyan(`  ${s}`)),
         `But the import${singular ? '' : 's'} ${importNamesUnused} ${singular ? "isn't" : "aren't"} re-exported at ${pc.cyan('export default { ... }')} and therefore ${singular ? 'has' : 'have'} no effect, see explanation at https://vike.dev/header-file`
-    ].join('\n'), { onlyOnce: true });
+    ].join('\n'));
 }
 function getExportedStrings(obj) {
     const exportedStrings = [];

package/dist/esm/node/runtime/html/stream.js

@@ -628,7 +628,10 @@ function isStreamPipeWeb(thing) {
 const __streamPipeNode = '__streamPipeNode';
 /** @deprecated */
 function pipeNodeStream(pipe) {
-    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', { onlyOnce: true, showStackTrace: true });
+    assertWarning(false, 'pipeNodeStream() is outdated, use stampPipe() instead. See https://vike.dev/stream', {
+        onlyOnce: true,
+        showStackTrace: true
+    });
     return { [__streamPipeNode]: pipe };
 }
 function getStreamPipeNode(thing) {

package/dist/esm/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -6,7 +6,7 @@ const idBase = 'virtual:vike:pageConfigValuesAll:';
 const idBaseClient = `${idBase}client:`;
 const idBaseServer = `${idBase}server:`;
 function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
-    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    const id = `${isForClientSide ? idBaseClient : idBaseServer}${pageId}`;
     return id;
 }
 function isVirtualFileIdPageConfigValuesAll(id) {

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -4,6 +4,7 @@ import { assertExportValues } from './assertExports.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
 import { assertPageConfigGlobal, assertPageConfigs } from './assertPageConfigs.js';
+import { parse } from '@brillout/json-serializer/parse';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));
     assert(pageFilesExports.isGeneratedFile !== false, `vike was re-installed(/re-built). Restart your app.`);
@@ -88,22 +89,21 @@ function assertLoadModule(globValue) {
     assert(isCallable(globValue));
 }
 function parsePageConfigs(pageConfigs) {
-    // TODO: remove
-    /*
     pageConfigs.forEach((pageConfig) => {
-      Object.entries(pageConfig.configElements).forEach(([configName, configElement]) => {
-        {
-          const { configValueSerialized } = configElement
-          if (configValueSerialized !== undefined) {
-            configElement.configValue = parse(configValueSerialized)
-          }
-        }
-        if (configName === 'route') {
-          assertRouteConfigValue(configElement)
-        }
-      })
-    })
-    */
+        Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+            {
+                const { valueSerialized } = configValue;
+                if (valueSerialized !== undefined) {
+                    configValue.value = parse(valueSerialized);
+                }
+            }
+            /*
+            if (configName === 'route') {
+              assertRouteConfigValue(configElement)
+            }
+            */
+        });
+    });
 }
 // TODO: use again
 // function assertRouteConfigValue(configElement: ConfigElement) {

package/dist/esm/shared/page-configs/PageConfig.d.ts

@@ -44,6 +44,7 @@ type ConfigValueSource = {
 type ConfigValueSources = Record<string, ConfigValueSource[]>;
 type ConfigValue = {
     value: unknown;
+    valueSerialized?: string;
     definedAtInfo: null | DefinedAtInfo;
 };
 type ConfigValues = Record<string, ConfigValue>;

package/dist/esm/shared/page-configs/utils.js

@@ -51,7 +51,7 @@ function assertConfigValueType(value, type, configName, definedAtInfo) {
     const valuePrintable = getValuePrintable(value);
     const problem = valuePrintable !== null ? `value ${pc.cyan(valuePrintable)}` : `type ${pc.cyan(typeActual)}`;
     const configDefinedAt = getConfigDefinedAtString(configName, { definedAtInfo }, true);
-    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: is should be a ${pc.cyan(type)} instead`);
+    assertUsage(false, `${configDefinedAt} has an invalid ${problem}: it should be a ${pc.cyan(type)} instead`);
 }
 function getConfigDefinedAtString(configName, { definedAtInfo }, sentenceBegin, append) {
     let configDefinedAt = `${sentenceBegin ? `Config` : `config`} ${pc.cyan(configName)}`;

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

@@ -1,7 +1,7 @@
 export { resolvePrecendence };
 // export type { RouteMatch }
 import { analyzeRouteString } from './resolveRouteString.js';
-import { higherFirst } from './utils.js';
+import { higherFirst, lowerFirst } from './utils.js';
 import { makeFirst } from './utils.js';
 import { isStaticRouteString } from './resolveRouteString.js';
 // See https://vike.dev/route-function#precedence
@@ -32,37 +32,58 @@ function sortMatches(routeMatch1, routeMatch2) {
     if (!routeMatch1.routeString) {
         return 0;
     }
+    /* DEBUG
+    console.log('routeMatch1.routeString', routeMatch1.routeString)
+    console.log('routeMatch2.routeString', routeMatch2.routeString)
+    console.log('parseRouteString(routeMatch1.routeString)', parseRouteString(routeMatch1.routeString))
+    console.log('parseRouteString(routeMatch2.routeString)', parseRouteString(routeMatch2.routeString))
+    //*/
     // Return route with highest number of static path segments at beginning first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegmentsBeginning;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticPartsBeginning;
         const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticPartsBeginning', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticPartsBeginning', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
     // Return route with highest number of static path segments in total first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticSegements;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfStaticParts;
         const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfStaticParts', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfStaticParts', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return route with most parameter segements first
+    // Return route with least amount of globs first
     {
-        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParameterSegments;
-        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfGlobs;
+        const result = lowerFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
         if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfGlobs', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfGlobs', getValue(routeMatch2.routeString))
+            //*/
             return result;
         }
     }
-    // Return catch-all routes last
+    // Return route with highest number of parameters first
     {
-        if (analyzeRouteString(routeMatch2.routeString).isCatchAll) {
-            return -1;
-        }
-        if (analyzeRouteString(routeMatch1.routeString).isCatchAll) {
-            return 1;
+        const getValue = (routeString) => analyzeRouteString(routeString).numberOfParams;
+        const result = higherFirst(getValue)(routeMatch1.routeString, routeMatch2.routeString);
+        if (result !== 0) {
+            /* DEBUG
+            console.log('analyzeRouteString(routeMatch1.routeString).numberOfParams', getValue(routeMatch1.routeString))
+            console.log('analyzeRouteString(routeMatch2.routeString).numberOfParams', getValue(routeMatch2.routeString))
+            //*/
+            return result;
         }
     }
     return 0;

package/dist/esm/shared/route/resolveRouteString.d.ts

@@ -3,15 +3,32 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
+export { parseRouteString };
 declare function assertRouteString(routeString: string, errPrefix?: `${string}Invalid` | `${string}invalid`): void;
 declare function resolveRouteString(routeString: string, urlPathname: string): null | {
     routeParams: Record<string, string>;
 };
+type Segment = {
+    glob: true;
+    /** Make route /a/* match URL /a */
+    isLastDir?: true;
+    static?: undefined;
+    param?: undefined;
+} | {
+    glob?: undefined;
+    static: string;
+    param?: undefined;
+} | {
+    glob?: undefined;
+    static?: undefined;
+    param: string;
+};
+declare function parseRouteString(routeString: string): Segment[];
 declare function getUrlFromRouteString(routeString: string): null | string;
 declare function analyzeRouteString(routeString: string): {
-    numberOfParameterSegments: number;
-    numberOfStaticSegmentsBeginning: number;
-    numberOfStaticSegements: number;
-    isCatchAll: boolean;
+    numberOfStaticPartsBeginning: number;
+    numberOfStaticParts: number;
+    numberOfParams: number;
+    numberOfGlobs: number;
 };
 declare function isStaticRouteString(routeString: string): boolean;

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

@@ -3,48 +3,109 @@ export { getUrlFromRouteString };
 export { isStaticRouteString };
 export { analyzeRouteString };
 export { assertRouteString };
-import { assertWarning, isBrowser } from '../utils.js';
+export { parseRouteString };
+import { assertWarning, isBrowser, escapeRegex } from '../utils.js';
 import { assert, assertUsage } from './utils.js';
 import pc from '@brillout/picocolors';
 const PARAM_TOKEN_NEW = '@';
 // TODO/v1-release: remove
 const PARAM_TOKEN_OLD = ':';
 function assertRouteString(routeString, errPrefix = 'Invalid') {
-    assert(errPrefix.endsWith('Invalid') || errPrefix.endsWith('invalid'));
-    assertUsage(routeString !== '', `${errPrefix} Route String ${highlight(routeString)} (empty string): set it to ${highlight('/')} instead`);
-    assertUsage(routeString.startsWith('/') || routeString === '*', `${errPrefix} Route String ${highlight(routeString)}: Route Strings should start with a leading slash ${highlight('/')} (or be ${highlight('*')})`);
+    let errPrefix2 = `${errPrefix} Route String ${highlight(routeString)}`;
+    assertUsage(routeString !== '', `${errPrefix2} (empty string): set it to ${highlight('/')} instead`);
+    assertUsage(['/', '*'].includes(routeString[0]), `${errPrefix2}: it should start with ${highlight('/')} or ${highlight('*')}`);
+    assertUsage(!routeString.includes('**'), `${errPrefix2}: set it to ${highlight(routeString.split('**').join('*'))} instead`);
 }
 function resolveRouteString(routeString, urlPathname) {
     assertRouteString(routeString);
-    assert(urlPathname.startsWith('/'));
-    const routeSegments = routeString.split('/');
-    const urlSegments = urlPathname.split('/');
-    const routeParams = {};
-    assertGlob(routeString);
-    if (routeString === '*') {
-        routeString = '/*';
-    }
-    for (let i = 0; i < Math.max(routeSegments.length, urlSegments.length); i++) {
-        const routeSegment = routeSegments[i];
-        const urlSegment = urlSegments[i];
-        if (routeSegment === '*') {
-            routeParams['*'] = urlSegments.slice(Math.max(1, i)).join('/');
-            return { routeParams };
+    const segments = parseRouteString(routeString);
+    const routeRegexStrInner = segments
+        .map((segment) => {
+        if (segment.param) {
+            return '[^/]+';
         }
-        else if (routeSegment && isParam(routeSegment)) {
-            assertWarning(!routeSegment.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${pc.cyan(routeString)}, use ${pc.cyan(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead.`, { onlyOnce: true });
-            if (!urlSegment) {
-                return null;
+        if (segment.glob) {
+            if (segment.isLastDir) {
+                return '|/.*';
+            }
+            else {
+                return '.*';
             }
-            routeParams[routeSegment.slice(1)] = urlSegment;
+        }
+        // segment.static
+        return escapeRegex(segment.static);
+    })
+        .map((s) => `(${s})`)
+        .join('');
+    const routeRegex = new RegExp(`^${routeRegexStrInner}/?$`);
+    const routeRegexMatch = urlPathname.match(routeRegex);
+    /* DEBUG
+    console.log()
+    console.log('routeString', routeString)
+    console.log('urlPathname', urlPathname)
+    console.log('routeSegments', segments)
+    console.log('routeRegex', routeRegex)
+    console.log('routeRegexMatch', routeRegexMatch)
+    //*/
+    if (!routeRegexMatch)
+        return null;
+    const routeParams = {};
+    const [_, ...segmentsValue] = routeRegexMatch;
+    let globIdx = 0;
+    const hasMultipleGlobs = segments.filter((segment) => segment.glob).length > 1;
+    segments.forEach((segment, i) => {
+        let val = segmentsValue[i];
+        if (segment.param) {
+            routeParams[segment.param] = val;
+        }
+        if (segment.glob) {
+            const param = `*${hasMultipleGlobs ? ++globIdx : ''}`;
+            if (segment.isLastDir)
+                val = val.slice(1);
+            routeParams[param] = val;
+        }
+    });
+    return { routeParams };
+}
+function parseRouteString(routeString) {
+    const segments = [];
+    const pushStatic = (s) => {
+        const segmentLast = segments[segments.length - 1];
+        if (segmentLast?.static) {
+            segmentLast.static += s;
         }
         else {
-            if ((routeSegment || '') !== (urlSegment || '')) {
-                return null;
+            segments.push({ static: s });
+        }
+    };
+    const parts = routeString.split('/');
+    parts.forEach((s, i) => {
+        const isFirst = i === 0;
+        const isLast = i === parts.length - 1;
+        if (isParam(s)) {
+            assertWarning(!s.startsWith(PARAM_TOKEN_OLD), `Outdated Route String ${highlight(routeString)}, use ${highlight(routeString.split(PARAM_TOKEN_OLD).join(PARAM_TOKEN_NEW))} instead`, { onlyOnce: true });
+            if (!isFirst)
+                pushStatic('/');
+            segments.push({ param: s.slice(1) });
+        }
+        else {
+            if (s === '*' && isLast && routeString !== '*' && routeString !== '/*') {
+                segments.push({ glob: true, isLastDir: true });
+            }
+            else {
+                if (!isFirst)
+                    pushStatic('/');
+                s.split('*').forEach((s, i) => {
+                    if (i !== 0)
+                        segments.push({ glob: true });
+                    if (s !== '') {
+                        pushStatic(s);
+                    }
+                });
             }
         }
-    }
-    return { routeParams };
+    });
+    return segments;
 }
 function getUrlFromRouteString(routeString) {
     assert(routeString.startsWith('/'));
@@ -54,24 +115,19 @@ function getUrlFromRouteString(routeString) {
     }
     return null;
 }
-function assertGlob(routeString) {
-    const numberOfGlobChars = routeString.split('*').length - 1;
-    assertUsage(numberOfGlobChars <= 1, `Invalid Route String ${highlight(routeString)}: Route Strings aren't allowed to contain more than one glob ${highlight('*')} (use a Route Function instead)`);
-    assertUsage(numberOfGlobChars === 0 || (numberOfGlobChars === 1 && routeString.endsWith('*')), `Invalid Route String ${highlight(routeString)}: make sure it ends with ${highlight('*')} or use a Route Function`);
-}
 function analyzeRouteString(routeString) {
-    const routeSegments = routeString.split('/').filter((routeSegment) => routeSegment !== '' && routeSegment !== '*');
-    let numberOfStaticSegmentsBeginning = 0;
-    for (const routeSegment of routeSegments) {
-        if (isParam(routeSegment)) {
+    const segments = parseRouteString(routeString);
+    const countStaticParts = (s) => s?.split('/').filter(Boolean).length || 0;
+    let numberOfStaticPartsBeginning = 0;
+    for (const segment of segments) {
+        if (!segment.static)
             break;
-        }
-        numberOfStaticSegmentsBeginning++;
+        numberOfStaticPartsBeginning += countStaticParts(segment.static);
     }
-    const numberOfStaticSegements = routeSegments.filter((s) => !isParam(s)).length;
-    const numberOfParameterSegments = routeSegments.filter((s) => isParam(s)).length;
-    const isCatchAll = routeString.endsWith('*');
-    return { numberOfParameterSegments, numberOfStaticSegmentsBeginning, numberOfStaticSegements, isCatchAll };
+    const numberOfStaticParts = segments.map((s) => countStaticParts(s.static)).reduce((sum, a) => sum + a, 0);
+    const numberOfParams = segments.filter((s) => s.param).length;
+    const numberOfGlobs = segments.filter((s) => s.glob).length;
+    return { numberOfStaticPartsBeginning, numberOfStaticParts, numberOfParams, numberOfGlobs };
 }
 function isParam(routeSegment) {
     return routeSegment.startsWith(PARAM_TOKEN_NEW) || routeSegment.startsWith(PARAM_TOKEN_OLD);

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

@@ -21,3 +21,4 @@ export * from '../utils/checkType.js';
 export * from '../utils/assertDefaultExport.js';
 export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
+export * from '../utils/escapeRegex.js';

package/dist/esm/shared/utils.js

@@ -25,3 +25,4 @@ export * from '../utils/checkType.js';
 export * from '../utils/assertDefaultExport.js';
 export * from '../utils/objectEntries.js';
 export * from '../utils/getValuePrintable.js';
+export * from '../utils/escapeRegex.js';

package/dist/esm/types/defineConfig.d.ts

@@ -0,0 +1,3 @@
+export { defineConfig };
+import type { Config } from '../shared/page-configs/Config.js';
+declare function defineConfig(config: Config): Config;

package/dist/esm/types/defineConfig.js

@@ -0,0 +1,4 @@
+export { defineConfig };
+function defineConfig(config) {
+    return config;
+}

package/dist/esm/types/index.d.ts

@@ -11,6 +11,7 @@ export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
+export { defineConfig } from './defineConfig.js';
 import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 /** @deprecated Replace:
  *   `import type { Env } from 'vike/types'`

package/dist/esm/types/index.js

@@ -1 +1 @@
-export {};
+export { defineConfig } from './defineConfig.js';

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

@@ -5,7 +5,7 @@ type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.142-commit-acfc159";
+    projectVersion: "0.4.143";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.142-commit-acfc159';
+const PROJECT_VERSION = '0.4.143';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.142-commit-acfc159",
+  "version": "0.4.143",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -16,7 +16,7 @@
     "@brillout/json-serializer": "^0.5.6",
     "@brillout/picocolors": "^1.0.9",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-import-build": "^0.2.18",
+    "@brillout/vite-plugin-import-build": "^0.2.20",
     "acorn": "^8.8.2",
     "cac": "^6.7.14",
     "es-module-lexer": "^1.3.0",