vike 0.4.165-commit-8eba585 → 0.4.166-commit-6a8acaa

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

@@ -1,20 +0,0 @@
-export { getFilePathResolved };
-export { getFilePathUnresolved };
-import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
-declare function getFilePathUnresolved(args: {
-    filePathAbsoluteFilesystem: string | null;
-    filePathAbsoluteUserRootDir: string | null;
-    importPathAbsolute: string | null;
-} & ({
-    filePathAbsoluteUserRootDir: string;
-} | {
-    importPathAbsolute: string;
-})): FilePath;
-declare function getFilePathResolved(args: {
-    userRootDir: string;
-    importPathAbsolute: string | null;
-} & ({
-    filePathAbsoluteFilesystem: string;
-} | {
-    filePathAbsoluteUserRootDir: string;
-})): FilePathResolved;

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

@@ -1,84 +0,0 @@
-export { getFilePathResolved };
-export { getFilePathUnresolved };
-import path from 'path';
-import { assert, assertPosixPath, hasProp } from '../../../../utils.js';
-function getFilePathUnresolved(args) {
-    const { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir } = args;
-    let filePathAbsoluteVite;
-    if (args.filePathAbsoluteUserRootDir !== null) {
-        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
-    }
-    else {
-        assert(args.importPathAbsolute !== null); // Help TS
-        filePathAbsoluteVite = args.importPathAbsolute;
-    }
-    return {
-        ...args,
-        filePathAbsoluteVite,
-        filePathToShowToUser: filePathAbsoluteVite,
-        filePathToShowToUserResolved: filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem
-    };
-}
-function getFilePathResolved(args) {
-    const { userRootDir, importPathAbsolute } = args;
-    let filePathAbsoluteFilesystem;
-    let filePathAbsoluteUserRootDir;
-    if ('filePathAbsoluteFilesystem' in args) {
-        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
-        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
-    }
-    else {
-        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
-        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
-    }
-    let filePathResolved;
-    const common = {
-        filePathAbsoluteUserRootDir,
-        filePathAbsoluteFilesystem,
-        importPathAbsolute,
-        userRootDir
-    };
-    if (importPathAbsolute) {
-        filePathResolved = getFilePathUnresolved({
-            ...common,
-            importPathAbsolute
-        });
-    }
-    else {
-        assert(filePathAbsoluteUserRootDir);
-        filePathResolved = getFilePathUnresolved({
-            ...common,
-            filePathAbsoluteUserRootDir
-        });
-    }
-    assert(filePathAbsoluteFilesystem);
-    assert(hasProp(filePathResolved, 'filePathAbsoluteFilesystem', 'string'));
-    assert(hasProp(filePathResolved, 'filePathToShowToUserResolved', 'string'));
-    return filePathResolved;
-}
-function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
-    assertPosixPath(filePathAbsoluteUserRootDir);
-    assertPosixPath(userRootDir);
-    const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
-    return filePathAbsoluteFilesystem;
-}
-function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(userRootDir);
-    let filePathAbsoluteUserRootDir = null;
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        {
-            let filePathAbsoluteUserRootDir1 = filePathAbsoluteFilesystem.slice(userRootDir.length);
-            if (!filePathAbsoluteUserRootDir1.startsWith('/'))
-                filePathAbsoluteUserRootDir1 = '/' + filePathAbsoluteUserRootDir1;
-            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir1;
-        }
-        {
-            let filePathAbsoluteUserRootDir2 = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
-            assert(!filePathAbsoluteUserRootDir2.startsWith('.') && !filePathAbsoluteUserRootDir2.startsWith('/'));
-            filePathAbsoluteUserRootDir2 = '/' + filePathAbsoluteUserRootDir2;
-            assert(filePathAbsoluteFilesystem === filePathAbsoluteUserRootDir2);
-        }
-    }
-    return filePathAbsoluteUserRootDir;
-}

