vike/dist/cjs/node/vite/shared/getFilePath.js

The Framework *You* Control - Next.js & Nuxt alternative for unprecedented flexibility and dependability.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getFilePathResolved = getFilePathResolved;
exports.getFilePathUnresolved = getFilePathUnresolved;
exports.getFilePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir;
exports.getFilePathToShowToUserFromUnknown = getFilePathToShowToUserFromUnknown;
exports.getModuleFilePathAbsolute = getModuleFilePathAbsolute;
exports.getModuleFilePathRelative = getModuleFilePathRelative;
exports.cleanFilePathUnknown = cleanFilePathUnknown;
exports.assertModuleId = assertModuleId;
const node_path_1 = __importDefault(require("node:path"));
const utils_js_1 = require("../utils.js");
function getFilePathResolved(args) {
    const { userRootDir } = args;
    let filePathAbsoluteFilesystem;
    let filePathAbsoluteUserRootDir;
    if ('filePathAbsoluteFilesystem' in args) {
        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
    }
    else {
        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
    }
    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
    const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
    (0, utils_js_1.assert)(filePathToShowToUserResolved);
    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
    const fileName = node_path_1.default.posix.basename(filePathAbsoluteFilesystem);
    const filePathResolved = {
        ...getComputedProps(args),
        filePathAbsoluteFilesystem,
        filePathToShowToUserResolved,
        fileName,
    };
    return filePathResolved;
}
function getComputedProps(args) {
    if ('filePathAbsoluteUserRootDir' in args) {
        const importPathAbsolute = args.importPathAbsolute ?? null;
        const { filePathAbsoluteUserRootDir } = args;
        if (importPathAbsolute)
            (0, utils_js_1.assertIsImportPathNpmPackage)(importPathAbsolute);
        return {
            importPathAbsolute,
            filePathAbsoluteUserRootDir,
            filePathAbsoluteVite: filePathAbsoluteUserRootDir,
            filePathToShowToUser: filePathAbsoluteUserRootDir,
        };
    }
    else {
        return getComputedPropsImportPathAbsolute(args);
    }
}
function getComputedPropsImportPathAbsolute(args) {
    const { importPathAbsolute } = args;
    (0, utils_js_1.assertIsImportPathNpmPackage)(importPathAbsolute);
    return {
        filePathAbsoluteUserRootDir: null,
        importPathAbsolute,
        filePathAbsoluteVite: importPathAbsolute,
        filePathToShowToUser: importPathAbsolute,
    };
}
function getFilePathUnresolved(args) {
    return {
        ...getComputedPropsImportPathAbsolute(args),
        filePathAbsoluteFilesystem: null,
    };
}
function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir, }) {
    (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
    (0, utils_js_1.assertPosixPath)(userRootDir);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
    const filePathAbsoluteFilesystem = node_path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
    return filePathAbsoluteFilesystem;
}
function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir, }) {
    const { filePathAbsoluteUserRootDir } = getFilePathRelative({
        filePathAbsoluteFilesystem,
        userRootDir,
    });
    return filePathAbsoluteUserRootDir;
}
function getFilePathRelative({ filePathAbsoluteFilesystem, userRootDir, }) {
    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
    (0, utils_js_1.assertPosixPath)(userRootDir);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
    const filePathRelativeUserRootDir = node_path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
        (0, utils_js_1.assert)(filePathRelativeUserRootDir.startsWith('../'));
        return {
            filePathAbsoluteUserRootDir: null,
            filePathRelativeUserRootDir,
        };
    }
    else {
        (0, utils_js_1.assert)(!filePathRelativeUserRootDir.startsWith('/') &&
            /* Not true if filePathRelative starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
            !filePathRelative.startsWith('.') &&
            */
            !filePathRelativeUserRootDir.startsWith('./') &&
            !filePathRelativeUserRootDir.startsWith('../'));
        const filePathAbsoluteUserRootDir = `/${filePathRelativeUserRootDir}`;
        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
        return { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
    }
}
function getModuleFilePathAbsolute(moduleId, config) {
    const { filePathAbsoluteUserRootDir, filePathAbsoluteFilesystem } = getModuleFilePath(moduleId, config);
    return filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
}
function getModuleFilePathRelative(moduleId, config) {
    const { filePathRelativeUserRootDir } = getModuleFilePath(moduleId, config);
    return filePathRelativeUserRootDir;
}
function getModuleFilePath(moduleId, config) {
    const userRootDir = config.root;
    assertModuleId(moduleId);
    (0, utils_js_1.assertPosixPath)(userRootDir);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
    const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(filePathAbsoluteFilesystem);
    const { filePathAbsoluteUserRootDir, filePathRelativeUserRootDir } = getFilePathRelative({
        filePathAbsoluteFilesystem,
        userRootDir,
    });
    return { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir, filePathRelativeUserRootDir };
}
function assertModuleId(moduleId) {
    (0, utils_js_1.assertPosixPath)(moduleId);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(moduleId); // Can moduleId be something else than the filesystem absolute path?
}
function getFilePathToShowToUserFromUnknown(
// We don't have any guarantee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
filePathUnknown, userRootDir) {
    (0, utils_js_1.assertPosixPath)(userRootDir);
    (0, utils_js_1.assertFilePathAbsoluteFilesystem)(userRootDir);
    filePathUnknown = cleanFilePathUnknown(filePathUnknown);
    if (!filePathUnknown.startsWith(userRootDir)) {
        return filePathUnknown;
    }
    else {
        return getFilePathAbsoluteUserRootDir2(filePathUnknown, userRootDir);
    }
}
function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(userRootDir));
    let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
    if (!filePathAbsoluteUserRootDir.startsWith('/'))
        filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
    return filePathAbsoluteUserRootDir;
}
function cleanFilePathUnknown(filePathUnknown) {
    filePathUnknown = (0, utils_js_1.toPosixPath)(filePathUnknown);
    filePathUnknown = cleanModuleId(filePathUnknown);
    return filePathUnknown;
}
function cleanModuleId(moduleId) {
    // remove query
    const parts = moduleId.split('?');
    if (parts.length > 1)
        parts.pop();
    (0, utils_js_1.assert)(parts.length >= 1);
    return parts.join('?');
}