vike 0.4.142-commit-acfc159 → 0.4.143-commit-f03b42d

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

@@ -137,19 +137,17 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        if (pageConfigGlobal.onBeforeRoute) {
-            const hookFn = pageConfigGlobal.onBeforeRoute.value;
-            if (hookFn) {
-                assert(!pageConfigGlobal.onBeforeRoute.isComputed);
-                const hookFilePath = pageConfigGlobal.onBeforeRoute.definedAtInfo.filePath;
-                assert(hookFilePath);
-                assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
-                const onBeforeRouteHook = {
-                    hookFilePath: hookFilePath,
-                    onBeforeRoute: hookFn
-                };
-                return { onBeforeRouteHook, filesystemRoots: null };
-            }
+        if (pageConfigGlobal.configValues.onBeforeRoute?.value) {
+            const { value: hookFn, definedAtInfo } = pageConfigGlobal.configValues.onBeforeRoute;
+            // config.onBeforeRoute isn't a computed nor a cumulative config => definedAtInfo should always be defined
+            assert(definedAtInfo);
+            const hookFilePath = definedAtInfo.filePath;
+            assertUsage(isCallable(hookFn), `The hook onBeforeRoute() defined by ${hookFilePath} should be a function.`);
+            const onBeforeRouteHook = {
+                hookFilePath: hookFilePath,
+                onBeforeRoute: hookFn
+            };
+            return { onBeforeRouteHook, filesystemRoots: null };
         }
         return { onBeforeRouteHook: null, filesystemRoots: null };
     }

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/resolveRedirects.js

@@ -7,7 +7,7 @@ import { assertRouteString, resolveRouteString } from './resolveRouteString.js';
 import pc from '@brillout/picocolors';
 assertIsNotBrowser(); // Don't bloat the client
 // TODO/v1-release: update
-const configSrc = '[vite.config.js > ssr({ redirects })]';
+const configSrc = '[vite.config.js > vike({ redirects })]';
 function resolveRedirects(redirects, urlPathname) {
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
         const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);

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

@@ -20,6 +20,7 @@ async function resolveRouteFunction(routeFunction, pageContext, routeDefinedAt)
         result = {};
     }
     assertUsage(isPlainObject(result), `The Route Function ${routeDefinedAt} should return a boolean or a plain JavaScript object (but it's ${pc.cyan(`typeof result === ${JSON.stringify(typeof result)}`)} instead)`);
