diff --git a/.github/workflows/integration-workflow.yml b/.github/workflows/integration-workflow.yml index 2c265ee740f5..9fc92576c0ff 100644 --- a/.github/workflows/integration-workflow.yml +++ b/.github/workflows/integration-workflow.yml @@ -55,7 +55,7 @@ jobs: env: TARGET_BRANCH: ${{github.event.pull_request.base.ref}} - - name: 'Check that the PnP hook is consistent with a fresh build (fix w/ "git merge master && yarn build:pnp:hook")' + - name: 'Check that the PnP hook is consistent with a fresh build (fix w/ "git merge master && yarn update:pnp:hook")' run: | if [[ $(git diff --name-only "$(git merge-base origin/"$TARGET_BRANCH" HEAD)" HEAD -- packages/yarnpkg-pnp/sources/hook.js | wc -l) -gt 0 ]]; then node ./scripts/run-yarn.js build:pnp:hook diff --git a/.pnp.cjs b/.pnp.cjs index 4df848db922c..61de6a5ec15d 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -11690,6 +11690,7 @@ function $$SETUP_STATE(hydrateRuntimeState, basePath) { ["@yarnpkg/fslib", "workspace:packages/yarnpkg-fslib"], ["@yarnpkg/libzip", "workspace:packages/yarnpkg-libzip"], ["@yarnpkg/monorepo", "workspace:."], + ["resolve.exports", "npm:1.0.2"], ["tslib", "npm:1.13.0"], ["typescript", "patch:typescript@npm%3A4.1.0-beta#builtin::version=4.1.0-beta&hash=a45b0e"], ["webpack", "virtual:16110bda3ce959c103b1979c5d750ceb8ac9cfbd2049c118b6278e46e65aa65fd17e71e04a0ce5f75b7ca3203efd8e9c9b03c948a76c7f4bca807539915b5cfc#npm:5.1.1"], @@ -32807,6 +32808,15 @@ function $$SETUP_STATE(hydrateRuntimeState, basePath) { "linkType": "HARD", }] ]], + ["resolve.exports", [ + ["npm:1.0.2", { + "packageLocation": "./.yarn/cache/resolve.exports-npm-1.0.2-bbb8d62ef6-012a46e3ae.zip/node_modules/resolve.exports/", + "packageDependencies": [ + ["resolve.exports", "npm:1.0.2"] + ], + "linkType": "HARD", + }] + ]], ["responselike", [ ["npm:1.0.2", { "packageLocation": "./.yarn/cache/responselike-npm-1.0.2-d0bf50cde4-c904f14994.zip/node_modules/responselike/", @@ -39039,7 +39049,7 @@ function $$SETUP_STATE(hydrateRuntimeState, basePath) { return /******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ -/***/ 807: +/***/ 289: /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { "use strict"; @@ -44154,24 +44164,37 @@ function hydrateRuntimeState(data, { const packageLocationLengths = new Set(); const packageRegistry = new Map(data.packageRegistryData.map(([packageName, packageStoreData]) => { return [packageName, new Map(packageStoreData.map(([packageReference, packageInformationData]) => { + var _a; + if (packageName === null !== (packageReference === null)) throw new Error(`Assertion failed: The name and reference should be null, or neither should`); + const discardFromLookup = (_a = packageInformationData.discardFromLookup) !== null && _a !== void 0 ? _a : false; // @ts-expect-error: TypeScript isn't smart enough to understand the type assertion - if (!packageInformationData.discardFromLookup) { - // @ts-expect-error: TypeScript isn't smart enough to understand the type assertion - const packageLocator = { - name: packageName, - reference: packageReference - }; - packageLocatorsByLocations.set(packageInformationData.packageLocation, packageLocator); - packageLocationLengths.add(packageInformationData.packageLocation.length); + const packageLocator = { + name: packageName, + reference: packageReference + }; + const entry = packageLocatorsByLocations.get(packageInformationData.packageLocation); + + if (!entry) { + packageLocatorsByLocations.set(packageInformationData.packageLocation, { + locator: packageLocator, + discardFromLookup + }); + } else { + entry.discardFromLookup = entry.discardFromLookup && discardFromLookup; + + if (!discardFromLookup) { + entry.locator = packageLocator; + } } + packageLocationLengths.add(packageInformationData.packageLocation.length); let resolvedPackageLocation = null; return [packageReference, { packageDependencies: new Map(packageInformationData.packageDependencies), packagePeers: new Set(packageInformationData.packagePeers), linkType: packageInformationData.linkType, - discardFromLookup: packageInformationData.discardFromLookup || false, + discardFromLookup, // we only need this for packages that are used by the currently running script // this is a lazy getter because `ppath.join` has some overhead @@ -44206,12 +44229,160 @@ function hydrateRuntimeState(data, { packageRegistry }; } +// CONCATENATED MODULE: ../../.yarn/cache/resolve.exports-npm-1.0.2-bbb8d62ef6-012a46e3ae.zip/node_modules/resolve.exports/dist/index.mjs +/** + * @param {object} exports + * @param {Set} keys + */ +function loop(exports, keys) { + if (typeof exports === 'string') { + return exports; + } + + if (exports) { + let idx, tmp; + if (Array.isArray(exports)) { + for (idx=0; idx < exports.length; idx++) { + if (tmp = loop(exports[idx], keys)) return tmp; + } + } else { + for (idx in exports) { + if (keys.has(idx)) { + return loop(exports[idx], keys); + } + } + } + } +} + +/** + * @param {string} name The package name + * @param {string} entry The target entry, eg "." + * @param {number} [condition] Unmatched condition? + */ +function bail(name, entry, condition) { + throw new Error( + condition + ? `No known conditions for "${entry}" entry in "${name}" package` + : `Missing "${entry}" export in "${name}" package` + ); +} + +/** + * @param {string} name the package name + * @param {string} entry the target path/import + */ +function toName(name, entry) { + return entry === name ? '.' + : entry[0] === '.' ? entry + : entry.replace(new RegExp('^' + name + '\/'), './'); +} + +/** + * @param {object} pkg package.json contents + * @param {string} [entry] entry name or import path + * @param {object} [options] + * @param {boolean} [options.browser] + * @param {boolean} [options.require] + * @param {string[]} [options.conditions] + */ +function resolve(pkg, entry='.', options={}) { + let { name, exports } = pkg; + + if (exports) { + let { browser, require, conditions=[] } = options; + + let target = toName(name, entry); + if (target[0] !== '.') target = './' + target; + + if (typeof exports === 'string') { + return target === '.' ? exports : bail(name, target); + } + + let allows = new Set(['default', ...conditions]); + allows.add(require ? 'require' : 'import'); + allows.add(browser ? 'browser' : 'node'); + + let key, tmp, isSingle=false; + + for (key in exports) { + isSingle = key[0] !== '.'; + break; + } + + if (isSingle) { + return target === '.' + ? loop(exports, allows) || bail(name, target, 1) + : bail(name, target); + } + + if (tmp = exports[target]) { + return loop(tmp, allows) || bail(name, target, 1); + } + + for (key in exports) { + tmp = key[key.length - 1]; + if (tmp === '/' && target.startsWith(key)) { + return (tmp = loop(exports[key], allows)) + ? (tmp + target.substring(key.length)) + : bail(name, target, 1); + } + if (tmp === '*' && target.startsWith(key.slice(0, -1))) { + // do not trigger if no *content* to inject + if (target.substring(key.length - 1).length > 0) { + return (tmp = loop(exports[key], allows)) + ? tmp.replace('*', target.substring(key.length - 1)) + : bail(name, target, 1); + } + } + } + + return bail(name, target); + } +} + +/** + * @param {object} pkg + * @param {object} [options] + * @param {string|boolean} [options.browser] + * @param {string[]} [options.fields] + */ +function legacy(pkg, options={}) { + let i=0, value, + browser = options.browser, + fields = options.fields || ['module', 'main']; + + if (browser && !fields.includes('browser')) { + fields.unshift('browser'); + } + + for (; i < fields.length; i++) { + if (value = pkg[fields[i]]) { + if (typeof value == 'string') { + // + } else if (typeof value == 'object' && fields[i] == 'browser') { + if (typeof browser == 'string') { + value = value[browser=toName(pkg.name, browser)]; + if (value == null) return browser; + } + } else { + continue; + } + + return typeof value == 'string' + ? ('./' + value.replace(/^\.?\//, '')) + : value; + } + } +} + // CONCATENATED MODULE: ./sources/loader/makeApi.ts + function makeApi(runtimeState, opts) { const alwaysWarnOnFallback = Number(process.env.PNP_ALWAYS_WARN_ON_FALLBACK) > 0; const debugLevel = Number(process.env.PNP_DEBUG_LEVEL); // @ts-expect-error @@ -44223,7 +44394,9 @@ function makeApi(runtimeState, opts) { const isStrictRegExp = /^(\/|\.{1,2}(\/|$))/; // Matches if the path must point to a directory (ie ends with /) - const isDirRegExp = /\/$/; // We only instantiate one of those so that we can use strict-equal comparisons + const isDirRegExp = /\/$/; // Matches if the path starts with a relative path qualifier (./, ../) + + const isRelativeRegexp = /^\.{0,2}\//; // We only instantiate one of those so that we can use strict-equal comparisons const topLevelLocator = { name: null, @@ -44383,6 +44556,46 @@ function makeApi(runtimeState, opts) { return false; } + /** + * Implements the node resolution for the "exports" field + * + * @returns The remapped path or `null` if the package doesn't have a package.json or an "exports" field + */ + + + function applyNodeExportsResolution(unqualifiedPath) { + const locator = findPackageLocator(ppath.join(unqualifiedPath, `internal.js`), { + resolveIgnored: true, + includeDiscardFromLookup: true + }); + + if (locator === null) { + throw internalTools_makeError(ErrorCode.INTERNAL, `The locator that owns the "${unqualifiedPath}" path can't be found inside the dependency tree (this is probably an internal error)`); + } + + const { + packageLocation + } = getPackageInformationSafe(locator); + const manifestPath = ppath.join(packageLocation, Filename.manifest); + if (!opts.fakeFs.existsSync(manifestPath)) return null; + const pkgJson = JSON.parse(opts.fakeFs.readFileSync(manifestPath, `utf8`)); + let subpath = ppath.contains(packageLocation, unqualifiedPath); + + if (subpath === null) { + throw internalTools_makeError(ErrorCode.INTERNAL, `unqualifiedPath doesn't contain the packageLocation (this is probably an internal error)`); + } + + if (!isRelativeRegexp.test(subpath)) subpath = `./${subpath}`; + const resolvedExport = resolve(pkgJson, ppath.normalize(subpath), { + browser: false, + require: true, + // TODO: implement support for the --conditions flag + // Waiting on https://github.com/nodejs/node/issues/36935 + conditions: [] + }); + if (typeof resolvedExport === `string`) return ppath.join(packageLocation, resolvedExport); + return null; + } /** * Implements the node resolution for folder access and extension selection */ @@ -44405,7 +44618,7 @@ function makeApi(runtimeState, opts) { let pkgJson; try { - pkgJson = JSON.parse(opts.fakeFs.readFileSync(ppath.join(unqualifiedPath, `package.json`), `utf8`)); + pkgJson = JSON.parse(opts.fakeFs.readFileSync(ppath.join(unqualifiedPath, Filename.manifest), `utf8`)); } catch (error) {} let nextUnqualifiedPath; @@ -44613,8 +44826,11 @@ function makeApi(runtimeState, opts) { */ - function findPackageLocator(location) { - if (isPathIgnored(location)) return null; + function findPackageLocator(location, { + resolveIgnored = false, + includeDiscardFromLookup = false + } = {}) { + if (isPathIgnored(location) && !resolveIgnored) return null; let relativeLocation = ppath.relative(runtimeState.basePath, location); if (!relativeLocation.match(isStrictRegExp)) relativeLocation = `./${relativeLocation}`; if (!relativeLocation.endsWith(`/`)) relativeLocation = `${relativeLocation}/`; @@ -44623,8 +44839,8 @@ function makeApi(runtimeState, opts) { while (from < packageLocationLengths.length && packageLocationLengths[from] > relativeLocation.length) from += 1; for (let t = from; t < packageLocationLengths.length; ++t) { - const locator = packageLocatorsByLocations.get(relativeLocation.substr(0, packageLocationLengths[t])); - if (typeof locator === `undefined`) continue; // Ensures that the returned locator isn't a blacklisted one. + const entry = packageLocatorsByLocations.get(relativeLocation.substr(0, packageLocationLengths[t])); + if (typeof entry === `undefined`) continue; // Ensures that the returned locator isn't a blacklisted one. // // Blacklisted packages are packages that cannot be used because their dependencies cannot be deduced. This only // happens with peer dependencies, which effectively have different sets of dependencies depending on their @@ -44640,14 +44856,15 @@ function makeApi(runtimeState, opts) { // paths, we're able to print a more helpful error message that points out that a third-party package is doing // something incompatible! - if (locator === null) { + if (entry === null) { const locationForDisplay = getPathForDisplay(location); throw internalTools_makeError(ErrorCode.BLACKLISTED, `A forbidden path has been used in the package resolution process - this is usually caused by one of your tools calling 'fs.realpath' on the return value of 'require.resolve'. Since we need to use symlinks to simultaneously provide valid filesystem paths and disambiguate peer dependencies, they must be passed untransformed to 'require'.\n\nForbidden path: ${locationForDisplay}`, { location: locationForDisplay }); } - return locator; + if (entry.discardFromLookup && !includeDiscardFromLookup) continue; + return entry.locator; } return null; @@ -44902,6 +45119,18 @@ function makeApi(runtimeState, opts) { return ppath.normalize(unqualifiedPath); } + + function resolveUnqualifiedExport(request, unqualifiedPath) { + // "exports" only apply when requiring a package, not when requiring via an absolute / relative path + if (isStrictRegExp.test(request)) return unqualifiedPath; + const unqualifiedExportPath = applyNodeExportsResolution(unqualifiedPath); + + if (unqualifiedExportPath) { + return ppath.normalize(unqualifiedExportPath); + } else { + return unqualifiedPath; + } + } /** * Transforms an unqualified path into a qualified path by using the Node resolution algorithm (which automatically * appends ".js" / ".json", and transforms directory accesses into "index.js"). @@ -44943,8 +45172,12 @@ function makeApi(runtimeState, opts) { }); if (unqualifiedPath === null) return null; + const isIssuerIgnored = () => issuer !== null ? isPathIgnored(issuer) : false; + + const remappedPath = (!considerBuiltins || !builtinModules.has(request)) && !isIssuerIgnored() ? resolveUnqualifiedExport(request, unqualifiedPath) : unqualifiedPath; + try { - return resolveUnqualified(unqualifiedPath, { + return resolveUnqualified(remappedPath, { extensions }); } catch (resolutionError) { @@ -49886,7 +50119,7 @@ module.exports = require("path");; /******/ // module exports must be returned from runtime so entry inlining is disabled /******/ // startup /******/ // Load entry module and return exports -/******/ return __webpack_require__(807); +/******/ return __webpack_require__(289); /******/ })() .default; }); \ No newline at end of file diff --git a/.yarn/cache/resolve.exports-npm-1.0.2-bbb8d62ef6-012a46e3ae.zip b/.yarn/cache/resolve.exports-npm-1.0.2-bbb8d62ef6-012a46e3ae.zip new file mode 100644 index 000000000000..2a372b6f10d1 Binary files /dev/null and b/.yarn/cache/resolve.exports-npm-1.0.2-bbb8d62ef6-012a46e3ae.zip differ diff --git a/.yarn/versions/9f82aeec.yml b/.yarn/versions/9f82aeec.yml new file mode 100644 index 000000000000..9cb51e96570b --- /dev/null +++ b/.yarn/versions/9f82aeec.yml @@ -0,0 +1,26 @@ +releases: + "@yarnpkg/cli": minor + "@yarnpkg/plugin-node-modules": patch + "@yarnpkg/plugin-pack": minor + "@yarnpkg/plugin-pnp": minor + "@yarnpkg/pnp": minor + +declined: + - "@yarnpkg/esbuild-plugin-pnp" + - "@yarnpkg/plugin-compat" + - "@yarnpkg/plugin-constraints" + - "@yarnpkg/plugin-dlx" + - "@yarnpkg/plugin-essentials" + - "@yarnpkg/plugin-init" + - "@yarnpkg/plugin-interactive-tools" + - "@yarnpkg/plugin-npm" + - "@yarnpkg/plugin-npm-cli" + - "@yarnpkg/plugin-patch" + - "@yarnpkg/plugin-stage" + - "@yarnpkg/plugin-typescript" + - "@yarnpkg/plugin-version" + - "@yarnpkg/plugin-workspace-tools" + - "@yarnpkg/builder" + - "@yarnpkg/core" + - "@yarnpkg/doctor" + - "@yarnpkg/pnpify" diff --git a/.yarnrc.yml b/.yarnrc.yml index 614ed8fdb384..4efbf59a3aab 100644 --- a/.yarnrc.yml +++ b/.yarnrc.yml @@ -1,5 +1,5 @@ changesetIgnorePatterns: - - "**/*.test.{js,ts}" + - "**/*.test.{js,ts}" enableGlobalCache: false diff --git a/packages/acceptance-tests/pkg-tests-core/sources/utils/yarn.ts b/packages/acceptance-tests/pkg-tests-core/sources/utils/yarn.ts index 62579731c35b..2390b05ba71c 100644 --- a/packages/acceptance-tests/pkg-tests-core/sources/utils/yarn.ts +++ b/packages/acceptance-tests/pkg-tests-core/sources/utils/yarn.ts @@ -1,7 +1,7 @@ -import {DEFAULT_RC_FILENAME, Manifest} from '@yarnpkg/core'; -import {PortablePath, ppath, Filename} from '@yarnpkg/fslib'; +import {DEFAULT_RC_FILENAME, Manifest} from '@yarnpkg/core'; +import {PortablePath, ppath, Filename, xfs} from '@yarnpkg/fslib'; -import * as fsUtils from './fs'; +import * as fsUtils from './fs'; export async function readConfiguration(dir: PortablePath, {filename = DEFAULT_RC_FILENAME}: {filename?: Filename} = {}) { return await fsUtils.readSyml(ppath.join(dir, filename)); @@ -16,6 +16,15 @@ export async function readManifest(dir: PortablePath, {key, filename = Filename. return key != null ? data?.[key] : data; } +export async function writeManifest(dir: PortablePath, value: {[key: string]: any}, {filename = Filename.manifest}: {filename?: Filename} = {}) { + return await fsUtils.writeJson(ppath.join(dir, filename), value); +} + +export async function writePackage(dir: PortablePath, manifest: {[key: string]: any}) { + await xfs.mkdirPromise(dir, {recursive: true}); + await writeManifest(dir, manifest); +} + export function getPluginPath(dir: PortablePath, name: string) { return ppath.join(dir, `.yarn/plugins/${name}.cjs` as PortablePath); } diff --git a/packages/acceptance-tests/pkg-tests-specs/sources/exports.test.ts b/packages/acceptance-tests/pkg-tests-specs/sources/exports.test.ts new file mode 100644 index 000000000000..0433bb5a1b5f --- /dev/null +++ b/packages/acceptance-tests/pkg-tests-specs/sources/exports.test.ts @@ -0,0 +1,880 @@ +import {NativePath, npath, PortablePath, ppath, xfs} from '@yarnpkg/fslib'; +import {createTemporaryFolder} from 'pkg-tests-core/sources/utils/fs'; +import {yarn} from 'pkg-tests-core'; + +export type Manifest = { + name: string; + main?: string; + exports?: string | object; +}; + +export async function writeTestPackage(path: PortablePath, manifest: Manifest, files: Array) { + await yarn.writePackage(path, {...manifest, version: `1.0.0`}); + + await Promise.all((files as Array).map(async file => { + const p = ppath.join(path, file); + + await xfs.mkdirpPromise(ppath.dirname(p)); + await xfs.writeFilePromise(p, `module.exports = __filename;\n`); + })); +} + +export type Assertions = { + pass?: Array<[/*request: */string, /*resolved: */string]>, + fail?: Array<[/*request: */string, /*error: */string | {message: string, code?: string, pnpCode?: string}]>, +}; + +export function makeTemporaryExportsEnv(testPackageName: string, manifest: Omit, files: Array, {pass, fail}: Assertions) { + return makeTemporaryEnv({ + dependencies: { + [testPackageName]: `file:./${testPackageName}`, + }, + }, async ({path, run, source}) => { + await writeTestPackage(`${path}/${testPackageName}` as PortablePath, { + name: testPackageName, + ...manifest, + }, files); + + await run(`install`); + + const makeScript = (request: string) => `require(${JSON.stringify(request)})`; + + const getPathRelativeToPackageRoot = (filename: NativePath) => { + const match = /node_modules\/.+?\/(.+)$/.exec(ppath.relative(path, npath.toPortablePath(filename))); + if (match === null) + throw new Error(`Assertion failed: Expected the match to be successful`); + + return match[1] as PortablePath; + }; + + const sourceRequest = (request: string) => source(makeScript(interpolateVariables(request))).then(p => getPathRelativeToPackageRoot(p as any)); + + const interpolateVariables = (input: string) => input.replace(`$PKG`, testPackageName); + + if (typeof pass !== `undefined`) { + for (const [request, file] of pass) { + await expect(sourceRequest(request)).resolves.toBe(interpolateVariables(file)); + } + } + + if (typeof fail !== `undefined`) { + for (const [request, message] of fail) { + const actualMessage = typeof message === `string` ? message : message.message; + + await expect(sourceRequest(request)).rejects.toMatchObject({ + externalException: { + ...(typeof message === `object` ? message : {}), + message: expect.stringContaining(interpolateVariables(actualMessage)), + }, + }); + } + } + }); +} + +describe(`"exports" field`, () => { + test( + `implicit "main" field`, + makeTemporaryExportsEnv(`main-implicit`, {}, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + pass: [ + [`$PKG`, `index.js`], + [`$PKG/file`, `file.js`], + ], + }) + ); + + test( + `dotted "main" field`, + makeTemporaryExportsEnv(`main-dotted`, { + main: `./file.js`, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/index`, `index.js`], + ], + }) + ); + + test( + `dotless "main" field`, + makeTemporaryExportsEnv(`main-dotless`, { + main: `file.js`, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/index`, `index.js`], + ], + }) + ); + + test( + `dot-slash "main" field`, + makeTemporaryExportsEnv(`main-dot-slash`, { + main: `./`, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + pass: [ + [`$PKG`, `index.js`], + [`$PKG/file`, `file.js`], + ], + }) + ); + + test( + `string "exports" field`, + makeTemporaryExportsEnv(`exports-string`, { + exports: `./file.js`, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and string "exports" field`, + makeTemporaryExportsEnv(`main-exports-string`, { + main: `main.js`, + exports: `./file.js`, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `file.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + ], + fail: [ + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + ], + }) + ); + + test( + `top-level object conditional "exports" field`, + makeTemporaryExportsEnv(`exports-top-level-object`, { + exports: { + import: `./import.mjs`, + node: `./node.js`, + require: `./require.js`, + default: `./default.js`, + }, + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `node.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and top-level object conditional "exports" field`, + makeTemporaryExportsEnv(`main-exports-top-level-object`, { + main: `main.js`, + exports: { + import: `./import.mjs`, + node: `./node.js`, + require: `./require.js`, + default: `./default.js`, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `node.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `dot object conditional "exports" field`, + makeTemporaryExportsEnv(`exports-dot-object`, { + exports: { + [`.`]: { + import: `./import.mjs`, + node: `./node.js`, + require: `./require.js`, + default: `./default.js`, + }, + }, + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `node.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and dot object conditional "exports" field`, + makeTemporaryExportsEnv(`main-exports-dot-object`, { + main: `main.js`, + exports: { + [`.`]: { + import: `./import.mjs`, + node: `./node.js`, + require: `./require.js`, + default: `./default.js`, + }, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `node.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `dot object conditional "exports" field with nested conditions`, + makeTemporaryExportsEnv(`exports-dot-object`, { + exports: { + [`.`]: { + node: { + import: `./import.mjs`, + require: `./require.js`, + }, + default: `./default.js`, + }, + }, + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `require.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and dot object conditional "exports" field with nested conditions`, + makeTemporaryExportsEnv(`main-exports-dot-object`, { + main: `main.js`, + exports: { + [`.`]: { + node: { + import: `./import.mjs`, + require: `./require.js`, + }, + default: `./default.js`, + }, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `node.js`, + `require.js`, + `default.js`, + ], { + pass: [ + [`$PKG`, `require.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/node`, `Missing "./node" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `top-level array fallback "exports" field`, + makeTemporaryExportsEnv(`exports-top-level-object`, { + exports: [ + {import: `./import.mjs`}, + `default.js`, + ], + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `default.js`, + ], { + pass: [ + [`$PKG`, `default.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and top-level array fallback "exports" field`, + makeTemporaryExportsEnv(`main-exports-top-level-object`, { + main: `main.js`, + exports: [ + {import: `./import.mjs`}, + `default.js`, + ], + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `default.js`, + ], { + pass: [ + [`$PKG`, `default.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `dot object array fallback "exports" field`, + makeTemporaryExportsEnv(`exports-top-level-object`, { + exports: { + [`.`]: [ + {import: `./import.mjs`}, + `default.js`, + ], + }, + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `default.js`, + ], { + pass: [ + [`$PKG`, `default.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field and dot object array fallback "exports" field`, + makeTemporaryExportsEnv(`main-exports-top-level-object`, { + main: `main.js`, + exports: { + [`.`]: [ + {import: `./import.mjs`}, + `default.js`, + ], + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `default.js`, + ], { + pass: [ + [`$PKG`, `default.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/import`, `Missing "./import" export in "$PKG" package`], + [`$PKG/default`, `Missing "./default" export in "$PKG" package`], + ], + }) + ); + + test( + `object subpath "exports" field`, + makeTemporaryExportsEnv(`exports-object-subpath`, { + exports: { + [`.`]: `file.js`, + [`./submodule`]: `./lib/submodule`, + }, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + `lib/submodule.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/submodule`, `lib/submodule.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + ], + }) + ); + + test( + `"main" field object subpath "exports" field`, + makeTemporaryExportsEnv(`main-exports-object-subpath`, { + main: `main.js`, + exports: { + [`.`]: `file.js`, + [`./submodule`]: `./lib/submodule`, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `file.js`, + `lib/submodule.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/submodule`, `lib/submodule.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + ], + }) + ); + + test( + `object subpath patterns "exports" field`, + makeTemporaryExportsEnv(`exports-object-subpath-patterns`, { + exports: { + [`.`]: `file.js`, + [`./src/*`]: `./lib/*`, + }, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + `lib/a.js`, + `lib/b.js`, + `lib/c.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/src/a`, `lib/a.js`], + [`$PKG/src/b`, `lib/b.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + [`$PKG/src`, `Missing "./src" export in "$PKG" package`], + [`$PKG/src/`, `Missing "./src/" export in "$PKG" package`], + [`$PKG/lib/c`, `Missing "./lib/c" export in "$PKG" package`], + [`$PKG/src/d`, { + code: `MODULE_NOT_FOUND`, + message: `Qualified path resolution failed`, + pnpCode: `QUALIFIED_PATH_RESOLUTION_FAILED`, + }], + ], + }) + ); + + test( + `"main" field and object subpath patterns "exports" field`, + makeTemporaryExportsEnv(`main-exports-object-subpath-patterns`, { + main: `main.js`, + exports: { + [`.`]: `file.js`, + [`./src/*`]: `./lib/*`, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `file.js`, + `lib/a.js`, + `lib/b.js`, + `lib/c.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/src/a`, `lib/a.js`], + [`$PKG/src/b`, `lib/b.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + [`$PKG/src`, `Missing "./src" export in "$PKG" package`], + [`$PKG/src/`, `Missing "./src/" export in "$PKG" package`], + [`$PKG/lib/c`, `Missing "./lib/c" export in "$PKG" package`], + [`$PKG/src/d`, { + code: `MODULE_NOT_FOUND`, + message: `Qualified path resolution failed`, + pnpCode: `QUALIFIED_PATH_RESOLUTION_FAILED`, + }], + ], + }) + ); + + // Deprecated by Node, will eventually be removed + test( + `object subpath folder mappings "exports" field`, + makeTemporaryExportsEnv(`exports-object-subpath-folder-mappings`, { + exports: { + [`.`]: `file.js`, + [`./src/`]: `./lib/`, + }, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + `lib/index.js`, + `lib/a.js`, + `lib/b.js`, + `lib/c.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/src/`, `lib/index.js`], + [`$PKG/src/a`, `lib/a.js`], + [`$PKG/src/b`, `lib/b.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + [`$PKG/src`, `Missing "./src" export in "$PKG" package`], + [`$PKG/lib/c`, `Missing "./lib/c" export in "$PKG" package`], + [`$PKG/src/d`, { + code: `MODULE_NOT_FOUND`, + message: `Qualified path resolution failed`, + pnpCode: `QUALIFIED_PATH_RESOLUTION_FAILED`, + }], + ], + }) + ); + + // Deprecated by Node, will eventually be removed + test( + `"main" field and object subpath subpath folder mappings "exports" field`, + makeTemporaryExportsEnv(`main-exports-object-subpath-folder-mappings`, { + main: `main.js`, + exports: { + [`.`]: `file.js`, + [`./src/`]: `./lib/`, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `file.js`, + `lib/index.js`, + `lib/a.js`, + `lib/b.js`, + `lib/c.js`, + ], { + pass: [ + [`$PKG`, `file.js`], + [`$PKG/src/`, `lib/index.js`], + [`$PKG/src/a`, `lib/a.js`], + [`$PKG/src/b`, `lib/b.js`], + ], + fail: [ + [`$PKG/index`, `Missing "./index" export in "$PKG" package`], + [`$PKG/main`, `Missing "./main" export in "$PKG" package`], + [`$PKG/inexistent`, `Missing "./inexistent" export in "$PKG" package`], + [`$PKG/src`, `Missing "./src" export in "$PKG" package`], + [`$PKG/lib/c`, `Missing "./lib/c" export in "$PKG" package`], + [`$PKG/src/d`, { + code: `MODULE_NOT_FOUND`, + message: `Qualified path resolution failed`, + pnpCode: `QUALIFIED_PATH_RESOLUTION_FAILED`, + }], + ], + }) + ); + + test( + `only import top-level object conditional "exports" field`, + makeTemporaryExportsEnv(`exports-top-level-object-only-import`, { + exports: { + node: { + import: `./node-import.mjs`, + }, + import: `./import.mjs`, + }, + }, [ + `index.js`, + `index.mjs`, + `import.mjs`, + `node-import.mjs`, + ], { + fail: [ + [`$PKG`, `No known conditions for "." entry in "$PKG" package`], + ], + }) + ); + + test( + `main field and only import top-level object conditional "exports" field`, + makeTemporaryExportsEnv(`main-exports-top-level-object-only-import`, { + main: `main.js`, + exports: { + node: { + import: `./node-import.mjs`, + }, + import: `./import.mjs`, + }, + }, [ + `index.js`, + `index.mjs`, + `main.js`, + `import.mjs`, + `node-import.mjs`, + ], { + fail: [ + [`$PKG`, `No known conditions for "." entry in "$PKG" package`], + ], + }) + ); + + test( + `manifest not exported`, + makeTemporaryExportsEnv(`manifest-not-exported`, { + exports: `./file.js`, + }, [ + `index.js`, + `index.mjs`, + `file.js`, + ], { + fail: [ + [`$PKG/package.json`, `Missing "./package.json" export in "$PKG" package`], + ], + }) + ); + + test( + `self-referencing with exports`, + makeTemporaryEnv({ + name: `pkg`, + exports: { + [`.`]: `./main.js`, + [`./foo`]: `./bar.js`, + }, + }, async ({path, run, source}) => { + await run(`install`); + + await xfs.writeFilePromise(`${path}/main.js` as PortablePath, ``); + await xfs.writeFilePromise(`${path}/bar.js` as PortablePath, ``); + + await expect(source(`require.resolve('pkg')`)).resolves.toStrictEqual(npath.fromPortablePath(`${path}/main.js`)); + await expect(source(`require.resolve('pkg/foo')`)).resolves.toStrictEqual(npath.fromPortablePath(`${path}/bar.js`)); + await expect(source(`require.resolve('pkg/bar')`)).rejects.toMatchObject({ + externalException: { + message: expect.stringContaining(`Missing "./bar" export in "pkg" package`), + }, + }); + }) + ); + + test( + `link: with exports (inside the project)`, + makeTemporaryEnv({}, async ({path, run, source}) => { + await xfs.mkdirPromise(`${path}/linked` as PortablePath); + + await xfs.writeJsonPromise(`${path}/linked/package.json` as PortablePath, { + name: `linked`, + exports: { + [`.`]: `./main.js`, + [`./foo`]: `./bar.js`, + }, + }); + + await xfs.writeFilePromise(`${path}/linked/main.js` as PortablePath, ``); + await xfs.writeFilePromise(`${path}/linked/bar.js` as PortablePath, ``); + + await xfs.writeJsonPromise(`${path}/package.json` as PortablePath, { + name: `pkg`, + dependencies: { + [`linked`]: `link:./linked`, + }, + exports: { + [`.`]: `./main.js`, + [`./foo`]: `./bar.js`, + }, + }); + + await xfs.writeFilePromise(`${path}/main.js` as PortablePath, ``); + await xfs.writeFilePromise(`${path}/bar.js` as PortablePath, ``); + + await run(`install`); + + await expect(source(`require.resolve('linked')`)).resolves.toStrictEqual(npath.fromPortablePath(`${path}/linked/main.js`)); + await expect(source(`require.resolve('linked/foo')`)).resolves.toStrictEqual(npath.fromPortablePath(`${path}/linked/bar.js`)); + }) + ); + + test( + `link: with exports (outside the project)`, + makeTemporaryEnv({}, async ({path, run, source}) => { + const tmp = await createTemporaryFolder(); + + await xfs.writeJsonPromise(`${tmp}/package.json` as PortablePath, { + name: `linked`, + exports: { + [`.`]: `./main.js`, + [`./foo`]: `./bar.js`, + }, + }); + + await xfs.writeFilePromise(`${tmp}/main.js` as PortablePath, ``); + await xfs.writeFilePromise(`${tmp}/bar.js` as PortablePath, ``); + + await xfs.writeJsonPromise(`${path}/package.json` as PortablePath, { + name: `pkg`, + dependencies: { + [`linked`]: `link:${tmp}`, + }, + exports: { + [`.`]: `./main.js`, + [`./foo`]: `./bar.js`, + }, + }); + + await xfs.writeFilePromise(`${path}/main.js` as PortablePath, ``); + await xfs.writeFilePromise(`${path}/bar.js` as PortablePath, ``); + + await run(`install`); + + await expect(source(`require.resolve('linked')`)).resolves.toStrictEqual(npath.fromPortablePath(`${tmp}/main.js`)); + await expect(source(`require.resolve('linked/foo')`)).resolves.toStrictEqual(npath.fromPortablePath(`${tmp}/bar.js`)); + }) + ); + + test( + `pnpIgnorePatterns with exports (issuer ignored)`, + makeTemporaryEnv( + {}, + { + pnpIgnorePatterns: `foo/**`, + }, + async ({path, run, source}) => { + await xfs.writeJsonPromise(`${path}/package.json` as PortablePath, { + name: `pkg`, + exports: { + [`.`]: `./main.js`, + }, + }); + + await run(`install`); + + await xfs.writeFilePromise(`${path}/main.js` as PortablePath, ``); + + await xfs.mkdirpPromise(`${path}/node_modules/dep` as PortablePath); + + await xfs.writeJsonPromise(`${path}/node_modules/dep/package.json` as PortablePath, { + name: `dep`, + exports: { + [`.`]: `./main.js`, + }, + }); + + await xfs.writeFilePromise(`${path}/node_modules/dep/main.js` as PortablePath, ``); + + await xfs.mkdirPromise(`${path}/foo` as PortablePath); + + await xfs.writeFilePromise(`${path}/foo/node-resolution.js` as PortablePath, `module.exports = require.resolve('dep');\n`); + + await expect(source(`require('./foo/node-resolution')`)).resolves.toStrictEqual(npath.fromPortablePath(`${path}/node_modules/dep/main.js`)); + }, + ), + ); + + // TODO: write a better, self-contained test + test( + `pnpIgnorePatterns with exports (subpath ignored)`, + async () => { + expect(require.resolve(`@yarnpkg/monorepo/.yarn/sdks/typescript/lib/tsserver.js`)).toStrictEqual(npath.join(__dirname, `../../../../.yarn/sdks/typescript/lib/tsserver.js`)); + }, + ); +}); diff --git a/packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.js b/packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.ts similarity index 95% rename from packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.js rename to packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.ts index 0d03f8240dc2..654b8dd1ed8b 100644 --- a/packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.js +++ b/packages/acceptance-tests/pkg-tests-specs/sources/pnpapi.test.ts @@ -1,13 +1,9 @@ -import {ppath, npath, xfs} from '@yarnpkg/fslib'; +import {ppath, npath, xfs, PortablePath} from '@yarnpkg/fslib'; const { fs: {writeFile, writeJson}, } = require(`pkg-tests-core`); -const skipIfNode10 = process.version.startsWith(`v10.`) - ? test.skip - : test; - describe(`Plug'n'Play API`, () => { test( `it should expose VERSIONS`, @@ -37,7 +33,7 @@ describe(`Plug'n'Play API`, () => { }), ); - skipIfNode10( + test( `it shouldn't mess up when using createRequire on virtual files`, makeTemporaryEnv({ private: true, @@ -49,8 +45,8 @@ describe(`Plug'n'Play API`, () => { [`no-deps`]: `1.0.0`, }, }, async ({path, run, source}) => { - await xfs.mkdirpPromise(`${path}/workspace`); - await xfs.writeJsonPromise(`${path}/workspace/package.json`, { + await xfs.mkdirpPromise(`${path}/workspace` as PortablePath); + await xfs.writeJsonPromise(`${path}/workspace/package.json` as PortablePath, { name: `workspace`, peerDependencies: { [`no-deps`]: `*`, @@ -64,7 +60,7 @@ describe(`Plug'n'Play API`, () => { ); test( - `it should expose resolveToUnqualified`, + `it should expose resolveUnqualified`, makeTemporaryEnv({}, async ({path, run, source}) => { await run(`install`); @@ -143,8 +139,8 @@ describe(`Plug'n'Play API`, () => { `packages/*`, ], }, async ({path, run, source}) => { - await xfs.mkdirpPromise(ppath.join(path, `packages/foo`)); - await xfs.writeJsonPromise(ppath.join(path, `packages/foo/package.json`), { + await xfs.mkdirpPromise(ppath.join(path, `packages/foo` as PortablePath)); + await xfs.writeJsonPromise(ppath.join(path, `packages/foo/package.json` as PortablePath), { name: `foo`, dependencies: { [`bar`]: `workspace:*`, @@ -152,8 +148,8 @@ describe(`Plug'n'Play API`, () => { }, }); - await xfs.mkdirpPromise(ppath.join(path, `packages/bar`)); - await xfs.writeJsonPromise(ppath.join(path, `packages/bar/package.json`), { + await xfs.mkdirpPromise(ppath.join(path, `packages/bar` as PortablePath)); + await xfs.writeJsonPromise(ppath.join(path, `packages/bar/package.json` as PortablePath), { name: `bar`, peerDependencies: { [`no-deps`]: `1.0.0`, @@ -186,8 +182,8 @@ describe(`Plug'n'Play API`, () => { `packages/*`, ], }, async ({path, run, source}) => { - await xfs.mkdirpPromise(ppath.join(path, `packages/foo`)); - await xfs.writeJsonPromise(ppath.join(path, `packages/foo/package.json`), { + await xfs.mkdirpPromise(ppath.join(path, `packages/foo` as PortablePath)); + await xfs.writeJsonPromise(ppath.join(path, `packages/foo/package.json` as PortablePath), { name: `foo`, dependencies: { [`bar`]: `workspace:*`, @@ -195,8 +191,8 @@ describe(`Plug'n'Play API`, () => { }, }); - await xfs.mkdirpPromise(ppath.join(path, `packages/bar`)); - await xfs.writeJsonPromise(ppath.join(path, `packages/bar/package.json`), { + await xfs.mkdirpPromise(ppath.join(path, `packages/bar` as PortablePath)); + await xfs.writeJsonPromise(ppath.join(path, `packages/bar/package.json` as PortablePath), { name: `bar`, peerDependencies: { [`no-deps`]: `1.0.0`, @@ -383,11 +379,11 @@ describe(`Plug'n'Play API`, () => { private: true, workspaces: [`packages/*`], }, async ({path, run, source}) => { - await xfs.mkdirpPromise(`${path}/packages/workspace-a`); - await xfs.writeJsonPromise(`${path}/packages/workspace-a/package.json`, {name: `workspace-a`}); + await xfs.mkdirpPromise(`${path}/packages/workspace-a` as PortablePath); + await xfs.writeJsonPromise(`${path}/packages/workspace-a/package.json` as PortablePath, {name: `workspace-a`}); - await xfs.mkdirpPromise(`${path}/packages/workspace-b`); - await xfs.writeJsonPromise(`${path}/packages/workspace-b/package.json`, {name: `workspace-b`}); + await xfs.mkdirpPromise(`${path}/packages/workspace-b` as PortablePath); + await xfs.writeJsonPromise(`${path}/packages/workspace-b/package.json` as PortablePath, {name: `workspace-b`}); await run(`install`); @@ -438,7 +434,7 @@ describe(`Plug'n'Play API`, () => { expect(typeof physicalPath).toEqual(`string`); expect(physicalPath).not.toEqual(virtualPath); - expect(xfs.existsSync(physicalPath)).toEqual(true); + expect(xfs.existsSync(physicalPath as PortablePath)).toEqual(true); }), ); }); diff --git a/packages/plugin-pack/sources/index.ts b/packages/plugin-pack/sources/index.ts index 27c3e833ccf8..d6bf8b6f4776 100644 --- a/packages/plugin-pack/sources/index.ts +++ b/packages/plugin-pack/sources/index.ts @@ -30,6 +30,9 @@ const beforeWorkspacePacking = (workspace: Workspace, rawManifest: any) => { if (rawManifest.publishConfig.browser) rawManifest.browser = rawManifest.publishConfig.browser; + if (rawManifest.publishConfig.exports) + rawManifest.exports = rawManifest.publishConfig.exports; + if (rawManifest.publishConfig.bin) { rawManifest.bin = rawManifest.publishConfig.bin; } diff --git a/packages/yarnpkg-pnp/package.json b/packages/yarnpkg-pnp/package.json index 7b6730d709ae..1f502809f85c 100644 --- a/packages/yarnpkg-pnp/package.json +++ b/packages/yarnpkg-pnp/package.json @@ -6,6 +6,7 @@ "dependencies": { "@types/node": "^13.7.0", "@yarnpkg/fslib": "workspace:^2.4.0", + "resolve.exports": "^1.0.2", "tslib": "^1.13.0" }, "devDependencies": { @@ -18,6 +19,7 @@ }, "scripts": { "build:pnp:hook": "webpack-cli --config webpack.config.hook.js", + "update:pnp:hook": "run build:pnp:hook && yarn install", "build:pnp": "webpack-cli --config webpack.config.pkg.js", "postpack": "rm -rf lib", "prepack": "run build:compile packages/yarnpkg-pnp --emitDeclarationOnly && run build:pnp", diff --git a/packages/yarnpkg-pnp/sources/hook.js b/packages/yarnpkg-pnp/sources/hook.js index 4d516ccf70f1..d1a9073c44a7 100644 --- a/packages/yarnpkg-pnp/sources/hook.js +++ b/packages/yarnpkg-pnp/sources/hook.js @@ -2,7 +2,7 @@ let hook; module.exports = () => { if (typeof hook === `undefined`) - hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; }; diff --git a/packages/yarnpkg-pnp/sources/loader/hydrateRuntimeState.ts b/packages/yarnpkg-pnp/sources/loader/hydrateRuntimeState.ts index ce10c81fa2ae..cbf2a84abb8c 100644 --- a/packages/yarnpkg-pnp/sources/loader/hydrateRuntimeState.ts +++ b/packages/yarnpkg-pnp/sources/loader/hydrateRuntimeState.ts @@ -14,7 +14,7 @@ export function hydrateRuntimeState(data: SerializedState, {basePath}: HydrateRu ? new RegExp(data.ignorePatternData) : null; - const packageLocatorsByLocations = new Map(); + const packageLocatorsByLocations = new Map(); const packageLocationLengths = new Set(); const packageRegistry = new Map(data.packageRegistryData.map(([packageName, packageStoreData]) => { @@ -22,21 +22,29 @@ export function hydrateRuntimeState(data: SerializedState, {basePath}: HydrateRu if ((packageName === null) !== (packageReference === null)) throw new Error(`Assertion failed: The name and reference should be null, or neither should`); - if (!packageInformationData.discardFromLookup) { - // @ts-expect-error: TypeScript isn't smart enough to understand the type assertion - const packageLocator: PhysicalPackageLocator = {name: packageName, reference: packageReference}; - packageLocatorsByLocations.set(packageInformationData.packageLocation, packageLocator); + const discardFromLookup = packageInformationData.discardFromLookup ?? false; - packageLocationLengths.add(packageInformationData.packageLocation.length); + // @ts-expect-error: TypeScript isn't smart enough to understand the type assertion + const packageLocator: PhysicalPackageLocator = {name: packageName, reference: packageReference}; + const entry = packageLocatorsByLocations.get(packageInformationData.packageLocation); + if (!entry) { + packageLocatorsByLocations.set(packageInformationData.packageLocation, {locator: packageLocator, discardFromLookup}); + } else { + entry.discardFromLookup = entry.discardFromLookup && discardFromLookup; + if (!discardFromLookup) { + entry.locator = packageLocator; + } } + packageLocationLengths.add(packageInformationData.packageLocation.length); + let resolvedPackageLocation: PortablePath | null = null; return [packageReference, { packageDependencies: new Map(packageInformationData.packageDependencies), packagePeers: new Set(packageInformationData.packagePeers), linkType: packageInformationData.linkType, - discardFromLookup: packageInformationData.discardFromLookup || false, + discardFromLookup, // we only need this for packages that are used by the currently running script // this is a lazy getter because `ppath.join` has some overhead get packageLocation() { diff --git a/packages/yarnpkg-pnp/sources/loader/makeApi.ts b/packages/yarnpkg-pnp/sources/loader/makeApi.ts index 8e480a226fab..abd48535e5d6 100644 --- a/packages/yarnpkg-pnp/sources/loader/makeApi.ts +++ b/packages/yarnpkg-pnp/sources/loader/makeApi.ts @@ -1,11 +1,12 @@ -import {ppath, Filename} from '@yarnpkg/fslib'; -import {FakeFS, NativePath, PortablePath, VirtualFS, npath} from '@yarnpkg/fslib'; -import {Module} from 'module'; -import {inspect} from 'util'; +import {ppath, Filename} from '@yarnpkg/fslib'; +import {FakeFS, NativePath, PortablePath, VirtualFS, npath} from '@yarnpkg/fslib'; +import {Module} from 'module'; +import {resolve as resolveExport} from 'resolve.exports'; +import {inspect} from 'util'; -import {PackageInformation, PackageLocator, PnpApi, RuntimeState, PhysicalPackageLocator, DependencyTarget} from '../types'; +import {PackageInformation, PackageLocator, PnpApi, RuntimeState, PhysicalPackageLocator, DependencyTarget, ResolveToUnqualifiedOptions, ResolveUnqualifiedOptions, ResolveRequestOptions} from '../types'; -import {ErrorCode, makeError, getPathForDisplay} from './internalTools'; +import {ErrorCode, makeError, getPathForDisplay} from './internalTools'; export type MakeApiOptions = { allowDebug?: boolean, @@ -14,18 +15,6 @@ export type MakeApiOptions = { pnpapiResolution: NativePath, }; -export type ResolveToUnqualifiedOptions = { - considerBuiltins?: boolean, -}; - -export type ResolveUnqualifiedOptions = { - extensions?: Array, -}; - -export type ResolveRequestOptions = - ResolveToUnqualifiedOptions & - ResolveUnqualifiedOptions; - export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpApi { const alwaysWarnOnFallback = Number(process.env.PNP_ALWAYS_WARN_ON_FALLBACK) > 0; const debugLevel = Number(process.env.PNP_DEBUG_LEVEL); @@ -43,6 +32,9 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp // Matches if the path must point to a directory (ie ends with /) const isDirRegExp = /\/$/; + // Matches if the path starts with a relative path qualifier (./, ../) + const isRelativeRegexp = /^\.{0,2}\//; + // We only instantiate one of those so that we can use strict-equal comparisons const topLevelLocator = {name: null, reference: null}; @@ -203,9 +195,58 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp } /** - * Implements the node resolution for folder access and extension selection + * Implements the node resolution for the "exports" field + * + * @returns The remapped path or `null` if the package doesn't have a package.json or an "exports" field */ + function applyNodeExportsResolution(unqualifiedPath: PortablePath) { + const locator = findPackageLocator(ppath.join(unqualifiedPath, `internal.js` as Filename), { + resolveIgnored: true, + includeDiscardFromLookup: true, + }); + if (locator === null) { + throw makeError( + ErrorCode.INTERNAL, + `The locator that owns the "${unqualifiedPath}" path can't be found inside the dependency tree (this is probably an internal error)`, + ); + } + + const {packageLocation} = getPackageInformationSafe(locator); + + const manifestPath = ppath.join(packageLocation, Filename.manifest); + if (!opts.fakeFs.existsSync(manifestPath)) + return null; + + const pkgJson = JSON.parse(opts.fakeFs.readFileSync(manifestPath, `utf8`)); + + let subpath = ppath.contains(packageLocation, unqualifiedPath); + if (subpath === null) { + throw makeError( + ErrorCode.INTERNAL, + `unqualifiedPath doesn't contain the packageLocation (this is probably an internal error)`, + ); + } + + if (!isRelativeRegexp.test(subpath)) + subpath = `./${subpath}` as PortablePath; + const resolvedExport = resolveExport(pkgJson, ppath.normalize(subpath), { + browser: false, + require: true, + // TODO: implement support for the --conditions flag + // Waiting on https://github.com/nodejs/node/issues/36935 + conditions: [], + }); + + if (typeof resolvedExport === `string`) + return ppath.join(packageLocation, resolvedExport as PortablePath); + + return null; + } + + /** + * Implements the node resolution for folder access and extension selection + */ function applyNodeExtensionResolution(unqualifiedPath: PortablePath, candidates: Array, {extensions}: {extensions: Array}): PortablePath | null { let stat; @@ -225,7 +266,7 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp let pkgJson; try { - pkgJson = JSON.parse(opts.fakeFs.readFileSync(ppath.join(unqualifiedPath, `package.json` as Filename), `utf8`)); + pkgJson = JSON.parse(opts.fakeFs.readFileSync(ppath.join(unqualifiedPath, Filename.manifest), `utf8`)); } catch (error) {} let nextUnqualifiedPath; @@ -444,8 +485,8 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp * Finds the package locator that owns the specified path. If none is found, returns null instead. */ - function findPackageLocator(location: PortablePath): PhysicalPackageLocator | null { - if (isPathIgnored(location)) + function findPackageLocator(location: PortablePath, {resolveIgnored = false, includeDiscardFromLookup = false}: {resolveIgnored?: boolean, includeDiscardFromLookup?: boolean} = {}): PhysicalPackageLocator | null { + if (isPathIgnored(location) && !resolveIgnored) return null; let relativeLocation = ppath.relative(runtimeState.basePath, location); @@ -463,8 +504,8 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp from += 1; for (let t = from; t < packageLocationLengths.length; ++t) { - const locator = packageLocatorsByLocations.get(relativeLocation.substr(0, packageLocationLengths[t]) as PortablePath); - if (typeof locator === `undefined`) + const entry = packageLocatorsByLocations.get(relativeLocation.substr(0, packageLocationLengths[t]) as PortablePath); + if (typeof entry === `undefined`) continue; // Ensures that the returned locator isn't a blacklisted one. @@ -483,7 +524,7 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp // paths, we're able to print a more helpful error message that points out that a third-party package is doing // something incompatible! - if (locator === null) { + if (entry === null) { const locationForDisplay = getPathForDisplay(location); throw makeError( ErrorCode.BLACKLISTED, @@ -492,7 +533,10 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp ); } - return locator; + if (entry.discardFromLookup && !includeDiscardFromLookup) + continue; + + return entry.locator; } return null; @@ -512,12 +556,10 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp function resolveToUnqualified(request: PortablePath, issuer: PortablePath | null, {considerBuiltins = true}: ResolveToUnqualifiedOptions = {}): PortablePath | null { // The 'pnpapi' request is reserved and will always return the path to the PnP file, from everywhere - if (request === `pnpapi`) return npath.toPortablePath(opts.pnpapiResolution); // Bailout if the request is a native module - if (considerBuiltins && builtinModules.has(request)) return null; @@ -557,7 +599,6 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp // If the request is a relative or absolute path, we just return it normalized const dependencyNameMatch = request.match(pathRegExp); - if (!dependencyNameMatch) { if (ppath.isAbsolute(request)) { unqualifiedPath = ppath.normalize(request); @@ -771,6 +812,19 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp return ppath.normalize(unqualifiedPath); } + function resolveUnqualifiedExport(request: PortablePath, unqualifiedPath: PortablePath) { + // "exports" only apply when requiring a package, not when requiring via an absolute / relative path + if (isStrictRegExp.test(request)) + return unqualifiedPath; + + const unqualifiedExportPath = applyNodeExportsResolution(unqualifiedPath); + if (unqualifiedExportPath) { + return ppath.normalize(unqualifiedExportPath); + } else { + return unqualifiedPath; + } + } + /** * Transforms an unqualified path into a qualified path by using the Node resolution algorithm (which automatically * appends ".js" / ".json", and transforms directory accesses into "index.js"). @@ -802,12 +856,20 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp function resolveRequest(request: PortablePath, issuer: PortablePath | null, {considerBuiltins, extensions}: ResolveRequestOptions = {}): PortablePath | null { const unqualifiedPath = resolveToUnqualified(request, issuer, {considerBuiltins}); - if (unqualifiedPath === null) return null; + const isIssuerIgnored = () => + issuer !== null + ? isPathIgnored(issuer) + : false; + + const remappedPath = (!considerBuiltins || !builtinModules.has(request)) && !isIssuerIgnored() + ? resolveUnqualifiedExport(request, unqualifiedPath) + : unqualifiedPath; + try { - return resolveUnqualified(unqualifiedPath, {extensions}); + return resolveUnqualified(remappedPath, {extensions}); } catch (resolutionError) { if (resolutionError.pnpCode === `QUALIFIED_PATH_RESOLUTION_FAILED`) Object.assign(resolutionError.data, {request: getPathForDisplay(request), issuer: issuer && getPathForDisplay(issuer)}); diff --git a/packages/yarnpkg-pnp/sources/types.ts b/packages/yarnpkg-pnp/sources/types.ts index 65b5bb3ec256..a91742ada233 100644 --- a/packages/yarnpkg-pnp/sources/types.ts +++ b/packages/yarnpkg-pnp/sources/types.ts @@ -56,7 +56,7 @@ export type RuntimeState = { fallbackPool: Map, ignorePattern: RegExp | null, packageLocationLengths: Array, - packageLocatorsByLocations: Map; + packageLocatorsByLocations: Map; packageRegistry: PackageRegistry, dependencyTreeRoots: Array, }; @@ -95,6 +95,18 @@ export type PnpSettings = { dependencyTreeRoots: Array, }; +export type ResolveToUnqualifiedOptions = { + considerBuiltins?: boolean, +}; + +export type ResolveUnqualifiedOptions = { + extensions?: Array, +}; + +export type ResolveRequestOptions = + ResolveToUnqualifiedOptions & + ResolveUnqualifiedOptions; + export type PnpApi = { VERSIONS: {std: number, [key: string]: number}, @@ -105,9 +117,9 @@ export type PnpApi = { getPackageInformation: (locator: PackageLocator) => PackageInformation | null, findPackageLocator: (location: NativePath) => PhysicalPackageLocator | null, - resolveToUnqualified: (request: string, issuer: NativePath | null, opts?: {considerBuiltins?: boolean}) => NativePath | null, - resolveUnqualified: (unqualified: NativePath, opts?: {extensions?: Array}) => NativePath, - resolveRequest: (request: string, issuer: NativePath | null, opts?: {considerBuiltins?: boolean, extensions?: Array}) => NativePath | null, + resolveToUnqualified: (request: string, issuer: NativePath | null, opts?: ResolveToUnqualifiedOptions) => NativePath | null, + resolveUnqualified: (unqualified: NativePath, opts?: ResolveUnqualifiedOptions) => NativePath, + resolveRequest: (request: string, issuer: NativePath | null, opts?: ResolveRequestOptions) => NativePath | null, // Extension methods resolveVirtual?: (p: NativePath) => NativePath | null, diff --git a/yarn.lock b/yarn.lock index 8f6c68566ee7..f3192cef56d7 100644 --- a/yarn.lock +++ b/yarn.lock @@ -6221,6 +6221,7 @@ __metadata: "@yarnpkg/fslib": "workspace:^2.4.0" "@yarnpkg/libzip": "workspace:^2.2.1" "@yarnpkg/monorepo": "workspace:0.0.0" + resolve.exports: ^1.0.2 tslib: ^1.13.0 typescript: 4.1.0-beta webpack: ^5.1.1 @@ -23479,6 +23480,13 @@ fsevents@^1.2.7: languageName: node linkType: hard +"resolve.exports@npm:^1.0.2": + version: 1.0.2 + resolution: "resolve.exports@npm:1.0.2" + checksum: 012a46e3ae41c53762abf5b50ea1b4adf2de617bbea1dbc7bf6e609c1ceaedee7782acbc92d443951d5dd0c3a8fb1090ce73285a9ccc24b530e33b5e09ae196f + languageName: node + linkType: hard + resolve@1.9.0: version: 1.9.0 resolution: "resolve@npm:1.9.0"