@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/dumpGraphToGraphViz.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = dumpGraphToGraphViz;
+const path_1 = __importDefault(require("path"));
+const graph_1 = require("@atlaspack/graph");
+const projectPath_1 = require("./projectPath");
+const types_1 = require("./types");
+const COLORS = {
+    root: 'gray',
+    asset: 'green',
+    dependency: 'orange',
+    transformer_request: 'cyan',
+    file: 'gray',
+    default: 'white',
+};
+const TYPE_COLORS = {
+    // bundle graph
+    bundle: 'blue',
+    contains: 'grey',
+    internal_async: 'orange',
+    references: 'red',
+    sibling: 'green',
+    // asset graph
+    // request graph
+    invalidated_by_create: 'green',
+    invalidated_by_create_above: 'orange',
+    invalidate_by_update: 'cyan',
+    invalidated_by_delete: 'red',
+};
+async function dumpGraphToGraphViz(graph, name, edgeTypes) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'production' &&
+        !process.env.ATLASPACK_BUILD_REPL) {
+        return;
+    }
+    let mode = process.env.ATLASPACK_BUILD_REPL
+        ? // @ts-expect-error TS7017
+            globalThis.ATLASPACK_DUMP_GRAPHVIZ?.mode
+        : process.env.ATLASPACK_DUMP_GRAPHVIZ;
+    // @ts-expect-error TS2367
+    if (mode == null || mode == false) {
+        return;
+    }
+    let detailedSymbols = mode === 'symbols';
+    let GraphVizGraph = require('graphviz/lib/deps/graph').Graph;
+    let g = new GraphVizGraph(null, 'G');
+    g.type = 'digraph';
+    for (let [id, node] of graph.nodes.entries()) {
+        if (node == null)
+            continue;
+        let n = g.addNode(nodeId(id));
+        // @ts-expect-error TS7053
+        n.set('color', COLORS[node.type || 'default']);
+        n.set('shape', 'box');
+        n.set('style', 'filled');
+        let label;
+        if (typeof node === 'string') {
+            label = node;
+            // @ts-expect-error TS2339
+        }
+        else if (node.assets) {
+            // @ts-expect-error TS2339
+            label = `(${nodeId(id)}), (assetIds: ${[...node.assets]
+                .map((a) => {
+                let arr = a.filePath.split('/');
+                return arr[arr.length - 1];
+            })
+                // @ts-expect-error TS2339
+                .join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(', ')}) (bb ${node.bundleBehavior ?? 'none'})`;
+            // @ts-expect-error TS2339
+        }
+        else if (node.type) {
+            // @ts-expect-error TS2339
+            label = `[${(0, graph_1.fromNodeId)(id)}] ${node.type || 'No Type'}: [${node.id}]: `;
+            // @ts-expect-error TS2339
+            if (node.type === 'dependency') {
+                // @ts-expect-error TS2339
+                label += node.value.specifier;
+                let parts = [];
+                // @ts-expect-error TS2339
+                if (node.value.priority !== types_1.Priority.sync) {
+                    parts.push(Object.entries(types_1.Priority).find(
+                    // @ts-expect-error TS2339
+                    ([, v]) => v === node.value.priority)?.[0]);
+                }
+                // @ts-expect-error TS2339
+                if (node.value.isOptional)
+                    parts.push('optional');
+                // @ts-expect-error TS2339
+                if (node.value.specifierType === types_1.SpecifierType.url)
+                    parts.push('url');
+                // @ts-expect-error TS2339
+                if (node.hasDeferred)
+                    parts.push('deferred');
+                // @ts-expect-error TS2339
+                if (node.deferred)
+                    parts.push('deferred');
+                // @ts-expect-error TS2339
+                if (node.excluded)
+                    parts.push('excluded');
+                if (parts.length)
+                    label += ' (' + parts.join(', ') + ')';
+                // @ts-expect-error TS2339
+                if (node.value.env)
+                    label += ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+                let depSymbols = node.value.symbols;
+                if (detailedSymbols) {
+                    if (depSymbols) {
+                        if (depSymbols.size) {
+                            label +=
+                                '\\nsymbols: ' +
+                                    [...depSymbols]
+                                        .map(([e, { local }]) => [e, local])
+                                        .join(';');
+                        }
+                        let weakSymbols = [...depSymbols]
+                            .filter(([, { isWeak }]) => isWeak)
+                            .map(([s]) => s);
+                        if (weakSymbols.length) {
+                            label += '\\nweakSymbols: ' + weakSymbols.join(',');
+                        }
+                        // @ts-expect-error TS2339
+                        if (node.usedSymbolsUp.size > 0) {
+                            label +=
+                                '\\nusedSymbolsUp: ' +
+                                    // @ts-expect-error TS2339
+                                    [...node.usedSymbolsUp]
+                                        .map(([s, sAsset]) => sAsset
+                                        ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})`
+                                        : sAsset === null
+                                            ? `${s}(external)`
+                                            : `${s}(ambiguous)`)
+                                        .join(',');
+                        }
+                        // @ts-expect-error TS2339
+                        if (node.usedSymbolsDown.size > 0) {
+                            label +=
+                                // @ts-expect-error TS2339
+                                '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
+                        }
+                        // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+                        // if (node.usedSymbolsUpDirtyDown)
+                        //   label += '\\nusedSymbolsUpDirtyDown';
+                        // if (node.usedSymbolsUpDirtyUp) label += '\\nusedSymbolsUpDirtyUp';
+                    }
+                    else {
+                        label += '\\nsymbols: cleared';
+                    }
+                }
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'asset') {
+                label +=
+                    // @ts-expect-error TS2339
+                    path_1.default.basename((0, projectPath_1.fromProjectPathRelative)(node.value.filePath)) +
+                        '#' +
+                        // @ts-expect-error TS2339
+                        node.value.type;
+                if (detailedSymbols) {
+                    // @ts-expect-error TS2339
+                    if (!node.value.symbols) {
+                        label += '\\nsymbols: cleared';
+                        // @ts-expect-error TS2339
+                    }
+                    else if (node.value.symbols.size) {
+                        label +=
+                            '\\nsymbols: ' +
+                                // @ts-expect-error TS2339
+                                [...node.value.symbols]
+                                    .map(([e, { local }]) => [e, local])
+                                    .join(';');
+                    }
+                    // @ts-expect-error TS2339
+                    if (node.usedSymbols.size) {
+                        // @ts-expect-error TS2339
+                        label += '\\nusedSymbols: ' + [...node.usedSymbols].join(',');
+                    }
+                    // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+                    // if (node.usedSymbolsUpDirty) label += '\\nusedSymbolsUpDirty';
+                }
+                else {
+                    label += '\\nsymbols: cleared';
+                }
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'asset_group') {
+                // @ts-expect-error TS2339
+                if (node.deferred)
+                    label += '(deferred)';
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'file') {
+                // @ts-expect-error TS2339
+                label += path_1.default.basename(node.id);
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'transformer_request') {
+                label +=
+                    // @ts-expect-error TS2339
+                    path_1.default.basename(node.value.filePath) +
+                        // @ts-expect-error TS2339
+                        ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'bundle') {
+                let parts = [];
+                // @ts-expect-error TS2339
+                if (node.value.needsStableName)
+                    parts.push('stable name');
+                // @ts-expect-error TS2339
+                parts.push(node.value.name);
+                // @ts-expect-error TS2339
+                parts.push('bb:' + (node.value.bundleBehavior ?? 'null'));
+                // @ts-expect-error TS2339
+                if (node.value.isPlaceholder)
+                    parts.push('placeholder');
+                if (parts.length)
+                    label += ' (' + parts.join(', ') + ')';
+                // @ts-expect-error TS2339
+                if (node.value.env)
+                    label += ` (${getEnvDescription(node.value.env)})`;
+                // @ts-expect-error TS2339
+            }
+            else if (node.type === 'request') {
+                // @ts-expect-error TS2339
+                label = node.requestType + ':' + node.id;
+            }
+        }
+        n.set('label', label);
+    }
+    let edgeNames;
+    if (edgeTypes) {
+        edgeNames = Object.fromEntries(Object.entries(edgeTypes).map(([k, v]) => [v, k]));
+    }
+    // @ts-expect-error TS2488
+    for (let edge of graph.getAllEdges()) {
+        let gEdge = g.addEdge(nodeId(edge.from), nodeId(edge.to));
+        let color = null;
+        if (edge.type != 1 && edgeNames) {
+            // @ts-expect-error TS7053
+            color = TYPE_COLORS[edgeNames[edge.type]];
+        }
+        if (color != null) {
+            gEdge.set('color', color);
+        }
+    }
+    if (process.env.ATLASPACK_BUILD_REPL) {
+        // @ts-expect-error TS7017
+        globalThis.ATLASPACK_DUMP_GRAPHVIZ?.(name, g.to_dot());
+    }
+    else {
+        const tempy = require('tempy');
+        let tmp = tempy.file({ name: `parcel-${name}.png` });
+        await g.output('png', tmp);
+        // eslint-disable-next-line no-console
+        console.log('Dumped', tmp);
+    }
+}
+// @ts-expect-error TS2552
+function nodeId(id) {
+    return `node${id}`;
+}
+function getEnvDescription(env) {
+    let description;
+    if (typeof env.engines.browsers === 'string') {
+        description = `${env.context}: ${env.engines.browsers}`;
+    }
+    else if (Array.isArray(env.engines.browsers)) {
+        description = `${env.context}: ${env.engines.browsers.join(', ')}`;
+    }
+    else if (env.engines.node) {
+        description = `node: ${env.engines.node}`;
+    }
+    else if (env.engines.electron) {
+        description = `electron: ${env.engines.electron}`;
+    }
+    return description ?? '';
+}

package/dist/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentManager = exports.Environment = exports.createEnvironment = exports.resolveOptions = exports.ATLASPACK_VERSION = exports.WORKER_PATH = exports.INTERNAL_TRANSFORM = exports.INTERNAL_RESOLVE = exports.createWorkerFarm = exports.BuildError = exports.Parcel = exports.Atlaspack = exports.default = void 0;
+const EnvironmentManager = __importStar(require("./EnvironmentManager"));
+exports.EnvironmentManager = EnvironmentManager;
+var Atlaspack_1 = require("./Atlaspack");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "Atlaspack", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "Parcel", { enumerable: true, get: function () { return __importDefault(Atlaspack_1).default; } });
+Object.defineProperty(exports, "BuildError", { enumerable: true, get: function () { return Atlaspack_1.BuildError; } });
+Object.defineProperty(exports, "createWorkerFarm", { enumerable: true, get: function () { return Atlaspack_1.createWorkerFarm; } });
+Object.defineProperty(exports, "INTERNAL_RESOLVE", { enumerable: true, get: function () { return Atlaspack_1.INTERNAL_RESOLVE; } });
+Object.defineProperty(exports, "INTERNAL_TRANSFORM", { enumerable: true, get: function () { return Atlaspack_1.INTERNAL_TRANSFORM; } });
+Object.defineProperty(exports, "WORKER_PATH", { enumerable: true, get: function () { return Atlaspack_1.WORKER_PATH; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "ATLASPACK_VERSION", { enumerable: true, get: function () { return constants_1.ATLASPACK_VERSION; } });
+var resolveOptions_1 = require("./resolveOptions");
+Object.defineProperty(exports, "resolveOptions", { enumerable: true, get: function () { return __importDefault(resolveOptions_1).default; } });
+var Environment_1 = require("./Environment");
+Object.defineProperty(exports, "createEnvironment", { enumerable: true, get: function () { return Environment_1.createEnvironment; } });
+var Environment_2 = require("./public/Environment");
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return __importDefault(Environment_2).default; } });
+__exportStar(require("./atlaspack-v3"), exports);

package/dist/loadAtlaspackPlugin.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadPlugin;
+const path_1 = __importDefault(require("path"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const projectPath_1 = require("./projectPath");
+const NODE_MODULES = `${path_1.default.sep}node_modules${path_1.default.sep}`;
+const CONFIG = Symbol.for('parcel-plugin-config');
+async function loadPlugin(pluginName, configPath, keyPath, options) {
+    let resolveFrom = configPath;
+    // Config packages can reference plugins, but cannot contain other plugins within them.
+    // This forces every published plugin to be published separately so they can be mixed and matched if needed.
+    if (resolveFrom.includes(NODE_MODULES) && pluginName.startsWith('.')) {
+        let configContents = await options.inputFS.readFile(configPath, 'utf8');
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
+                origin: '@atlaspack/core',
+                codeFrames: keyPath
+                    ? [
+                        {
+                            filePath: configPath,
+                            language: 'json5',
+                            code: configContents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(configContents, [
+                                {
+                                    key: keyPath,
+                                    type: 'value',
+                                },
+                            ]),
+                        },
+                    ]
+                    : undefined,
+            },
+        });
+    }
+    let pkg;
+    try {
+        ({ pkg } = await options.packageManager.resolve(pluginName, resolveFrom, {
+            shouldAutoInstall: options.shouldAutoInstall,
+        }));
+    }
+    catch (err) {
+        if (err.code !== 'MODULE_NOT_FOUND') {
+            throw err;
+        }
+        let configContents = await options.inputFS.readFile(configPath, 'utf8');
+        let alternatives = await (0, utils_1.findAlternativeNodeModules)(options.inputFS, pluginName, path_1.default.dirname(resolveFrom));
+        throw new diagnostic_1.default({
+            diagnostic: {
+                message: (0, diagnostic_1.md) `Cannot find Atlaspack plugin "${pluginName}"`,
+                origin: '@atlaspack/core',
+                codeFrames: keyPath
+                    ? [
+                        {
+                            filePath: configPath,
+                            language: 'json5',
+                            code: configContents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(configContents, [
+                                {
+                                    key: keyPath,
+                                    type: 'value',
+                                    message: (0, diagnostic_1.md) `Cannot find module "${pluginName}"${alternatives[0]
+                                        ? `, did you mean "${alternatives[0]}"?`
+                                        : ''}`,
+                                },
+                            ]),
+                        },
+                    ]
+                    : undefined,
+            },
+        });
+    }
+    let plugin = await options.packageManager.require(pluginName, resolveFrom, {
+        shouldAutoInstall: options.shouldAutoInstall,
+    });
+    plugin = plugin.default ? plugin.default : plugin;
+    if (!plugin) {
+        throw new Error(`Plugin ${pluginName} has no exports.`);
+    }
+    plugin = plugin[CONFIG];
+    if (!plugin) {
+        throw new Error(`Plugin ${pluginName} is not a valid Atlaspack plugin, should export an instance of a Atlaspack plugin ex. "export default new Reporter({ ... })".`);
+    }
+    return {
+        plugin,
+        version: (0, nullthrows_1.default)(pkg).version,
+        resolveFrom: (0, projectPath_1.toProjectPath)(options.projectRoot, resolveFrom),
+    };
+}

package/dist/loadDotEnv.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadEnv;
+const utils_1 = require("@atlaspack/utils");
+const dotenv_1 = __importDefault(require("dotenv"));
+const dotenv_expand_1 = __importDefault(require("dotenv-expand"));
+async function loadEnv(env, fs, filePath, projectRoot) {
+    const NODE_ENV = env.NODE_ENV ?? 'development';
+    const dotenvFiles = [
+        '.env',
+        // Don't include `.env.local` for `test` environment
+        // since normally you expect tests to produce the same
+        // results for everyone
+        NODE_ENV === 'test' ? null : '.env.local',
+        `.env.${NODE_ENV}`,
+        `.env.${NODE_ENV}.local`,
+    ].filter(Boolean);
+    let envs = await Promise.all(dotenvFiles.map(async (dotenvFile) => {
+        const envPath = await (0, utils_1.resolveConfig)(fs, filePath, 
+        // @ts-expect-error TS2322
+        [dotenvFile], projectRoot);
+        if (envPath == null) {
+            return;
+        }
+        // `ignoreProcessEnv` prevents dotenv-expand from writing values into `process.env`:
+        // https://github.com/motdotla/dotenv-expand/blob/ddb73d02322fe8522b4e05b73e1c1ad24ea7c14a/lib/main.js#L5
+        let output = (0, dotenv_expand_1.default)({
+            parsed: dotenv_1.default.parse(await fs.readFile(envPath)),
+            // @ts-expect-error TS2353
+            ignoreProcessEnv: true,
+        });
+        if (output.error != null) {
+            throw output.error;
+        }
+        return output.parsed;
+    }));
+    return Object.assign({}, ...envs);
+}

package/dist/projectPath.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromProjectPath = exports.toProjectPath = void 0;
+exports.fromProjectPathRelative = fromProjectPathRelative;
+exports.toProjectPathUnsafe = toProjectPathUnsafe;
+exports.joinProjectPath = joinProjectPath;
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("@atlaspack/utils");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+/**
+ * Converts a file path to a project-relative path.
+ *
+ * @param projectRoot - The project root.
+ * @param p - The file path to convert.
+ * @returns The project path.
+ */
+function toProjectPath_(projectRoot, p) {
+    // If the file path is not provided, then treat it as though it is already from the project root
+    if (p == null) {
+        return p;
+    }
+    // If the file path is already relative and it does not begin with '.', then treat the path as if it
+    // is already from the project root. This prevents relative paths from being processed twice,
+    // most often within `toInternalSourceLocation` when handling loc types from symbols and asset
+    // dependencies.
+    if (p[0] !== '.' && !path_1.default.isAbsolute(p)) {
+        return p;
+    }
+    // If the file is outside the project root, store an absolute path rather than a relative one.
+    // This way if the project root is moved, the file references still work. Accessing files outside
+    // the project root is not portable anyway.
+    let relative = (0, utils_1.relativePath)(projectRoot, p, false);
+    if (relative.startsWith('..')) {
+        // e.g given projectRoot = '/Users/monorepo/project' and p = '/Users/monorepo/other-project/src/index.js' --> relative = '../other-project/src/index.js'
+        if ((0, feature_flags_1.getFeatureFlagValue)('patchProjectPaths')) {
+            return relative;
+        }
+        return process.platform === 'win32' ? (0, utils_1.normalizeSeparators)(p) : p;
+    }
+    return relative;
+}
+// @ts-expect-error TS2322
+exports.toProjectPath = toProjectPath_;
+function fromProjectPath_(projectRoot, p) {
+    if (p == null) {
+        return null;
+    }
+    // Project paths use normalized unix separators, so we only need to
+    // convert them on Windows.
+    let projectPath = process.platform === 'win32' ? path_1.default.normalize(p) : p;
+    // If the path is absolute (e.g. outside the project root), just return it.
+    if (path_1.default.isAbsolute(projectPath)) {
+        return projectPath;
+    }
+    // Add separator if needed. Doing this manunally is much faster than path.join.
+    if (projectRoot[projectRoot.length - 1] !== path_1.default.sep) {
+        return projectRoot + path_1.default.sep + projectPath;
+    }
+    return projectRoot + projectPath;
+}
+// @ts-expect-error TS2322
+exports.fromProjectPath = fromProjectPath_;
+/**
+ * Returns a path relative to the project root. This should be used when computing cache keys
+ */
+function fromProjectPathRelative(p) {
+    return p;
+}
+/**
+ * This function should be avoided, it doesn't change the actual value.
+ */
+function toProjectPathUnsafe(p) {
+    return p;
+}
+/**
+ * Joins a project root with relative paths (similar to `path.join`)
+ */
+function joinProjectPath(a, ...b) {
+    return path_1.default.posix.join(a, ...b);
+}