+    // AFAICT this return interface is superfluous. Should we soft-deprecate it and remove it?
     if ('match' in result) {
         const { match } = result;
         assertUsage(typeof match === 'boolean', `The ${pc.cyan('match')} value returned by the Route Function ${routeDefinedAt} should be a boolean.`);

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/types.d.ts

@@ -12,12 +12,10 @@ import type { ConfigEntries, ExportsAll } from './getPageFiles/getExports.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';
-type PageContext = PageContextWithClientRouting;
-type PageContextClient = PageContextClientWithClientRouting;
-type PageContextWithClientRouting = PageContextClientWithClientRouting | PageContextServer;
-type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
 type PageContextServer = PageContextBuiltInServer & Vike.PageContext;
-type PageContextClientWithClientRouting = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
+type PageContext = PageContextClient | PageContextServer;
+type PageContextClient = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
+type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
 type PageContextClientWithServerRouting = PageContextBuiltInClientWithServerRouting & Vike.PageContext;
 /** Built-in `pageContext` properties set by vike.
  *
@@ -57,7 +55,10 @@ type PageContextBuiltInCommon<Page = [never]> = {
      * https://vike.dev/exports
      */
     exportsAll: ExportsAll;
-    /** The URL of the current page */
+    /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
+     *
+     * https://vike.dev/renderPage
+     */
     urlOriginal: string;
     /** If an error occurs, whether the error is a `404 Page Not Found`.
      *

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

@@ -18,6 +18,6 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/hasPropertyGetter.js';
 export * from '../utils/isPromise.js';
 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

@@ -22,6 +22,6 @@ export * from '../utils/projectInfo.js';
 export * from '../utils/hasPropertyGetter.js';
 export * from '../utils/isPromise.js';
 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

@@ -6,11 +6,12 @@ export type { PageContextClientWithServerRouting } from '../shared/types.js';
 export type { PageContextBuiltInServer } from '../shared/types.js';
 export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
 export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
-export type { Config, ConfigMeta as Meta } from '../shared/page-configs/Config.js';
+export type { Config, ConfigMeta as Meta, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync } from '../shared/page-configs/Config.js';
 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/objectAssign.js

@@ -3,5 +3,7 @@ export { objectAssign };
 //  - With type inference
 //  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
 function objectAssign(obj, objAddendum) {
-    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    if (objAddendum) {
+        Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+    }
 }

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-commit-f03b42d";
     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-commit-f03b42d';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

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

@@ -0,0 +1,2 @@
+export { requireResolve };
+declare function requireResolve(importPath: string, cwd: string): string | null;

package/dist/esm/utils/{resolve.js → requireResolve.js}

@@ -1,4 +1,4 @@
-export { resolve };
+export { requireResolve };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
@@ -10,7 +10,7 @@ const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-function resolve(importPath, cwd) {
+function requireResolve(importPath, cwd) {
     assertPosixPath(cwd);
     const clean = addFileExtensionsToRequireResolve();
     importPath = removeFileExtention(importPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.142-commit-acfc159",
+  "version": "0.4.143-commit-f03b42d",
   "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",
@@ -163,7 +163,7 @@
   },
   "devDependencies": {
     "@brillout/part-regex": "^0.1.2",
-    "@brillout/release-me": "^0.1.7",
+    "@brillout/release-me": "^0.1.8",
     "@types/estree": "^1.0.0",
     "@types/jest": "^27.4.1",
     "@types/node": "^20.1.0",

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

@@ -1,63 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPageCode = void 0;
-const utils_js_1 = require("../utils.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function loadPageCode(pageConfig, isDev) {
-    if (pageConfig.isLoaded &&
-        // We don't need to cache in dev, since Vite already caches the virtual module
-        !isDev) {
-        return pageConfig;
-    }
-    const codeFiles = await pageConfig.loadConfigValuesAll();
-    // TODO: remove?
-    // pageConfig.configValuesOld = pageConfig.configValuesOld.filter((val) => !val.definedByCodeFile)
-    const addConfigValue = (configName, value, filePath, exportName) => {
-        /* TODO
-        assert(!isAlreadyDefined(val.configName), val.configName) // Conflicts are resolved upstream
-        */
-        pageConfig.configValues[configName] = {
-            value,
-            definedAtInfo: {
-                filePath,
-                fileExportPath: [exportName]
-            }
-            /* TODO: remove?
-            definedByCodeFile: true
-            */
-        };
-        assertIsNotNull(value, configName, filePath);
-    };
-    codeFiles.forEach((codeFile) => {
-        if (codeFile.isPlusFile) {
-            const { importFileExports, importFilePath } = codeFile;
-            if (codeFile.configName !== 'client') {
-                (0, utils_js_1.assertDefaultExportUnknown)(importFileExports, importFilePath);
-            }
-            Object.entries(importFileExports).forEach(([exportName, exportValue]) => {
-                const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`
-                const configName = isSideExport ? exportName : codeFile.configName;
-                if (isSideExport && configName in pageConfig.configValues) {
-                    // We can't avoid side-export conflicts upstream. (Because we cannot know about side-exports upstream at build-time.)
-                    // Side-exports have the lowest priority.
-                    return;
-                }
-                addConfigValue(configName, exportValue, importFilePath, exportName);
-            });
-        }
-        else {
-            const { configName, importFilePath, importFileExportValue, importFileExportName } = codeFile;
-            addConfigValue(configName, importFileExportValue, importFilePath, importFileExportName);
-        }
-    });
-    (0, utils_js_1.objectAssign)(pageConfig, { isLoaded: true });
-    return pageConfig;
-}
-exports.loadPageCode = loadPageCode;
-function assertIsNotNull(configValue, configName, importFilePath) {
-    (0, utils_js_1.assert)(!importFilePath.includes('+config.'));
-    (0, utils_js_1.assertUsage)(configValue !== null, `Set ${picocolors_1.default.cyan(configName)} to ${picocolors_1.default.cyan('null')} in a +config.h.js file instead of ${importFilePath}`);
-}

package/dist/cjs/utils/assertDefaultExport.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertDefaultExportObject = exports.assertDefaultExportUnknown = void 0;
-const assert_js_1 = require("./assert.js");
-const isObject_js_1 = require("./isObject.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const IGNORE = [
-    // vite-plugin-solid adds `export { $$registrations }`
-    '$$registrations',
-    // @vitejs/plugin-vue adds `export { _rerender_only }`
-    '_rerender_only'
-];
-// support `export { frontmatter }` in .mdx files
-const FILES_WITH_SIDE_EXPORTS = ['.md', '.mdx'];
-function assertDefaultExportUnknown(fileExports, filePath) {
-    assertSingleDefaultExport(fileExports, filePath, true);
-}
-exports.assertDefaultExportUnknown = assertDefaultExportUnknown;
-function assertDefaultExportObject(fileExports, filePath) {
-    assertSingleDefaultExport(fileExports, filePath, false);
-    const exportDefault = fileExports.default;
-    (0, assert_js_1.assertUsage)((0, isObject_js_1.isObject)(exportDefault), `The ${picocolors_1.default.cyan('export default')} of ${filePath} should be an object (but it's ${picocolors_1.default.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
-}
-exports.assertDefaultExportObject = assertDefaultExportObject;
-function assertSingleDefaultExport(fileExports, filePath, defaultExportValueIsUnknown) {
-    const exportsAll = Object.keys(fileExports);
-    const exportsRelevant = exportsAll.filter((exportName) => !IGNORE.includes(exportName));
-    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default');
-    const exportsHasDefault = exportsRelevant.includes('default');
-    if (exportsInvalid.length === 0) {
-        if (exportsHasDefault) {
-            return;
-        }
-        else {
-            (0, assert_js_1.assert)(exportsRelevant.length === 0);
-            (0, assert_js_1.assertUsage)(false, `${filePath} doesn't export any value, but it should have a ${picocolors_1.default.cyan('export default')} instead`);
-        }
-    }
-    else if (!FILES_WITH_SIDE_EXPORTS.some((ext) => filePath.endsWith(ext))) {
-        if (defaultExportValueIsUnknown) {
-            exportsInvalid.forEach((exportInvalid) => {
-                (0, assert_js_1.assertWarning)(exportsInvalid.length === 0, `${filePath} should only have a default export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
-            });
-        }
-        else {
-            const exportsInvalidStr = exportsInvalid.join(', ');
-            (0, assert_js_1.assertWarning)(exportsInvalid.length === 0, `${filePath} replace ${picocolors_1.default.cyan(`export { ${exportsInvalidStr} }`)} with ${picocolors_1.default.cyan(`export default { ${exportsInvalidStr} }`)}`, { onlyOnce: true });
-        }
-    }
-}

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

@@ -1,3 +0,0 @@
-export { loadPageCode };
-import type { PageConfig, PageConfigLoaded } from './PageConfig.js';
-declare function loadPageCode(pageConfig: PageConfig, isDev: boolean): Promise<PageConfigLoaded>;