vike 0.4.168-commit-ce94f5c → 0.4.168-commit-42406a9

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

@@ -25,12 +25,7 @@ function resolveRouteString(routeString, urlPathname) {
             return '[^/]+';
         }
         if (segment.glob) {
-            if (segment.isLastDir) {
-                return '|/.*';
-            }
-            else {
-                return '.*';
-            }
+            return '.*';
         }
         // segment.static
         return escapeRegex(segment.static);
@@ -60,8 +55,6 @@ function resolveRouteString(routeString, urlPathname) {
         }
         if (segment.glob) {
             const param = `*${hasMultipleGlobs ? ++globIdx : ''}`;
-            if (segment.isLastDir)
-                val = val.slice(1);
             routeParams[param] = val;
         }
     });
@@ -80,21 +73,17 @@ function parseRouteString(routeString) {
     };
     const parts = routeString.split('/');
     parts.forEach((s, i) => {
-        const isFirst = i === 0;
-        const isLast = i === parts.length - 1;
+        if (i !== 0)
+            pushStatic('/');
         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 });
+            if (s === '*' && i === parts.length - 1 && routeString !== '*' && routeString !== '/*') {
+                segments.push({ glob: true });
             }
             else {
-                if (!isFirst)
-                    pushStatic('/');
                 s.split('*').forEach((s, i) => {
                     if (i !== 0)
                         segments.push({ glob: true });

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

@@ -6,7 +6,6 @@ export * from '../../utils/isPromise.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/slice.js';
-export * from '../../utils/isStringRecord.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/isBrowser.js';
 export * from '../../utils/parseUrl.js';

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

@@ -15,7 +15,6 @@ export * from '../../utils/isPromise.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/objectAssign.js';
 export * from '../../utils/slice.js';
-export * from '../../utils/isStringRecord.js';
 export * from '../../utils/unique.js';
 export * from '../../utils/isBrowser.js';
 export * from '../../utils/parseUrl.js';

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

@@ -20,3 +20,4 @@ export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';
+export * from '../utils/isArray.js';

package/dist/esm/shared/utils.js

@@ -24,3 +24,4 @@ export * from '../utils/isPromise.js';
 export * from '../utils/checkType.js';
 export * from '../utils/getValuePrintable.js';
 export * from '../utils/escapeRegex.js';
+export * from '../utils/isArray.js';

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

@@ -0,0 +1,6 @@
+export { assertPathFilesystemAbsolute };
+export { isPathFilesystemAbsolute };
+/** Assert path is absolute starting from the filesystem root. */
+declare function assertPathFilesystemAbsolute(p: string): void;
+/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
+declare function isPathFilesystemAbsolute(p: string): boolean;

package/dist/esm/utils/assertPathFilesystemAbsolute.js

@@ -0,0 +1,33 @@
+export { assertPathFilesystemAbsolute };
+export { isPathFilesystemAbsolute };
+import path from 'path';
+import { assert } from './assert.js';
+import { assertPosixPath } from './filesystemPathHandling.js';
+/** Assert path is absolute starting from the filesystem root. */
+function assertPathFilesystemAbsolute(p) {
+    // The assert is "eventually reliable":
+    // - For Windows users, the assert is correct.
+    // - For Linux users assertPathFilesystemAbsolute() will erroneously succeed if `p` is a path absolute from the user root dir.
+    //   - But that's okay because the assertion will eventually fail for Windows users.
+    assert(isPathFilesystemAbsolute(p));
+}
+/** Whether path is absolute starting from the filesystem root. Isn't reliable for Linux users: isPathFilesystemAbsolute() returns `true` for paths absolute from the user root dir. */
+function isPathFilesystemAbsolute(p) {
+    assertPosixPath(p);
+    assert(!p.startsWith('/@fs/'));
+    if (process.platform !== 'win32') {
+        // - For linux users, there doesn't seem to be a reliable way to distinguish between:
+        //   - File path absolute starting from filesystem root, e.g. /home/rom/code/my-app/pages/about/+Page.js
+        //   - File path absolute starting from user root dir (Vite's `config.root`), e.g. /pages/about/+Page.js
+        // - Checking whether `p` starts with the first directory of process.cwd() (or `userRootDir`) can be erroneous, most notably when using docker: https://github.com/vikejs/vike/issues/703
+        // - Using require.resolve() would be a solution but probably too slow?
+        return p.startsWith('/');
+    }
+    else {
+        const yes = path.win32.isAbsolute(p);
+        // Ensure isPathFilesystemAbsolute() returns `false` if path is absolute starting from the user root dir (see comments above).
+        if (yes)
+            assert(!p.startsWith('/'));
+        return yes;
+    }
+}

package/dist/esm/utils/createErrorWithCleanStackTrace.js

@@ -1,13 +1,7 @@
 export { createErrorWithCleanStackTrace };
 import { isNodeJS } from './isNodeJS.js';
 function createErrorWithCleanStackTrace(errorMessage, numberOfStackTraceLinesToRemove) {
-    let err;
-    {
-        var stackTraceLimit__original = Error.stackTraceLimit;
-        Error.stackTraceLimit = Infinity;
-        err = new Error(errorMessage);
-        Error.stackTraceLimit = stackTraceLimit__original;
-    }
+    const err = new Error(errorMessage);
     if (isNodeJS()) {
         err.stack = clean(err.stack, numberOfStackTraceLinesToRemove);
     }

package/dist/esm/utils/debug.js

@@ -7,6 +7,7 @@ import { assert, assertUsage } from './assert.js';
 import { checkType } from './checkType.js';
 import { getTerminalWidth } from './getTerminWidth.js';
 import pc from '@brillout/picocolors';
+import { isArray } from './isArray.js';
 // Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
 assert(!isBrowser());
 globalThis.__brillout_debug_createDebugger = createDebugger;
@@ -81,7 +82,7 @@ function formatMsg(info, options, padding, position) {
     if (typeof info === 'string') {
         str += info;
     }
-    else if (Array.isArray(info)) {
+    else if (isArray(info)) {
         if (info.length === 0) {
             str += options.serialization?.emptyArray ?? '[]';
         }

package/dist/esm/utils/findFile.js

@@ -1,8 +1,9 @@
 export { findFile };
 import path from 'path';
 import fs from 'fs';
+import { isArray } from './isArray.js';
 function findFile(arg, cwd) {
-    const filenames = Array.isArray(arg) ? arg : [arg];
+    const filenames = isArray(arg) ? arg : [arg];
     let dir = cwd;
     while (true) {
         for (const filename of filenames) {

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

@@ -5,6 +5,7 @@ declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectTy
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'object'): obj is ObjectType & Record<PropName, Record<string, unknown>>;
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'array'): obj is ObjectType & Record<PropName, unknown[]>;
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string[]'): obj is ObjectType & Record<PropName, string[]>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string{}'): obj is ObjectType & Record<PropName, Record<string, string>>;
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'function'): obj is ObjectType & Record<PropName, (...args: any[]) => unknown>;
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'undefined'): obj is ObjectType & Record<PropName, undefined>;
 declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'null'): obj is ObjectType & Record<PropName, null>;

package/dist/esm/utils/hasProp.js

@@ -3,8 +3,9 @@ export { hasProp };
 // - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
 import { isCallable } from './isCallable.js';
 import { isObject } from './isObject.js';
-// prettier-ignore
-// biome-ignore format:
+import { isArrayOfStrings } from './isArrayOfStrings.js';
+import { isObjectOfStrings } from './isObjectOfStrings.js';
+import { isArray } from './isArray.js';
 function hasProp(obj, prop, type = 'unknown') {
     if (!isObject(obj))
         return false;
@@ -16,18 +17,21 @@ function hasProp(obj, prop, type = 'unknown') {
     }
     const propValue = obj[prop];
     if (type === 'array') {
-        return Array.isArray(propValue);
+        return isArray(propValue);
     }
     if (type === 'object') {
         return isObject(propValue);
     }
     if (type === 'string[]') {
-        return Array.isArray(propValue) && propValue.every(el => typeof el === 'string');
+        return isArrayOfStrings(propValue);
+    }
+    if (type === 'string{}') {
+        return isObjectOfStrings(propValue);
     }
     if (type === 'function') {
         return isCallable(propValue);
     }
-    if (Array.isArray(type)) {
+    if (isArray(type)) {
         return typeof propValue === 'string' && type.includes(propValue);
     }
     if (type === 'null') {

package/dist/esm/utils/injectRollupInputs.js

@@ -2,6 +2,7 @@ export { injectRollupInputs };
 export { normalizeRollupInput };
 import { assert } from './assert.js';
 import { isObject } from './isObject.js';
+import { isArray } from './isArray.js';
 function injectRollupInputs(inputsNew, config) {
     const inputsCurrent = normalizeRollupInput(config.build.rollupOptions.input);
     const input = {
@@ -18,7 +19,7 @@ function normalizeRollupInput(input) {
     if (typeof input === 'string') {
         input = [input];
     }
-    if (Array.isArray(input)) {
+    if (isArray(input)) {
         return Object.fromEntries(input.map((input) => [input, input]));
     }
     assert(isObject(input));

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

@@ -0,0 +1 @@
+export declare function isArray(value: unknown): value is unknown[];

package/dist/esm/utils/isArray.js

@@ -0,0 +1,4 @@
+// Typesafe Array.isArray() — asserting unknown[] instead of any[]
+export function isArray(value) {
+    return Array.isArray(value);
+}

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

@@ -0,0 +1,2 @@
+export { isArrayOfStrings };
+declare function isArrayOfStrings(val: unknown): val is string[];

package/dist/esm/utils/isArrayOfStrings.js

@@ -0,0 +1,5 @@
+export { isArrayOfStrings };
+import { isArray } from './isArray.js';
+function isArrayOfStrings(val) {
+    return isArray(val) && val.every((v) => typeof v === 'string');
+}

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

@@ -1,6 +1,9 @@
 export { isDev1 };
 export { isDev1_onConfigureServer };
 export { isDev2 };
+export { isDev3 };
+import type { ConfigEnv } from 'vite';
+declare function isDev3(configEnv: ConfigEnv): null | boolean;
 declare function isDev1(): boolean;
 declare function isDev1_onConfigureServer(): void | undefined;
 import type { ResolvedConfig } from 'vite';

package/dist/esm/utils/isDev.js

@@ -1,10 +1,18 @@
 export { isDev1 };
 export { isDev1_onConfigureServer };
 export { isDev2 };
-// There isn't any reliable way to test whether Vite is ran as dev/build/preview/optimizeDep
-//  - Failed attempt to make a PR: https://github.com/brillout/vite/tree/fix/config-operation
+export { isDev3 };
+function isDev3(configEnv) {
+    const { isPreview, command } = configEnv;
+    if (command !== 'serve')
+        return false;
+    if (typeof isPreview === 'boolean')
+        return !isPreview;
+    // isPreview is undefined in older Vite versions, see https://github.com/vitejs/vite/commit/93fce55
+    return null;
+}
 // ********
-// Method 1 - most reliable
+// Method 1 - reliable
 // ********
 import { assert } from './assert.js';
 import { getGlobalObject } from './getGlobalObject.js';

package/dist/esm/utils/isNpmPackage.js

@@ -22,7 +22,7 @@ function assertIsNpmPackageImport(str) {
     assert(isNpmPackageImport(str, {
         // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
         cannotBePathAlias: true
-    }));
+    }), str);
 }
 function isNpmPackageName(str) {
     const res = parse(str);

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

@@ -0,0 +1,2 @@
+export { isObjectOfStrings };
+declare function isObjectOfStrings(val: unknown): val is Record<string, string>;

package/dist/esm/utils/isObjectOfStrings.js

@@ -0,0 +1,5 @@
+export { isObjectOfStrings };
+import { isObject } from './isObject.js';
+function isObjectOfStrings(val) {
+    return isObject(val) && Object.values(val).every((v) => typeof v === 'string');
+}

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

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.168-commit-ce94f5c";
+declare const PROJECT_VERSION: "0.4.168-commit-42406a9";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.168-commit-ce94f5c";
+    projectVersion: "0.4.168-commit-42406a9";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,6 +1,6 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-const PROJECT_VERSION = '0.4.168-commit-ce94f5c';
+const PROJECT_VERSION = '0.4.168-commit-42406a9';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.168-commit-ce94f5c",
+  "version": "0.4.168-commit-42406a9",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/cjs/shared/page-configs/helpers/getConfigDefinedAtString.js

@@ -1,43 +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.getDefinedAtString = exports.getConfigDefinedAtString = void 0;
-const utils_js_1 = require("../../utils.js");
-const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const getExportPath_js_1 = require("../getExportPath.js");
-function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
-    const definedAtString = getDefinedAtString(definedAt, configName);
-    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
-    let configNameStr = `${configName}${ /*sentenceBegin === 'Hook' ? '()' :*/''}`;
-    const configDefinedAt = `${sentenceBegin} ${picocolors_1.default.cyan(configNameStr)} defined ${definedAtStr}`;
-    return configDefinedAt;
-}
-exports.getConfigDefinedAtString = getConfigDefinedAtString;
-function getDefinedAtString(definedAt, configName) {
-    if ('isComputed' in definedAt) {
-        return 'internally';
-    }
-    let files;
-    if ('files' in definedAt) {
-        files = definedAt.files;
-    }
-    else {
-        files = [definedAt];
-    }
-    (0, utils_js_1.assert)(files.length >= 1);
-    const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
-        let s = filePathToShowToUser;
-        const exportPath = (0, getExportPath_js_1.getExportPath)(fileExportPathToShowToUser, configName);
-        if (exportPath) {
-            s = `${s} > ${picocolors_1.default.cyan(exportPath)}`;
-        }
-        return s;
-    })
-        .join(' / ');
-    return definedAtString;
-}
-exports.getDefinedAtString = getDefinedAtString;

package/dist/cjs/utils/assertPathIsFilesystemAbsolute.js

@@ -1,21 +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.assertPathIsFilesystemAbsolute = void 0;
-const path_1 = __importDefault(require("path"));
-const assert_js_1 = require("./assert.js");
-const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
-/** Assert path is absolute from the filesystem root */
-function assertPathIsFilesystemAbsolute(p) {
-    (0, filesystemPathHandling_js_1.assertPosixPath)(p);
-    (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        (0, assert_js_1.assert)(p.startsWith('/'));
-    }
-    else {
-        (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
-    }
-}
-exports.assertPathIsFilesystemAbsolute = assertPathIsFilesystemAbsolute;

package/dist/cjs/utils/isStringRecord.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStringRecord = void 0;
-function isStringRecord(thing) {
-    return typeof thing === 'object' && thing !== null && Object.values(thing).every((val) => typeof val === 'string');
-}
-exports.isStringRecord = isStringRecord;

package/dist/cjs/utils/mergeCumulativeValues.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeCumulativeValues = void 0;
-const assert_js_1 = require("./assert.js");
-function mergeCumulativeValues(values) {
-    if (values.length === 0)
-        return null;
-    if (values.every((v) => v instanceof Set)) {
-        return new Set(values
-            .map((v) => {
-            (0, assert_js_1.assert)(v instanceof Set);
-            return [...v];
-        })
-            .flat());
-    }
-    if (values.every((v) => Array.isArray(v))) {
-        return values.flat();
-    }
-    return null;
-}
-exports.mergeCumulativeValues = mergeCumulativeValues;

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

@@ -1,13 +0,0 @@
-export { resolveImport };
-export { resolveImportPath };
-export { assertImportPath };
-export { clearFilesEnvMap };
-import type { ConfigEnvInternal, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
-import { type ImportData } from './transformFileImports.js';
-import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-declare function resolveImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | (DefinedAtFileFullInfo & {
-    fileExportName: string;
-});
-declare function resolveImportPath(importData: ImportData, importerFilePath: FilePathResolved): string | null;
-declare function assertImportPath(filePathAbsoluteFilesystem: string | null, importData: ImportData, importerFilePath: FilePathResolved): asserts filePathAbsoluteFilesystem is string;
-declare function clearFilesEnvMap(): void;

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

@@ -1,109 +0,0 @@
-export { resolveImport };
-export { resolveImportPath };
-export { assertImportPath };
-export { clearFilesEnvMap };
-import pc from '@brillout/picocolors';
-import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
-import { parseImportData } from './transformFileImports.js';
-import path from 'path';
-import { getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
-const filesEnvMap = new Map();
-function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
-    if (typeof configValue !== 'string')
-        return null;
-    const importData = parseImportData(configValue);
-    if (!importData)
-        return null;
-    const { importPath, exportName } = importData;
-    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
-    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
-    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
-    let filePath;
-    if (importPath.startsWith('.')) {
-        assert(importPath.startsWith('./') || importPath.startsWith('../'));
-        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
-        // Imports are included in virtual files, thus the relative path of imports need to resolved.
-        // ```
-        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
-        // ```
-        assertUsage(filePath.filePathAbsoluteUserRootDir, `${importerFilePath.filePathToShowToUser} imports a relative path ${pc.cyan(importPath)} resolving outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
-        // Alternativey, we can try one of the following but last time we tried none of the following worked.
-        // /*
-        // assert(filePathAbsoluteFilesystem.startsWith('/'))
-        // filePath = `/@fs${filePathAbsoluteFilesystem}`
-        // /*/
-        // assert(filePathAbsoluteUserRootDir.startsWith('../'))
-        // filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
-        // //*/
-    }
-    else {
-        // importPath can be:
-        //  - an npm package import
-        //  - a path alias
-        if (filePathAbsoluteFilesystem) {
-            filePath = getFilePathResolved({
-                userRootDir,
-                filePathAbsoluteFilesystem,
-                importPathAbsolute: importPath
-            });
-        }
-        else {
-            filePath = getFilePathUnresolved({
-                importPathAbsolute: importPath
-            });
-        }
-    }
-    return {
-        ...filePath,
-        fileExportName: exportName,
-        fileExportPathToShowToUser
-    };
-}
-function resolveImportPath(importData, importerFilePath) {
-    const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
-    assertPosixPath(importerFilePathAbsolute);
-    const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer)
-    // https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
-    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
-    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
-    return filePathAbsoluteFilesystem;
-}
-function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
-    const { importPath: importPath, importStringWasGenerated, importString } = importData;
-    const { filePathToShowToUser } = importerFilePath;
-    if (!filePathAbsoluteFilesystem) {
-        const importPathString = pc.cyan(`'${importPath}'`);
-        const errIntro = importStringWasGenerated
-            ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
-        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
-        if (importPath.startsWith('.')) {
-            assert(importPath.startsWith('./') || importPath.startsWith('../'));
-            assertUsage(false, `${errIntro2} point to an existing file?`);
-        }
-        else {
-            assertUsage(false, `${errIntro2} exist?`);
-        }
-    }
-}
-function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
-    assertPosixPath(filePathForEnvCheck);
-    if (!filesEnvMap.has(filePathForEnvCheck)) {
-        filesEnvMap.set(filePathForEnvCheck, []);
-    }
-    const fileEnv = filesEnvMap.get(filePathForEnvCheck);
-    fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
-    if (configDifferentEnv) {
-        assertUsage(false, [
-            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/config#pointer-imports'
-        ].join('\n'));
-    }
-}
-function clearFilesEnvMap() {
-    filesEnvMap.clear();
-}

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.d.ts

@@ -1,7 +0,0 @@
-export { getConfigDefinedAtString };
-export { getDefinedAtString };
-import type { DefinedAt } from '../PageConfig.js';
-declare function getConfigDefinedAtString<ConfigName extends string, SentenceBegin extends 'Config' | 'config'>(sentenceBegin: SentenceBegin, configName: ConfigName, { definedAt }: {
-    definedAt: DefinedAt;
-}): `${SentenceBegin} ${ConfigName}${string} defined ${'internally' | `at ${string}`}`;
-declare function getDefinedAtString(definedAt: DefinedAt, configName: string): string;

package/dist/esm/shared/page-configs/helpers/getConfigDefinedAtString.js

@@ -1,37 +0,0 @@
-export { getConfigDefinedAtString };
-export { getDefinedAtString };
-import { assert } from '../../utils.js';
-import pc from '@brillout/picocolors';
-import { getExportPath } from '../getExportPath.js';
-function getConfigDefinedAtString(sentenceBegin, configName, { definedAt }) {
-    const definedAtString = getDefinedAtString(definedAt, configName);
-    const definedAtStr = definedAtString === 'internally' ? definedAtString : `at ${definedAtString}`;
-    let configNameStr = `${configName}${ /*sentenceBegin === 'Hook' ? '()' :*/''}`;
-    const configDefinedAt = `${sentenceBegin} ${pc.cyan(configNameStr)} defined ${definedAtStr}`;
-    return configDefinedAt;
-}
-function getDefinedAtString(definedAt, configName) {
-    if ('isComputed' in definedAt) {
-        return 'internally';
-    }
-    let files;
-    if ('files' in definedAt) {
-        files = definedAt.files;
-    }
-    else {
-        files = [definedAt];
-    }
-    assert(files.length >= 1);
-    const definedAtString = files
-        .map((source) => {
-        const { filePathToShowToUser, fileExportPathToShowToUser } = source;
-        let s = filePathToShowToUser;
-        const exportPath = getExportPath(fileExportPathToShowToUser, configName);
-        if (exportPath) {
-            s = `${s} > ${pc.cyan(exportPath)}`;
-        }
-        return s;
-    })
-        .join(' / ');
-    return definedAtString;
-}

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

@@ -1,3 +0,0 @@
-export { assertPathIsFilesystemAbsolute };
-/** Assert path is absolute from the filesystem root */
-declare function assertPathIsFilesystemAbsolute(p: string): void;

package/dist/esm/utils/assertPathIsFilesystemAbsolute.js

@@ -1,15 +0,0 @@
-export { assertPathIsFilesystemAbsolute };
-import path from 'path';
-import { assert } from './assert.js';
-import { assertPosixPath } from './filesystemPathHandling.js';
-/** Assert path is absolute from the filesystem root */
-function assertPathIsFilesystemAbsolute(p) {
-    assertPosixPath(p);
-    assert(!p.startsWith('/@fs/'));
-    if (process.platform !== 'win32') {
-        assert(p.startsWith('/'));
-    }
-    else {
-        assert(path.win32.isAbsolute(p));
-    }
-}

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

@@ -1 +0,0 @@
-export declare function isStringRecord(thing: unknown): thing is Record<string, string>;

package/dist/esm/utils/isStringRecord.js

@@ -1,3 +0,0 @@
-export function isStringRecord(thing) {
-    return typeof thing === 'object' && thing !== null && Object.values(thing).every((val) => typeof val === 'string');
-}