package/dist/esm/node/runtime/renderPage/getPageAssets/assertClientEntryId.d.ts

@@ -1,2 +0,0 @@
-export { assertClientEntryId };
-declare function assertClientEntryId(id: string): void;

package/dist/esm/node/runtime/renderPage/getPageAssets/assertClientEntryId.js

@@ -1,16 +0,0 @@
-export { assertClientEntryId };
-import { assert, assertPosixPath, isNpmPackageImport } from '../../utils.js';
-import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
-function assertClientEntryId(id) {
-    assertPosixPath(id);
-    assert(!id.startsWith('/@fs'), id);
-    assert(
-    // Client entry
-    id.startsWith('@@vike/') ||
-        // User files
-        id.startsWith('/') ||
-        // Page code importer
-        isVirtualFileIdPageConfigValuesAll(id) ||
-        // Import
-        isNpmPackageImport(id), id);
-}

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

@@ -1,5 +0,0 @@
-export { getFilePathAbsoluteFilesystem };
-export { getFilePathAbsoluteUserRootDir };
-import type { ResolvedConfig } from 'vite';
-declare function getFilePathAbsoluteFilesystem(filePath: string, config: ResolvedConfig): string;
-declare function getFilePathAbsoluteUserRootDir(filePathAbsoluteFilesystem: string, userRootDir: string, alwaysRelative?: boolean): string;

package/dist/esm/utils/getFilePathAbsolute.js

@@ -1,64 +0,0 @@
-export { getFilePathAbsoluteFilesystem };
-export { getFilePathAbsoluteUserRootDir };
-import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
-import { assert } from './assert.js';
-import path from 'path';
-import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
-import { isNpmPackageImport } from './isNpmPackage.js';
-import { assertPathIsFilesystemAbsolute } from './assertPathIsFilesystemAbsolute.js';
-import { createRequire } from 'module';
-// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
-const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
-assertIsNotProductionRuntime();
-// Vite handles paths such as /pages/index.page.js which are relative to `config.root`.
-// Make them absolute starting from the filesystem root.
-// Also resolve plus files living in npm packages such as restack/renderer/+onRenderHtml.js
-function getFilePathAbsoluteFilesystem(filePath, config) {
-    assertPosixPath(filePath);
-    if (filePath.startsWith('/@fs/')) {
-        return filePath;
-    }
-    let filePathUnresolved;
-    if (isNpmPackageImport(filePath)) {
-        filePathUnresolved = filePath;
-    }
-    else {
-        assert(filePath.startsWith('/'));
-        const { root } = config;
-        assertPathIsFilesystemAbsolute(root);
-        filePathUnresolved = path.posix.join(root, filePath);
-        assertPathIsFilesystemAbsolute(filePathUnresolved);
-    }
-    let filePathAbsoluteFilesystem;
-    try {
-        filePathAbsoluteFilesystem = require_.resolve(filePathUnresolved, { paths: [config.root] });
-    }
-    catch (err) {
-        console.error(err);
-        assert(false);
-    }
-    filePathAbsoluteFilesystem = toPosixPath(filePathAbsoluteFilesystem);
-    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
-    return filePathAbsoluteFilesystem;
-}
-function getFilePathAbsoluteUserRootDir(filePathAbsoluteFilesystem, userRootDir, alwaysRelative = false) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(userRootDir);
-    let filePathAbsoluteUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
-    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        assert(!filePathAbsoluteUserRootDir.startsWith('.') && !filePathAbsoluteUserRootDir.startsWith('/'), 
-        // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
-        { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem, userRootDir });
-        filePathAbsoluteUserRootDir = `/${filePathAbsoluteUserRootDir}`;
-        return filePathAbsoluteUserRootDir;
-    }
-    else {
-        if (alwaysRelative) {
-            return filePathAbsoluteUserRootDir;
-        }
-        else {
-            return filePathAbsoluteFilesystem;
-        }
-    }
-}