diff --git a/.pnp.cjs b/.pnp.cjs index 44e2da5823de..355b800639cf 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -278,7 +278,7 @@ const RAW_RUNTIME_STATE = ["pirates", "npm:4.0.5"],\ ["semver", "npm:7.5.4"],\ ["tslib", "npm:2.6.2"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "linkType": "SOFT"\ }]\ @@ -7515,7 +7515,7 @@ const RAW_RUNTIME_STATE = ["natural-compare-lite", "npm:1.4.0"],\ ["semver", "npm:7.5.4"],\ ["ts-api-utils", "virtual:f34075dd5db6b9bb298a4e70eff93791d17b5803594e174de5fe1a77979605c349ca8f56d9c56291db5f6694dd056cddd1caf2537ecb6b817b48975418795553#npm:1.0.1"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -7581,7 +7581,7 @@ const RAW_RUNTIME_STATE = ["@typescript-eslint/visitor-keys", "npm:6.2.0"],\ ["debug", "virtual:5506c369f7d205cc727e8f2875616dc0244b99710d92b1bad22ac883508e7a91e51874d9b6c2a625bec078bdd53505d75f79e9c1a0dce52df9bea20420686aaf#npm:4.3.4"],\ ["eslint", "npm:8.45.0"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -7665,7 +7665,7 @@ const RAW_RUNTIME_STATE = ["debug", "virtual:5506c369f7d205cc727e8f2875616dc0244b99710d92b1bad22ac883508e7a91e51874d9b6c2a625bec078bdd53505d75f79e9c1a0dce52df9bea20420686aaf#npm:4.3.4"],\ ["eslint", "npm:8.45.0"],\ ["ts-api-utils", "virtual:f34075dd5db6b9bb298a4e70eff93791d17b5803594e174de5fe1a77979605c349ca8f56d9c56291db5f6694dd056cddd1caf2537ecb6b817b48975418795553#npm:1.0.1"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -7705,7 +7705,7 @@ const RAW_RUNTIME_STATE = ["is-glob", "npm:4.0.3"],\ ["semver", "npm:7.5.4"],\ ["ts-api-utils", "virtual:f34075dd5db6b9bb298a4e70eff93791d17b5803594e174de5fe1a77979605c349ca8f56d9c56291db5f6694dd056cddd1caf2537ecb6b817b48975418795553#npm:1.0.1"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/typescript",\ @@ -7999,7 +7999,7 @@ const RAW_RUNTIME_STATE = ]],\ ["semver", "npm:7.5.4"],\ ["tslib", "npm:2.6.2"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "linkType": "SOFT"\ }]\ @@ -9006,7 +9006,7 @@ const RAW_RUNTIME_STATE = ["micromatch", "npm:4.0.5"],\ ["p-limit", "npm:2.2.0"],\ ["tslib", "npm:2.6.2"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "linkType": "SOFT"\ }]\ @@ -9098,7 +9098,7 @@ const RAW_RUNTIME_STATE = ["three", "npm:0.145.0"],\ ["tslib", "npm:2.6.2"],\ ["typedoc", "virtual:efae73f2e9aa11493dde5182b5b7f0894b5c101cb3c916b74523dc0bde92d8579259d43c7f83a5363dbd8939dc3d1e6c45c5965b9191878533d9a2c19b046d70#npm:0.25.8"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"],\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"],\ ["unified", "npm:11.0.4"],\ ["unist-util-visit-parents", "npm:6.0.1"],\ ["usehooks-ts", "virtual:efae73f2e9aa11493dde5182b5b7f0894b5c101cb3c916b74523dc0bde92d8579259d43c7f83a5363dbd8939dc3d1e6c45c5965b9191878533d9a2c19b046d70#npm:2.9.1"],\ @@ -9123,7 +9123,7 @@ const RAW_RUNTIME_STATE = ["eslint", "npm:8.45.0"],\ ["eslint-plugin-arca", "npm:0.16.0"],\ ["eslint-plugin-react", "virtual:4b728ee22ccd3ae66b83e3be6d39acfb5b7a775112cc78b6b4322feb849fcfe6e39510452356cb4477dc6089bee57db31d02bbfb03b9fc8e914effa16a4145be#npm:7.33.0"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -9274,7 +9274,7 @@ const RAW_RUNTIME_STATE = ["pirates", "npm:4.0.5"],\ ["semver", "npm:7.5.4"],\ ["tslib", "npm:2.6.2"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "linkType": "SOFT"\ }]\ @@ -21969,7 +21969,7 @@ const RAW_RUNTIME_STATE = ["react", "npm:18.2.0"],\ ["react-dom", "virtual:efae73f2e9aa11493dde5182b5b7f0894b5c101cb3c916b74523dc0bde92d8579259d43c7f83a5363dbd8939dc3d1e6c45c5965b9191878533d9a2c19b046d70#npm:18.2.0"],\ ["typedoc", "virtual:efae73f2e9aa11493dde5182b5b7f0894b5c101cb3c916b74523dc0bde92d8579259d43c7f83a5363dbd8939dc3d1e6c45c5965b9191878533d9a2c19b046d70#npm:0.25.8"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@docusaurus/core",\ @@ -34531,7 +34531,7 @@ const RAW_RUNTIME_STATE = "packageDependencies": [\ ["ts-api-utils", "virtual:f34075dd5db6b9bb298a4e70eff93791d17b5803594e174de5fe1a77979605c349ca8f56d9c56291db5f6694dd056cddd1caf2537ecb6b817b48975418795553#npm:1.0.1"],\ ["@types/typescript", null],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/typescript",\ @@ -34764,7 +34764,7 @@ const RAW_RUNTIME_STATE = ["marked", "npm:4.3.0"],\ ["minimatch", "npm:9.0.3"],\ ["shiki", "npm:0.14.7"],\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "packagePeers": [\ "@types/typescript",\ @@ -34774,10 +34774,10 @@ const RAW_RUNTIME_STATE = }]\ ]],\ ["typescript", [\ - ["patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c", {\ - "packageLocation": "./.yarn/cache/typescript-patch-c2a63ebc8f-613747bc8c.zip/node_modules/typescript/",\ + ["patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf", {\ + "packageLocation": "./.yarn/cache/typescript-patch-5205e392bf-bba23e7bca.zip/node_modules/typescript/",\ "packageDependencies": [\ - ["typescript", "patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c"]\ + ["typescript", "patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf"]\ ],\ "linkType": "HARD"\ }]\ diff --git a/.yarn/cache/typescript-npm-5.4.1-rc-12b07cd2ef-8f98b4df2a.zip b/.yarn/cache/typescript-npm-5.4.1-rc-12b07cd2ef-8f98b4df2a.zip deleted file mode 100644 index 1b81f065cf97..000000000000 Binary files a/.yarn/cache/typescript-npm-5.4.1-rc-12b07cd2ef-8f98b4df2a.zip and /dev/null differ diff --git a/.yarn/cache/typescript-npm-5.5.0-beta-e39e99a341-94d187972a.zip b/.yarn/cache/typescript-npm-5.5.0-beta-e39e99a341-94d187972a.zip new file mode 100644 index 000000000000..0fb8790a0a60 Binary files /dev/null and b/.yarn/cache/typescript-npm-5.5.0-beta-e39e99a341-94d187972a.zip differ diff --git a/.yarn/cache/typescript-patch-5205e392bf-bba23e7bca.zip b/.yarn/cache/typescript-patch-5205e392bf-bba23e7bca.zip new file mode 100644 index 000000000000..6b5a0ed19047 Binary files /dev/null and b/.yarn/cache/typescript-patch-5205e392bf-bba23e7bca.zip differ diff --git a/.yarn/cache/typescript-patch-c2a63ebc8f-613747bc8c.zip b/.yarn/cache/typescript-patch-c2a63ebc8f-613747bc8c.zip deleted file mode 100644 index 4373c3c93f0c..000000000000 Binary files a/.yarn/cache/typescript-patch-c2a63ebc8f-613747bc8c.zip and /dev/null differ diff --git a/.yarn/sdks/typescript/lib/tsserver.js b/.yarn/sdks/typescript/lib/tsserver.js index bbb1e46501b5..e8acd929c014 100644 --- a/.yarn/sdks/typescript/lib/tsserver.js +++ b/.yarn/sdks/typescript/lib/tsserver.js @@ -9,6 +9,13 @@ const relPnpApiPath = "../../../../.pnp.cjs"; const absPnpApiPath = resolve(__dirname, relPnpApiPath); const absRequire = createRequire(absPnpApiPath); +if (existsSync(absPnpApiPath)) { + if (!process.versions.pnp) { + // Setup the environment to be able to require typescript/lib/tsserver.js + require(absPnpApiPath).setup(); + } +} + const moduleWrapper = tsserver => { if (!process.versions.pnp) { return tsserver; @@ -214,12 +221,7 @@ const moduleWrapper = tsserver => { return tsserver; }; -if (existsSync(absPnpApiPath)) { - if (!process.versions.pnp) { - // Setup the environment to be able to require typescript/lib/tsserver.js - require(absPnpApiPath).setup(); - } -} +moduleWrapper(absRequire(`typescript`)); // Defer to the real typescript/lib/tsserver.js your application uses module.exports = moduleWrapper(absRequire(`typescript/lib/tsserver.js`)); diff --git a/.yarn/sdks/typescript/lib/tsserverlibrary.js b/.yarn/sdks/typescript/lib/tsserverlibrary.js index a68f028fe197..4c3db8f57db6 100644 --- a/.yarn/sdks/typescript/lib/tsserverlibrary.js +++ b/.yarn/sdks/typescript/lib/tsserverlibrary.js @@ -9,6 +9,13 @@ const relPnpApiPath = "../../../../.pnp.cjs"; const absPnpApiPath = resolve(__dirname, relPnpApiPath); const absRequire = createRequire(absPnpApiPath); +if (existsSync(absPnpApiPath)) { + if (!process.versions.pnp) { + // Setup the environment to be able to require typescript/lib/tsserverlibrary.js + require(absPnpApiPath).setup(); + } +} + const moduleWrapper = tsserver => { if (!process.versions.pnp) { return tsserver; @@ -214,12 +221,7 @@ const moduleWrapper = tsserver => { return tsserver; }; -if (existsSync(absPnpApiPath)) { - if (!process.versions.pnp) { - // Setup the environment to be able to require typescript/lib/tsserverlibrary.js - require(absPnpApiPath).setup(); - } -} +moduleWrapper(absRequire(`typescript`)); // Defer to the real typescript/lib/tsserverlibrary.js your application uses module.exports = moduleWrapper(absRequire(`typescript/lib/tsserverlibrary.js`)); diff --git a/.yarn/sdks/typescript/package.json b/.yarn/sdks/typescript/package.json index 572788fe8924..ed7032ba6a63 100644 --- a/.yarn/sdks/typescript/package.json +++ b/.yarn/sdks/typescript/package.json @@ -1,6 +1,6 @@ { "name": "typescript", - "version": "5.4.1-rc-sdk", + "version": "5.5.0-beta-sdk", "main": "./lib/typescript.js", "type": "commonjs", "bin": { diff --git a/.yarn/versions/80caa95b.yml b/.yarn/versions/80caa95b.yml new file mode 100644 index 000000000000..55c5b4c5c575 --- /dev/null +++ b/.yarn/versions/80caa95b.yml @@ -0,0 +1,24 @@ +releases: + "@yarnpkg/cli": patch + "@yarnpkg/plugin-compat": patch + "@yarnpkg/sdks": patch + +declined: + - "@yarnpkg/plugin-constraints" + - "@yarnpkg/plugin-dlx" + - "@yarnpkg/plugin-essentials" + - "@yarnpkg/plugin-init" + - "@yarnpkg/plugin-interactive-tools" + - "@yarnpkg/plugin-nm" + - "@yarnpkg/plugin-npm-cli" + - "@yarnpkg/plugin-pack" + - "@yarnpkg/plugin-patch" + - "@yarnpkg/plugin-pnp" + - "@yarnpkg/plugin-pnpm" + - "@yarnpkg/plugin-stage" + - "@yarnpkg/plugin-typescript" + - "@yarnpkg/plugin-version" + - "@yarnpkg/plugin-workspace-tools" + - "@yarnpkg/builder" + - "@yarnpkg/core" + - "@yarnpkg/doctor" diff --git a/package.json b/package.json index 5d8d3c8702ea..608bc6600177 100644 --- a/package.json +++ b/package.json @@ -27,7 +27,7 @@ "jest": "^29.2.1", "pirates": "^4.0.5", "tslib": "^2.4.0", - "typescript": "5.4.1-rc" + "typescript": "5.5.0-beta" }, "resolutions": { "ink": "patch:ink@npm%3A3.0.8#~/.yarn/patches/ink-npm-3.0.8-3a8005f59f.patch", @@ -81,5 +81,6 @@ "chalk": "^3.0.0", "micromatch": "^4.0.2", "semver": "^7.1.2" - } + }, + "packageManager": "yarn@4.1.1+sha256.f3cc0eda8e5560e529c7147565b30faa43b4e472d90e8634d7134a37c7f59781" } diff --git a/packages/docusaurus/package.json b/packages/docusaurus/package.json index ee8ad2f24e3b..71b9fad74b81 100644 --- a/packages/docusaurus/package.json +++ b/packages/docusaurus/package.json @@ -101,7 +101,7 @@ "fast-glob": "^3.2.2", "mdast-util-mdx-jsx": "^3.0.0", "typedoc": "^0.25.7", - "typescript": "5.4.1-rc", + "typescript": "5.5.0-beta", "unified": "^11.0.4" }, "browserslist": { diff --git a/packages/plugin-compat/extra/typescript/gen-typescript-patch.js b/packages/plugin-compat/extra/typescript/gen-typescript-patch.js index fab3377526cb..96423f5610be 100644 --- a/packages/plugin-compat/extra/typescript/gen-typescript-patch.js +++ b/packages/plugin-compat/extra/typescript/gen-typescript-patch.js @@ -267,7 +267,14 @@ const SLICES = [ from: `786e26825dad9dcc0eff79610bffd8bb121e7e8a`, to: `786e26825dad9dcc0eff79610bffd8bb121e7e8a`, onto: `db6b2a980280a9c87799b9c1edd6d71e92bb255b`, - range: `>=5.4.1-rc`, + range: `>=5.4.1-rc <5.5.0-beta`, + }, + // https://github.com/yarnpkg/TypeScript/tree/merceyz/pnp-5.5-beta + { + from: `f90eb7508e66a3d5066b1d8a06606c6c23f3df43`, + to: `43d2cbd6ac423e35a5a095a509fc90c03f0c22ba`, + onto: `b574864abc989d0f8b15367baea1058819e126ba`, + range: `>=5.5.0-beta`, }, ]; @@ -531,10 +538,10 @@ async function main() { const patch = await run(slice); const versions = await fetchVersions(slice.range); - for (const version of versions) { + await Promise.all(versions.map(async version => { console.log(`Validating ${version}...`); await validate(version, patch); - } + })); patches.push(patch); } diff --git a/packages/plugin-compat/extra/typescript/patch-14d8ce3d823cd5772f690ee6089998f1.diff b/packages/plugin-compat/extra/typescript/patch-14d8ce3d823cd5772f690ee6089998f1.diff index a076eec20c79..958be0281e9d 100644 --- a/packages/plugin-compat/extra/typescript/patch-14d8ce3d823cd5772f690ee6089998f1.diff +++ b/packages/plugin-compat/extra/typescript/patch-14d8ce3d823cd5772f690ee6089998f1.diff @@ -1,6 +1,6 @@ diff --git a/lib/tsc.js b/lib/tsc.js index 49a42a27b..0625b052d 100644 -semver exclusivity >=5.4.1-rc +semver exclusivity >=5.4.1-rc <5.5.0-beta --- a/lib/tsc.js +++ b/lib/tsc.js @@ -5063,6 +5063,9 @@ var sys = (() => { @@ -345,7 +345,7 @@ semver exclusivity >=5.4.1-rc function reloadFileNamesFromConfigFile() { diff --git a/lib/tsserver.js b/lib/tsserver.js index 707a6387a..491cb8fa7 100644 -semver exclusivity >=5.4.1-rc +semver exclusivity >=5.4.1-rc <5.5.0-beta --- a/lib/tsserver.js +++ b/lib/tsserver.js @@ -8611,6 +8611,9 @@ var sys = (() => { @@ -1002,7 +1002,7 @@ semver exclusivity >=5.4.1-rc this.installer.on("message", (m) => this.handleMessage(m)); diff --git a/lib/typescript.d.ts b/lib/typescript.d.ts index a13173346..b0e8856e1 100644 -semver exclusivity >=5.4.1-rc +semver exclusivity >=5.4.1-rc <5.5.0-beta --- a/lib/typescript.d.ts +++ b/lib/typescript.d.ts @@ -9903,6 +9903,8 @@ declare namespace ts { @@ -1016,7 +1016,7 @@ semver exclusivity >=5.4.1-rc function resolveTripleslashReference(moduleName: string, containingFile: string): string; diff --git a/lib/typescript.js b/lib/typescript.js index a75d7ba4b..fd5189269 100644 -semver exclusivity >=5.4.1-rc +semver exclusivity >=5.4.1-rc <5.5.0-beta --- a/lib/typescript.js +++ b/lib/typescript.js @@ -6370,6 +6370,9 @@ ${lanes.join("\n")} @@ -1719,7 +1719,7 @@ semver exclusivity >=5.4.1-rc let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path); diff --git a/lib/typingsInstaller.js b/lib/typingsInstaller.js index 7d305c002..0162dd8ae 100644 -semver exclusivity >=5.4.1-rc +semver exclusivity >=5.4.1-rc <5.5.0-beta --- a/lib/typingsInstaller.js +++ b/lib/typingsInstaller.js @@ -4475,6 +4475,9 @@ var sys = (() => { diff --git a/packages/plugin-compat/extra/typescript/patch-51ab57a4392bdf0fe1e44f78309540a3.diff b/packages/plugin-compat/extra/typescript/patch-51ab57a4392bdf0fe1e44f78309540a3.diff new file mode 100644 index 000000000000..d1ac33c2ca97 --- /dev/null +++ b/packages/plugin-compat/extra/typescript/patch-51ab57a4392bdf0fe1e44f78309540a3.diff @@ -0,0 +1,1053 @@ +diff --git a/lib/tsc.js b/lib/tsc.js +index 06f7f5ec9..4a7e28076 100644 +semver exclusivity >=5.5.0-beta +--- a/lib/tsc.js ++++ b/lib/tsc.js +@@ -5120,6 +5120,9 @@ var sys = (() => { + } + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -38652,6 +38655,48 @@ function getDefaultValueForOption(option) { + } + } + ++// src/compiler/pnpapi.ts ++function getPnpApi(path) { ++ if (typeof process.versions.pnp === "undefined") { ++ return; ++ } ++ const { findPnpApi } = require("module"); ++ if (findPnpApi) { ++ return findPnpApi(`${path}/`); ++ } ++} ++function getPnpApiPath(path) { ++ var _a; ++ return (_a = getPnpApi(path)) == null ? void 0 : _a.resolveRequest( ++ "pnpapi", ++ /*issuer*/ ++ null ++ ); ++} ++ ++// src/compiler/pnp.ts ++function getPnpTypeRoots(currentDirectory) { ++ const pnpApi = getPnpApi(currentDirectory); ++ if (!pnpApi) { ++ return []; ++ } ++ currentDirectory = resolvePath(currentDirectory); ++ const currentPackage = pnpApi.findPackageLocator(`${currentDirectory}/`); ++ if (!currentPackage) { ++ return []; ++ } ++ const { packageDependencies } = pnpApi.getPackageInformation(currentPackage); ++ const typeRoots = []; ++ for (const [name, referencish] of Array.from(packageDependencies.entries())) { ++ if (name.startsWith(`@types/`) && referencish !== null) { ++ const dependencyLocator = pnpApi.getLocator(name, referencish); ++ const { packageLocation } = pnpApi.getPackageInformation(dependencyLocator); ++ typeRoots.push(getDirectoryPath(packageLocation)); ++ } ++ } ++ return typeRoots; ++} ++ + // src/compiler/moduleNameResolver.ts + function trace(host, message, ...args) { + host.trace(formatMessage(message, ...args)); +@@ -38882,7 +38927,7 @@ function getEffectiveTypeRoots(options, host) { + return getDefaultTypeRoots(currentDirectory); + } + } +-function getDefaultTypeRoots(currentDirectory) { ++function getNodeModulesTypeRoots(currentDirectory) { + let typeRoots; + forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => { + const atTypes = combinePaths(directory, nodeModulesAtTypes); +@@ -38895,6 +38940,15 @@ function arePathsEqual(path1, path2, host) { + const useCaseSensitiveFileNames2 = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames2) === 0 /* EqualTo */; + } ++function getDefaultTypeRoots(currentDirectory) { ++ const nmTypes = getNodeModulesTypeRoots(currentDirectory); ++ const pnpTypes = getPnpTypeRoots(currentDirectory); ++ if (nmTypes == null ? void 0 : nmTypes.length) { ++ return [...nmTypes, ...pnpTypes]; ++ } else if (pnpTypes.length) { ++ return pnpTypes; ++ } ++} + function getOriginalAndResolvedFileName(fileName, host, traceEnabled) { + const resolvedFileName = realPath(fileName, host, traceEnabled); + const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host); +@@ -40823,7 +40877,15 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, + return lookup(secondaryExtensions); + } + function lookup(extensions2) { +- return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => { ++ const issuer = normalizeSlashes(directory); ++ if (getPnpApi(issuer)) { ++ const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, issuer, redirectedReference, state); ++ if (resolutionFromCache) { ++ return resolutionFromCache; ++ } ++ return toSearchResult(loadModuleFromImmediateNodeModulesDirectoryPnP(extensions2, moduleName, issuer, state, typesScopeOnly, cache, redirectedReference)); ++ } ++ return forEachAncestorDirectory(issuer, (ancestorDirectory) => { + if (getBaseFileName(ancestorDirectory) !== "node_modules") { + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state); + if (resolutionFromCache) { +@@ -40858,11 +40920,40 @@ function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, dir + return loadModuleFromSpecificNodeModulesDirectory(4 /* Declaration */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference); + } + } ++function loadModuleFromImmediateNodeModulesDirectoryPnP(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { ++ const issuer = normalizeSlashes(directory); ++ if (!typesScopeOnly) { ++ const packageResult = tryLoadModuleUsingPnpResolution(extensions, moduleName, issuer, state, cache, redirectedReference); ++ if (packageResult) { ++ return packageResult; ++ } ++ } ++ if (extensions & 4 /* Declaration */) { ++ return tryLoadModuleUsingPnpResolution(4 /* Declaration */, `@types/${mangleScopedPackageNameWithTrace(moduleName, state)}`, issuer, state, cache, redirectedReference); ++ } ++} + function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) { +- var _a, _b; + const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName)); + const { packageName, rest } = parsePackageName(moduleName); + const packageDirectory = combinePaths(nodeModulesDirectory, packageName); ++ return loadModuleFromSpecificNodeModulesDirectoryImpl(extensions, nodeModulesDirectoryExists, state, cache, redirectedReference, candidate, rest, packageDirectory); ++} ++function loadModuleFromPnpResolution(extensions, packageDirectory, rest, state, cache, redirectedReference) { ++ const candidate = normalizePath(combinePaths(packageDirectory, rest)); ++ return loadModuleFromSpecificNodeModulesDirectoryImpl( ++ extensions, ++ /*nodeModulesDirectoryExists*/ ++ true, ++ state, ++ cache, ++ redirectedReference, ++ candidate, ++ rest, ++ packageDirectory ++ ); ++} ++function loadModuleFromSpecificNodeModulesDirectoryImpl(extensions, nodeModulesDirectoryExists, state, cache, redirectedReference, candidate, rest, packageDirectory) { ++ var _a, _b; + let rootPackageInfo; + let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state); + if (rest !== "" && packageInfo && (!(state.features & 8 /* Exports */) || !hasProperty(((_a = rootPackageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state)) == null ? void 0 : _a.contents.packageJsonContent) ?? emptyArray, "exports"))) { +@@ -41167,6 +41258,18 @@ function traceIfEnabled(state, diagnostic, ...args) { + function useCaseSensitiveFileNames(state) { + return !state.host.useCaseSensitiveFileNames ? true : typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : state.host.useCaseSensitiveFileNames(); + } ++function loadPnpPackageResolution(packageName, containingDirectory) { ++ try { ++ const resolution = getPnpApi(containingDirectory).resolveToUnqualified(packageName, `${containingDirectory}/`, { considerBuiltins: false }); ++ return normalizeSlashes(resolution).replace(/\/$/, ""); ++ } catch { ++ } ++} ++function tryLoadModuleUsingPnpResolution(extensions, moduleName, containingDirectory, state, cache, redirectedReference) { ++ const { packageName, rest } = parsePackageName(moduleName); ++ const packageResolution = loadPnpPackageResolution(packageName, containingDirectory); ++ return packageResolution ? loadModuleFromPnpResolution(extensions, packageResolution, rest, state, cache, redirectedReference) : void 0; ++} + + // src/compiler/binder.ts + function getModuleInstanceState(node, visited) { +@@ -44615,7 +44718,15 @@ function getAllModulePathsWorker(info, importedFileName, host, compilerOptions, + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(info.importingSourceFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: info.getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -44914,7 +45025,41 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + if (!host.fileExists || !host.readFile) { + return void 0; + } +- const parts = getNodeModulePathParts(path); ++ let parts = getNodeModulePathParts(path); ++ let pnpPackageName; ++ const pnpApi = getPnpApi(path); ++ if (pnpApi) { ++ const fromLocator = pnpApi.findPackageLocator(importingSourceFile.fileName); ++ const toLocator = pnpApi.findPackageLocator(path); ++ if (fromLocator === toLocator) { ++ return void 0; ++ } ++ if (fromLocator && toLocator) { ++ const fromInfo = pnpApi.getPackageInformation(fromLocator); ++ if (toLocator.reference === fromInfo.packageDependencies.get(toLocator.name)) { ++ pnpPackageName = toLocator.name; ++ } else { ++ for (const [name, reference] of fromInfo.packageDependencies) { ++ if (Array.isArray(reference)) { ++ if (reference[0] === toLocator.name && reference[1] === toLocator.reference) { ++ pnpPackageName = name; ++ break; ++ } ++ } ++ } ++ } ++ if (!parts) { ++ const toInfo = pnpApi.getPackageInformation(toLocator); ++ parts = { ++ topLevelNodeModulesIndex: void 0, ++ topLevelPackageNameIndex: void 0, ++ // The last character from packageLocation is the trailing "/", we want to point to it ++ packageRootIndex: toInfo.packageLocation.length - 1, ++ fileNameIndex: path.lastIndexOf(`/`) ++ }; ++ } ++ } ++ } + if (!parts) { + return void 0; + } +@@ -44952,14 +45097,16 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + if (isRedirect && !isPackageRootPath) { + return void 0; + } +- const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); +- const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); +- if (!(startsWith(canonicalSourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { +- return void 0; ++ if (typeof process.versions.pnp === "undefined") { ++ const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); ++ const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); ++ if (!(startsWith(canonicalSourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { ++ return void 0; ++ } + } +- const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); +- const packageName = getPackageNameFromTypesPackageName(nodeModulesDirectoryName); +- return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageName === nodeModulesDirectoryName ? void 0 : packageName; ++ const nodeModulesDirectoryName = typeof pnpPackageName !== "undefined" ? pnpPackageName + moduleSpecifier.substring(parts.packageRootIndex) : moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); ++ const packageNameFromPath = getPackageNameFromTypesPackageName(nodeModulesDirectoryName); ++ return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageNameFromPath === nodeModulesDirectoryName ? void 0 : packageNameFromPath; + function tryDirectoryWithPackageJson(packageRootIndex) { + var _a, _b; + const packageRootPath = path.substring(0, packageRootIndex); +@@ -44972,9 +45119,9 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + const importMode = overrideMode || getDefaultResolutionModeForFile(importingSourceFile, host, options); + if (getResolvePackageJsonExports(options)) { + const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1); +- const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2); ++ const packageName = getPackageNameFromTypesPackageName(pnpPackageName ? pnpPackageName : nodeModulesDirectoryName2); + const conditions = getConditions(options, importMode); +- const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + return { ...fromExports, verbatimFromExports: true }; + } +@@ -125700,6 +125847,11 @@ function createWatchProgram(host) { + if (configFileName) { + configFileWatcher = watchFile2(configFileName, scheduleProgramReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile); + } ++ let pnpFileWatcher; ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ pnpFileWatcher = watchFile2(pnpApiPath, scheduleResolutionReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile); ++ } + const compilerHost = createCompilerHostFromProgramHost(host, () => compilerOptions, directoryStructureHost); + setGetSourceFileAsHashVersioned(compilerHost); + const getNewSourceFile = compilerHost.getSourceFile; +@@ -125763,6 +125915,10 @@ function createWatchProgram(host) { + configFileWatcher.close(); + configFileWatcher = void 0; + } ++ if (pnpFileWatcher) { ++ pnpFileWatcher.close(); ++ pnpFileWatcher = void 0; ++ } + extendedConfigCache == null ? void 0 : extendedConfigCache.clear(); + extendedConfigCache = void 0; + if (sharedExtendedConfigFileWatchers) { +@@ -125798,7 +125954,7 @@ function createWatchProgram(host) { + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } +- function synchronizeProgram() { ++ function synchronizeProgram(forceAllFilesAsInvalidated = false) { + writeLog(`Synchronizing program`); + Debug.assert(compilerOptions); + Debug.assert(rootFileNames); +@@ -125810,7 +125966,7 @@ function createWatchProgram(host) { + resolutionCache.onChangesAffectModuleResolution(); + } + } +- const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidLibResolutions); ++ const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions, customHasInvalidLibResolutions); + const { + originalReadFile, + originalFileExists, +@@ -126022,13 +126178,19 @@ function createWatchProgram(host) { + updateLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ updateLevel = 3 /* Resolutions */; ++ scheduleProgramUpdate(); ++ } + function updateProgramWithWatchStatus() { + timerToUpdateProgram = void 0; + reportFileChangeDetectedOnCreateProgram = true; + updateProgram(); + } + function updateProgram() { +- var _a, _b, _c, _d; ++ var _a, _b, _c, _d, _e; + switch (updateLevel) { + case 1 /* RootNamesAndUpdate */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -126038,12 +126200,19 @@ function createWatchProgram(host) { + (_b = perfLogger) == null ? void 0 : _b.logStartUpdateProgram("FullConfigReload"); + reloadConfigFile(); + break; ++ case 3 /* Resolutions */: ++ (_c = perfLogger) == null ? void 0 : _c.logStartUpdateProgram("SynchronizeProgramWithResolutions"); ++ synchronizeProgram( ++ /*forceAllFilesAsInvalidated*/ ++ true ++ ); ++ break; + default: +- (_c = perfLogger) == null ? void 0 : _c.logStartUpdateProgram("SynchronizeProgram"); ++ (_d = perfLogger) == null ? void 0 : _d.logStartUpdateProgram("SynchronizeProgram"); + synchronizeProgram(); + break; + } +- (_d = perfLogger) == null ? void 0 : _d.logStopUpdateProgram("Done"); ++ (_e = perfLogger) == null ? void 0 : _e.logStopUpdateProgram("Done"); + return getCurrentBuilderProgram(); + } + function reloadFileNamesFromConfigFile() { +diff --git a/lib/tsserver.js b/lib/tsserver.js +index 50cc6659c..9cefc330a 100644 +semver exclusivity >=5.5.0-beta +--- a/lib/tsserver.js ++++ b/lib/tsserver.js +@@ -33,6 +33,25 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau + var typescript_exports = {}; + __reExport(typescript_exports, require("./typescript.js")); + ++// src/compiler/pnpapi.ts ++function getPnpApi(path) { ++ if (typeof process.versions.pnp === "undefined") { ++ return; ++ } ++ const { findPnpApi } = require("module"); ++ if (findPnpApi) { ++ return findPnpApi(`${path}/`); ++ } ++} ++function getPnpApiPath(path) { ++ var _a; ++ return (_a = getPnpApi(path)) == null ? void 0 : _a.resolveRequest( ++ "pnpapi", ++ /*issuer*/ ++ null ++ ); ++} ++ + // src/tsserver/common.ts + function getLogLevel(level) { + if (level) { +@@ -240,6 +259,10 @@ function initializeNodeSystem() { + } + try { + const args = [(0, typescript_exports.combinePaths)(libDirectory, "watchGuard.js"), path]; ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ args.unshift("-r", pnpApiPath); ++ } + if (logger.hasLevel(typescript_exports.server.LogLevel.verbose)) { + logger.info(`Starting ${process.execPath} with args:${typescript_exports.server.stringifyIndented(args)}`); + } +@@ -422,6 +445,10 @@ function startNodeSession(options, logger, cancellationToken) { + break; + } + } ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ execArgv.unshift("-r", pnpApiPath); ++ } + const typingsInstaller = (0, typescript_exports.combinePaths)((0, typescript_exports.getDirectoryPath)(typescript_exports.sys.getExecutingFilePath()), "typingsInstaller.js"); + this.installer = childProcess.fork(typingsInstaller, args, { execArgv }); + this.installer.on("message", (m) => this.handleMessage(m)); +diff --git a/lib/typescript.d.ts b/lib/typescript.d.ts +index f4c59a844..631850d94 100644 +semver exclusivity >=5.5.0-beta +--- a/lib/typescript.d.ts ++++ b/lib/typescript.d.ts +@@ -9339,6 +9339,8 @@ declare namespace ts { + * - Updating the program + */ + Full = 2, ++ /** Reload the resolutions */ ++ Resolutions = 3, + } + function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string | undefined; + function resolveTripleslashReference(moduleName: string, containingFile: string): string; +diff --git a/lib/typescript.js b/lib/typescript.js +index 6b52dd675..22cf43d26 100644 +semver exclusivity >=5.5.0-beta +--- a/lib/typescript.js ++++ b/lib/typescript.js +@@ -8708,6 +8708,9 @@ var sys = (() => { + } + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -43194,6 +43197,69 @@ function getDefaultValueForOption(option) { + } + } + ++// src/compiler/pnpapi.ts ++function getPnpApi(path) { ++ if (typeof process.versions.pnp === "undefined") { ++ return; ++ } ++ const { findPnpApi } = require("module"); ++ if (findPnpApi) { ++ return findPnpApi(`${path}/`); ++ } ++} ++function getPnpApiPath(path) { ++ var _a; ++ return (_a = getPnpApi(path)) == null ? void 0 : _a.resolveRequest( ++ "pnpapi", ++ /*issuer*/ ++ null ++ ); ++} ++ ++// src/compiler/pnp.ts ++function getPnpTypeRoots(currentDirectory) { ++ const pnpApi = getPnpApi(currentDirectory); ++ if (!pnpApi) { ++ return []; ++ } ++ currentDirectory = resolvePath(currentDirectory); ++ const currentPackage = pnpApi.findPackageLocator(`${currentDirectory}/`); ++ if (!currentPackage) { ++ return []; ++ } ++ const { packageDependencies } = pnpApi.getPackageInformation(currentPackage); ++ const typeRoots = []; ++ for (const [name, referencish] of Array.from(packageDependencies.entries())) { ++ if (name.startsWith(`@types/`) && referencish !== null) { ++ const dependencyLocator = pnpApi.getLocator(name, referencish); ++ const { packageLocation } = pnpApi.getPackageInformation(dependencyLocator); ++ typeRoots.push(getDirectoryPath(packageLocation)); ++ } ++ } ++ return typeRoots; ++} ++function isImportablePathPnp(fromPath, toPath3) { ++ const pnpApi = getPnpApi(fromPath); ++ const fromLocator = pnpApi.findPackageLocator(fromPath); ++ const toLocator = pnpApi.findPackageLocator(toPath3); ++ if (toLocator === null) { ++ return false; ++ } ++ const fromInfo = pnpApi.getPackageInformation(fromLocator); ++ const toReference = fromInfo.packageDependencies.get(toLocator.name); ++ if (toReference) { ++ return toReference === toLocator.reference; ++ } ++ for (const reference of fromInfo.packageDependencies.values()) { ++ if (Array.isArray(reference)) { ++ if (reference[0] === toLocator.name && reference[1] === toLocator.reference) { ++ return true; ++ } ++ } ++ } ++ return false; ++} ++ + // src/compiler/moduleNameResolver.ts + function trace(host, message, ...args) { + host.trace(formatMessage(message, ...args)); +@@ -43436,7 +43502,7 @@ function getEffectiveTypeRoots(options, host) { + return getDefaultTypeRoots(currentDirectory); + } + } +-function getDefaultTypeRoots(currentDirectory) { ++function getNodeModulesTypeRoots(currentDirectory) { + let typeRoots; + forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => { + const atTypes = combinePaths(directory, nodeModulesAtTypes); +@@ -43449,6 +43515,15 @@ function arePathsEqual(path1, path2, host) { + const useCaseSensitiveFileNames2 = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames2) === 0 /* EqualTo */; + } ++function getDefaultTypeRoots(currentDirectory) { ++ const nmTypes = getNodeModulesTypeRoots(currentDirectory); ++ const pnpTypes = getPnpTypeRoots(currentDirectory); ++ if (nmTypes == null ? void 0 : nmTypes.length) { ++ return [...nmTypes, ...pnpTypes]; ++ } else if (pnpTypes.length) { ++ return pnpTypes; ++ } ++} + function getOriginalAndResolvedFileName(fileName, host, traceEnabled) { + const resolvedFileName = realPath(fileName, host, traceEnabled); + const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host); +@@ -43701,6 +43776,21 @@ function getConditions(options, resolutionMode) { + } + function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) { + const moduleResolutionState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options); ++ const pnpapi = getPnpApi(containingDirectory); ++ if (pnpapi) { ++ try { ++ const resolution = pnpapi.resolveToUnqualified(packageName, `${containingDirectory}/`, { considerBuiltins: false }); ++ const candidate = normalizeSlashes(resolution).replace(/\/$/, ""); ++ return getPackageJsonInfo( ++ candidate, ++ /*onlyRecordFailures*/ ++ false, ++ moduleResolutionState ++ ); ++ } catch { ++ return; ++ } ++ } + return forEachAncestorDirectory(containingDirectory, (ancestorDirectory) => { + if (getBaseFileName(ancestorDirectory) !== "node_modules") { + const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules"); +@@ -45529,7 +45619,15 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, + return lookup(secondaryExtensions); + } + function lookup(extensions2) { +- return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => { ++ const issuer = normalizeSlashes(directory); ++ if (getPnpApi(issuer)) { ++ const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, issuer, redirectedReference, state); ++ if (resolutionFromCache) { ++ return resolutionFromCache; ++ } ++ return toSearchResult(loadModuleFromImmediateNodeModulesDirectoryPnP(extensions2, moduleName, issuer, state, typesScopeOnly, cache, redirectedReference)); ++ } ++ return forEachAncestorDirectory(issuer, (ancestorDirectory) => { + if (getBaseFileName(ancestorDirectory) !== "node_modules") { + const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state); + if (resolutionFromCache) { +@@ -45564,11 +45662,40 @@ function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, dir + return loadModuleFromSpecificNodeModulesDirectory(4 /* Declaration */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference); + } + } ++function loadModuleFromImmediateNodeModulesDirectoryPnP(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { ++ const issuer = normalizeSlashes(directory); ++ if (!typesScopeOnly) { ++ const packageResult = tryLoadModuleUsingPnpResolution(extensions, moduleName, issuer, state, cache, redirectedReference); ++ if (packageResult) { ++ return packageResult; ++ } ++ } ++ if (extensions & 4 /* Declaration */) { ++ return tryLoadModuleUsingPnpResolution(4 /* Declaration */, `@types/${mangleScopedPackageNameWithTrace(moduleName, state)}`, issuer, state, cache, redirectedReference); ++ } ++} + function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) { +- var _a, _b; + const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName)); + const { packageName, rest } = parsePackageName(moduleName); + const packageDirectory = combinePaths(nodeModulesDirectory, packageName); ++ return loadModuleFromSpecificNodeModulesDirectoryImpl(extensions, nodeModulesDirectoryExists, state, cache, redirectedReference, candidate, rest, packageDirectory); ++} ++function loadModuleFromPnpResolution(extensions, packageDirectory, rest, state, cache, redirectedReference) { ++ const candidate = normalizePath(combinePaths(packageDirectory, rest)); ++ return loadModuleFromSpecificNodeModulesDirectoryImpl( ++ extensions, ++ /*nodeModulesDirectoryExists*/ ++ true, ++ state, ++ cache, ++ redirectedReference, ++ candidate, ++ rest, ++ packageDirectory ++ ); ++} ++function loadModuleFromSpecificNodeModulesDirectoryImpl(extensions, nodeModulesDirectoryExists, state, cache, redirectedReference, candidate, rest, packageDirectory) { ++ var _a, _b; + let rootPackageInfo; + let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state); + if (rest !== "" && packageInfo && (!(state.features & 8 /* Exports */) || !hasProperty(((_a = rootPackageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state)) == null ? void 0 : _a.contents.packageJsonContent) ?? emptyArray, "exports"))) { +@@ -45873,6 +46000,18 @@ function traceIfEnabled(state, diagnostic, ...args) { + function useCaseSensitiveFileNames(state) { + return !state.host.useCaseSensitiveFileNames ? true : typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : state.host.useCaseSensitiveFileNames(); + } ++function loadPnpPackageResolution(packageName, containingDirectory) { ++ try { ++ const resolution = getPnpApi(containingDirectory).resolveToUnqualified(packageName, `${containingDirectory}/`, { considerBuiltins: false }); ++ return normalizeSlashes(resolution).replace(/\/$/, ""); ++ } catch { ++ } ++} ++function tryLoadModuleUsingPnpResolution(extensions, moduleName, containingDirectory, state, cache, redirectedReference) { ++ const { packageName, rest } = parsePackageName(moduleName); ++ const packageResolution = loadPnpPackageResolution(packageName, containingDirectory); ++ return packageResolution ? loadModuleFromPnpResolution(extensions, packageResolution, rest, state, cache, redirectedReference) : void 0; ++} + + // src/compiler/binder.ts + var ModuleInstanceState = /* @__PURE__ */ ((ModuleInstanceState2) => { +@@ -49440,7 +49579,15 @@ function getAllModulePathsWorker(info, importedFileName, host, compilerOptions, + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(info.importingSourceFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: info.getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -49739,7 +49886,41 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + if (!host.fileExists || !host.readFile) { + return void 0; + } +- const parts = getNodeModulePathParts(path); ++ let parts = getNodeModulePathParts(path); ++ let pnpPackageName; ++ const pnpApi = getPnpApi(path); ++ if (pnpApi) { ++ const fromLocator = pnpApi.findPackageLocator(importingSourceFile.fileName); ++ const toLocator = pnpApi.findPackageLocator(path); ++ if (fromLocator === toLocator) { ++ return void 0; ++ } ++ if (fromLocator && toLocator) { ++ const fromInfo = pnpApi.getPackageInformation(fromLocator); ++ if (toLocator.reference === fromInfo.packageDependencies.get(toLocator.name)) { ++ pnpPackageName = toLocator.name; ++ } else { ++ for (const [name, reference] of fromInfo.packageDependencies) { ++ if (Array.isArray(reference)) { ++ if (reference[0] === toLocator.name && reference[1] === toLocator.reference) { ++ pnpPackageName = name; ++ break; ++ } ++ } ++ } ++ } ++ if (!parts) { ++ const toInfo = pnpApi.getPackageInformation(toLocator); ++ parts = { ++ topLevelNodeModulesIndex: void 0, ++ topLevelPackageNameIndex: void 0, ++ // The last character from packageLocation is the trailing "/", we want to point to it ++ packageRootIndex: toInfo.packageLocation.length - 1, ++ fileNameIndex: path.lastIndexOf(`/`) ++ }; ++ } ++ } ++ } + if (!parts) { + return void 0; + } +@@ -49777,14 +49958,16 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + if (isRedirect && !isPackageRootPath) { + return void 0; + } +- const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); +- const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); +- if (!(startsWith(canonicalSourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { +- return void 0; ++ if (typeof process.versions.pnp === "undefined") { ++ const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); ++ const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); ++ if (!(startsWith(canonicalSourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { ++ return void 0; ++ } + } +- const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); +- const packageName = getPackageNameFromTypesPackageName(nodeModulesDirectoryName); +- return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageName === nodeModulesDirectoryName ? void 0 : packageName; ++ const nodeModulesDirectoryName = typeof pnpPackageName !== "undefined" ? pnpPackageName + moduleSpecifier.substring(parts.packageRootIndex) : moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); ++ const packageNameFromPath = getPackageNameFromTypesPackageName(nodeModulesDirectoryName); ++ return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageNameFromPath === nodeModulesDirectoryName ? void 0 : packageNameFromPath; + function tryDirectoryWithPackageJson(packageRootIndex) { + var _a, _b; + const packageRootPath = path.substring(0, packageRootIndex); +@@ -49797,9 +49980,9 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + const importMode = overrideMode || getDefaultResolutionModeForFile(importingSourceFile, host, options); + if (getResolvePackageJsonExports(options)) { + const nodeModulesDirectoryName2 = packageRootPath.substring(parts.topLevelPackageNameIndex + 1); +- const packageName2 = getPackageNameFromTypesPackageName(nodeModulesDirectoryName2); ++ const packageName = getPackageNameFromTypesPackageName(pnpPackageName ? pnpPackageName : nodeModulesDirectoryName2); + const conditions = getConditions(options, importMode); +- const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = (packageJsonContent == null ? void 0 : packageJsonContent.exports) ? tryGetModuleNameFromExports(options, host, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + return { ...fromExports, verbatimFromExports: true }; + } +@@ -122821,6 +123004,7 @@ var ProgramUpdateLevel = /* @__PURE__ */ ((ProgramUpdateLevel2) => { + ProgramUpdateLevel2[ProgramUpdateLevel2["Update"] = 0] = "Update"; + ProgramUpdateLevel2[ProgramUpdateLevel2["RootNamesAndUpdate"] = 1] = "RootNamesAndUpdate"; + ProgramUpdateLevel2[ProgramUpdateLevel2["Full"] = 2] = "Full"; ++ ProgramUpdateLevel2[ProgramUpdateLevel2["Resolutions"] = 3] = "Resolutions"; + return ProgramUpdateLevel2; + })(ProgramUpdateLevel || {}); + function updateSharedExtendedConfigFileWatcher(projectPath, options, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath3) { +@@ -130835,6 +131019,11 @@ function createWatchProgram(host) { + if (configFileName) { + configFileWatcher = watchFile2(configFileName, scheduleProgramReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile); + } ++ let pnpFileWatcher; ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ pnpFileWatcher = watchFile2(pnpApiPath, scheduleResolutionReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile); ++ } + const compilerHost = createCompilerHostFromProgramHost(host, () => compilerOptions, directoryStructureHost); + setGetSourceFileAsHashVersioned(compilerHost); + const getNewSourceFile = compilerHost.getSourceFile; +@@ -130898,6 +131087,10 @@ function createWatchProgram(host) { + configFileWatcher.close(); + configFileWatcher = void 0; + } ++ if (pnpFileWatcher) { ++ pnpFileWatcher.close(); ++ pnpFileWatcher = void 0; ++ } + extendedConfigCache == null ? void 0 : extendedConfigCache.clear(); + extendedConfigCache = void 0; + if (sharedExtendedConfigFileWatchers) { +@@ -130933,7 +131126,7 @@ function createWatchProgram(host) { + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } +- function synchronizeProgram() { ++ function synchronizeProgram(forceAllFilesAsInvalidated = false) { + writeLog(`Synchronizing program`); + Debug.assert(compilerOptions); + Debug.assert(rootFileNames); +@@ -130945,7 +131138,7 @@ function createWatchProgram(host) { + resolutionCache.onChangesAffectModuleResolution(); + } + } +- const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidLibResolutions); ++ const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions, customHasInvalidLibResolutions); + const { + originalReadFile, + originalFileExists, +@@ -131157,13 +131350,19 @@ function createWatchProgram(host) { + updateLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ updateLevel = 3 /* Resolutions */; ++ scheduleProgramUpdate(); ++ } + function updateProgramWithWatchStatus() { + timerToUpdateProgram = void 0; + reportFileChangeDetectedOnCreateProgram = true; + updateProgram(); + } + function updateProgram() { +- var _a, _b, _c, _d; ++ var _a, _b, _c, _d, _e; + switch (updateLevel) { + case 1 /* RootNamesAndUpdate */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -131173,12 +131372,19 @@ function createWatchProgram(host) { + (_b = perfLogger) == null ? void 0 : _b.logStartUpdateProgram("FullConfigReload"); + reloadConfigFile(); + break; ++ case 3 /* Resolutions */: ++ (_c = perfLogger) == null ? void 0 : _c.logStartUpdateProgram("SynchronizeProgramWithResolutions"); ++ synchronizeProgram( ++ /*forceAllFilesAsInvalidated*/ ++ true ++ ); ++ break; + default: +- (_c = perfLogger) == null ? void 0 : _c.logStartUpdateProgram("SynchronizeProgram"); ++ (_d = perfLogger) == null ? void 0 : _d.logStartUpdateProgram("SynchronizeProgram"); + synchronizeProgram(); + break; + } +- (_d = perfLogger) == null ? void 0 : _d.logStopUpdateProgram("Done"); ++ (_e = perfLogger) == null ? void 0 : _e.logStopUpdateProgram("Done"); + return getCurrentBuilderProgram(); + } + function reloadFileNamesFromConfigFile() { +@@ -138135,7 +138341,14 @@ function createPackageJsonImportFilter(fromFile, preferences, host) { + return false; + } + function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) { +- if (!importedFileName.includes("node_modules")) { ++ const pnpapi = getPnpApi(importedFileName); ++ if (pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(fromFile.fileName); ++ const toLocator = pnpapi.findPackageLocator(importedFileName); ++ if (!(fromLocator && toLocator)) { ++ return void 0; ++ } ++ } else if (!importedFileName.includes("node_modules")) { + return void 0; + } + const specifier = ts_moduleSpecifiers_exports.getNodeModulesPackageName( +@@ -138693,6 +138906,9 @@ function isImportableFile(program, from, to, preferences, packageJsonFilter, mod + return hasImportablePath; + } + function isImportablePath(fromPath, toPath3, getCanonicalFileName, globalCachePath) { ++ if (getPnpApi(fromPath)) { ++ return isImportablePathPnp(fromPath, toPath3); ++ } + const toNodeModules = forEachAncestorDirectory(toPath3, (ancestor) => getBaseFileName(ancestor) === "node_modules" ? ancestor : void 0); + const toNodeModulesParent = toNodeModules && getDirectoryPath(getCanonicalFileName(toNodeModules)); + return toNodeModulesParent === void 0 || startsWith(getCanonicalFileName(fromPath), toNodeModulesParent) || !!globalCachePath && startsWith(getCanonicalFileName(globalCachePath), toNodeModulesParent); +@@ -166731,7 +166947,34 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p + ); + } + }; +- if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) { ++ const checkExports = (packageFile, packageDirectory, fragmentSubpath) => { ++ const packageJson = readJson(packageFile, host); ++ const exports2 = packageJson.exports; ++ if (exports2) { ++ if (typeof exports2 !== "object" || exports2 === null) { ++ return true; ++ } ++ const keys = getOwnKeys(exports2); ++ const conditions = getConditions(compilerOptions, mode); ++ addCompletionEntriesFromPathsOrExports( ++ result, ++ /*isExports*/ ++ true, ++ fragmentSubpath, ++ packageDirectory, ++ extensionOptions, ++ program, ++ host, ++ keys, ++ (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports2[key], conditions)), ++ comparePatternKeys ++ ); ++ return true; ++ } ++ return false; ++ }; ++ const shouldCheckExports = fragmentDirectory && getResolvePackageJsonExports(compilerOptions); ++ if (shouldCheckExports) { + const nodeModulesDirectoryLookup = ancestorLookup; + ancestorLookup = (ancestor) => { + const components = getPathComponents(fragment); +@@ -166750,35 +166993,53 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, p + const packageDirectory = combinePaths(ancestor, "node_modules", packagePath); + const packageFile = combinePaths(packageDirectory, "package.json"); + if (tryFileExists(host, packageFile)) { +- const packageJson = readJson(packageFile, host); +- const exports2 = packageJson.exports; +- if (exports2) { +- if (typeof exports2 !== "object" || exports2 === null) { +- return; ++ const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); ++ if (checkExports(packageFile, packageDirectory, fragmentSubpath)) { ++ return; ++ } ++ } ++ return nodeModulesDirectoryLookup(ancestor); ++ }; ++ } ++ const pnpApi = getPnpApi(scriptPath); ++ if (pnpApi) { ++ const pathRegExp = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:@[^/]+\/)?[^/]+)\/*(.*|)$/; ++ const dependencyNameMatch = fragment.match(pathRegExp); ++ if (dependencyNameMatch) { ++ const [, dependencyName, subPath] = dependencyNameMatch; ++ let unqualified; ++ try { ++ unqualified = pnpApi.resolveToUnqualified(dependencyName, scriptPath, { considerBuiltins: false }); ++ } catch { ++ } ++ if (unqualified) { ++ const packageDirectory = normalizePath(unqualified); ++ let shouldGetCompletions = true; ++ if (shouldCheckExports) { ++ const packageFile = combinePaths(packageDirectory, "package.json"); ++ if (tryFileExists(host, packageFile) && checkExports(packageFile, packageDirectory, subPath)) { ++ shouldGetCompletions = false; + } +- const keys = getOwnKeys(exports2); +- const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); +- const conditions = getConditions(compilerOptions, mode); +- addCompletionEntriesFromPathsOrExports( +- result, +- /*isExports*/ +- true, +- fragmentSubpath, ++ } ++ if (shouldGetCompletions) { ++ getCompletionEntriesForDirectoryFragment( ++ subPath, + packageDirectory, + extensionOptions, + program, + host, +- keys, +- (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports2[key], conditions)), +- comparePatternKeys ++ /*moduleSpecifierIsRelative*/ ++ false, ++ /*exclude*/ ++ void 0, ++ result + ); +- return; + } + } +- return nodeModulesDirectoryLookup(ancestor); +- }; ++ } ++ } else { ++ forEachAncestorDirectory(scriptPath, ancestorLookup); + } +- forEachAncestorDirectory(scriptPath, ancestorLookup); + } + } + return arrayFrom(result.values()); +@@ -166912,9 +167173,15 @@ function getCompletionEntriesFromTypings(host, program, scriptPath, fragmentDire + for (const root of typeRoots) { + getCompletionEntriesFromDirectories(root); + } +- for (const packageJson of findPackageJsons(scriptPath, host)) { +- const typesDir = combinePaths(getDirectoryPath(packageJson), "node_modules/@types"); +- getCompletionEntriesFromDirectories(typesDir); ++ if (getPnpApi(scriptPath)) { ++ for (const root of getPnpTypeRoots(scriptPath)) { ++ getCompletionEntriesFromDirectories(root); ++ } ++ } else { ++ for (const packageJson of findPackageJsons(scriptPath, host)) { ++ const typesDir = combinePaths(getDirectoryPath(packageJson), "node_modules/@types"); ++ getCompletionEntriesFromDirectories(typesDir); ++ } + } + return result; + function getCompletionEntriesFromDirectories(directory) { +@@ -184102,6 +184369,29 @@ var ConfiguredProject2 = class extends Project3 { + return this.projectReferences; + } + updateReferences(refs) { ++ if (typeof process.versions.pnp !== `undefined`) { ++ const basePath = this.getCurrentDirectory(); ++ const getPnpPath = (path) => { ++ try { ++ const pnpApi = getPnpApi(`${path}/`); ++ if (!pnpApi) { ++ return path; ++ } ++ const targetLocator = pnpApi.findPackageLocator(`${path}/`); ++ const { packageLocation } = pnpApi.getPackageInformation(targetLocator); ++ const request = combinePaths(targetLocator.name, getRelativePathFromDirectory( ++ packageLocation, ++ path, ++ /*ignoreCase*/ ++ false ++ )); ++ return pnpApi.resolveToUnqualified(request, `${basePath}/`); ++ } catch { ++ return path; ++ } ++ }; ++ refs = refs == null ? void 0 : refs.map((r) => ({ ...r, path: getPnpPath(r.path) })); ++ } + this.projectReferences = refs; + this.potentialProjectReferences = void 0; + } +@@ -184807,6 +185097,7 @@ var _ProjectService = class _ProjectService { + log, + getDetailWatchInfo + ); ++ this.pnpWatcher = this.watchPnpFile(); + (_a = opts.incrementalVerifier) == null ? void 0 : _a.call(opts, this); + } + toPath(fileName) { +@@ -186737,7 +187028,7 @@ Dynamic files must always be opened with service's current directory or service + this.performanceEventHandler = performanceEventHandler; + } + setHostConfiguration(args) { +- var _a; ++ var _a, _b; + if (args.file) { + const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(args.file)); + if (info) { +@@ -186786,6 +187077,8 @@ Dynamic files must always be opened with service's current directory or service + this.hostConfiguration.watchOptions = substitution; + this.hostConfiguration.beforeSubstitution = substitution === watchOptions ? void 0 : watchOptions; + this.logger.info(`Host watch options changed to ${JSON.stringify(this.hostConfiguration.watchOptions)}, it will be take effect for next watches.`); ++ (_b = this.pnpWatcher) == null ? void 0 : _b.close(); ++ this.watchPnpFile(); + } + } + } +@@ -187736,6 +188029,29 @@ Dynamic files must always be opened with service's current directory or service + }); + } + /** @internal */ ++ watchPnpFile() { ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (!pnpApiPath) { ++ return; ++ } ++ return this.watchFactory.watchFile( ++ pnpApiPath, ++ () => { ++ this.forEachProject((project) => { ++ for (const info of project.getScriptInfos()) { ++ project.resolutionCache.invalidateResolutionOfFile(info.path); ++ } ++ project.markAsDirty(); ++ updateProjectIfDirty(project); ++ }); ++ this.delayEnsureProjectForOpenFiles(); ++ }, ++ 250 /* Low */, ++ this.hostConfiguration.watchOptions, ++ WatchType.ConfigFile ++ ); ++ } ++ /** @internal */ + watchPackageJsonFile(file, path, project) { + Debug.assert(project !== void 0); + let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path); diff --git a/packages/plugin-compat/sources/patches/typescript.patch.ts b/packages/plugin-compat/sources/patches/typescript.patch.ts index 8656b9f47ec1..22345be7b774 100644 --- a/packages/plugin-compat/sources/patches/typescript.patch.ts +++ b/packages/plugin-compat/sources/patches/typescript.patch.ts @@ -2,7 +2,7 @@ let patch: string; export function getPatch() { if (typeof patch === `undefined`) - patch = require(`zlib`).brotliDecompressSync(Buffer.from(`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`, `base64`)).toString(); + patch = require(`zlib`).brotliDecompressSync(Buffer.from(`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`, `base64`)).toString(); return patch; } diff --git a/packages/yarnpkg-builder/package.json b/packages/yarnpkg-builder/package.json index 3c1e77586c1a..9e19df822969 100644 --- a/packages/yarnpkg-builder/package.json +++ b/packages/yarnpkg-builder/package.json @@ -21,7 +21,7 @@ "devDependencies": { "@types/semver": "^7.1.0", "@yarnpkg/monorepo": "workspace:^", - "typescript": "5.4.1-rc" + "typescript": "5.5.0-beta" }, "scripts": { "postpack": "rm -rf lib", diff --git a/packages/yarnpkg-doctor/package.json b/packages/yarnpkg-doctor/package.json index a31dbf24371f..acb4d769de7b 100644 --- a/packages/yarnpkg-doctor/package.json +++ b/packages/yarnpkg-doctor/package.json @@ -16,7 +16,7 @@ "micromatch": "^4.0.2", "p-limit": "^2.2.0", "tslib": "^2.4.0", - "typescript": "5.4.1-rc" + "typescript": "5.5.0-beta" }, "devDependencies": { "@types/micromatch": "^4.0.1", diff --git a/packages/yarnpkg-sdks/sources/generateSdk.ts b/packages/yarnpkg-sdks/sources/generateSdk.ts index 3b15c56bca54..a19bdc216974 100644 --- a/packages/yarnpkg-sdks/sources/generateSdk.ts +++ b/packages/yarnpkg-sdks/sources/generateSdk.ts @@ -126,10 +126,6 @@ const TEMPLATE = (relPnpApiPath: PortablePath, module: string, {setupEnv = false `const absPnpApiPath = resolve(__dirname, relPnpApiPath);\n`, `const absRequire = createRequire(absPnpApiPath);\n`, `\n`, - ...(wrapModule ? [ - `const moduleWrapper = ${wrapModule.trim().replace(/^ {4}/gm, ``)}\n`, - `\n`, - ] : []), `if (existsSync(absPnpApiPath)) {\n`, ` if (!process.versions.pnp) {\n`, ` // Setup the environment to be able to require ${module}\n`, @@ -164,6 +160,10 @@ const TEMPLATE = (relPnpApiPath: PortablePath, module: string, {setupEnv = false ] : []), `}\n`, `\n`, + ...(wrapModule ? [ + `const moduleWrapper = ${wrapModule.trim().replace(/^ {4}/gm, ``)}\n`, + `\n`, + ] : []), `// Defer to the real ${module} your application uses\n`, wrapModule ? `module.exports = moduleWrapper(absRequire(\`${module}\`));\n` : `module.exports = absRequire(\`${module}\`);\n`, ].join(``); diff --git a/packages/yarnpkg-sdks/sources/sdks/base.ts b/packages/yarnpkg-sdks/sources/sdks/base.ts index 86020c64a966..821bf18231a0 100644 --- a/packages/yarnpkg-sdks/sources/sdks/base.ts +++ b/packages/yarnpkg-sdks/sources/sdks/base.ts @@ -249,6 +249,8 @@ export const generateTypescriptBaseWrapper: GenerateBaseWrapper = async (pnpApi: return tsserver; }; + + moduleWrapper(absRequire(\`typescript\`)); `; const wrapper = new Wrapper(`typescript` as PortablePath, {pnpApi, target}); diff --git a/yarn.lock b/yarn.lock index f1849c18a81a..1b45bf49b499 100644 --- a/yarn.lock +++ b/yarn.lock @@ -5173,7 +5173,7 @@ __metadata: esbuild: "npm:esbuild-wasm@^0.15.15" semver: "npm:^7.1.2" tslib: "npm:^2.4.0" - typescript: "npm:5.4.1-rc" + typescript: "npm:5.5.0-beta" bin: builder: ./sources/boot-cli-dev.js languageName: unknown @@ -5293,7 +5293,7 @@ __metadata: micromatch: "npm:^4.0.2" p-limit: "npm:^2.2.0" tslib: "npm:^2.4.0" - typescript: "npm:5.4.1-rc" + typescript: "npm:5.5.0-beta" bin: doctor: ./sources/boot-cli-dev.js languageName: unknown @@ -5385,7 +5385,7 @@ __metadata: three: "npm:^0.145.0" tslib: "npm:^2.4.0" typedoc: "npm:^0.25.7" - typescript: "npm:5.4.1-rc" + typescript: "npm:5.5.0-beta" unified: "npm:^11.0.4" unist-util-visit-parents: "npm:^6.0.1" usehooks-ts: "npm:^2.9.1" @@ -5492,7 +5492,7 @@ __metadata: pirates: "npm:^4.0.5" semver: "npm:^7.1.2" tslib: "npm:^2.4.0" - typescript: "npm:5.4.1-rc" + typescript: "npm:5.5.0-beta" dependenciesMeta: core-js: built: false @@ -19510,23 +19510,23 @@ pem@dexus/pem: languageName: node linkType: hard -"typescript@npm:5.4.1-rc": - version: 5.4.1-rc - resolution: "typescript@npm:5.4.1-rc" +"typescript@npm:5.5.0-beta": + version: 5.5.0-beta + resolution: "typescript@npm:5.5.0-beta" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 10/8f98b4df2a7eea6788c018c004161bd355c842f7e80777eaa5f96d75bf72d7f4d6d0d164dc6bbf40ca8763cb2e518839e0c941ebc5523a8baaa159cec1d209ae + checksum: 10/94d187972aff9c1b521fa40cb4e8121cd0ca701c7e33a28f7d2b6b16179b51d8f209822fd49da1899ffe949446f45624face5083fd9f1cfd0dd532f5865fcdee languageName: node linkType: hard -"typescript@patch:typescript@npm%3A5.4.1-rc#optional!builtin": - version: 5.4.1-rc - resolution: "typescript@patch:typescript@npm%3A5.4.1-rc#optional!builtin::version=5.4.1-rc&hash=5adc0c" +"typescript@patch:typescript@npm%3A5.5.0-beta#optional!builtin": + version: 5.5.0-beta + resolution: "typescript@patch:typescript@npm%3A5.5.0-beta#optional!builtin::version=5.5.0-beta&hash=b45daf" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 10/613747bc8c9636ad70e8a692331a78b7a1f3c30ea247bd7f5427eafcee9041a7b42d1b7ee484be018bfc448abbba286bd75ef5353108daec203b5882d18cd75d + checksum: 10/bba23e7bcae0b253b9af030094baf3964b2d19bea67beaf9faff34ddb89b83f47ab9357118c7e8174ad27790fac0088d88bbbd6f999c938accf75a788b31f87e languageName: node linkType: hard