diff --git a/.github/workflows/e2e-typescript-workflow.yml b/.github/workflows/e2e-typescript-workflow.yml index 4e06af9f9a99..24ccee237f6b 100644 --- a/.github/workflows/e2e-typescript-workflow.yml +++ b/.github/workflows/e2e-typescript-workflow.yml @@ -48,7 +48,7 @@ jobs: yarn add ts-pnp left-pad @types/left-pad - echo '{"compilerOptions": {"baseUrl": ".", "strict": true, "esModuleInterop": true}}' > tsconfig.json + echo '{"compilerOptions": {"baseUrl": ".", "strict": true, "esModuleInterop": true, "lib": ["es2015"]}}' > tsconfig.json echo "const foo: number = 42;" | tee file.ts yarn tsc --noEmit diff --git a/.pnp.cjs b/.pnp.cjs index e538eebb8f00..edda909a6f01 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -275,7 +275,7 @@ const RAW_RUNTIME_STATE = ["jest", "virtual:e470d99b1e4fdf4c5db5d090ff5472cdeba0404b7ffd31cd2efab3493dd184c67bc45f60c2ef1c040e2c41afe38c6280bffc5df2fbe3aefaa2b6eacf685ab07c#npm:29.2.1"],\ ["pirates", "npm:4.0.5"],\ ["tslib", "npm:2.4.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "linkType": "SOFT"\ }]\ @@ -11310,7 +11310,7 @@ const RAW_RUNTIME_STATE = ["regexpp", "npm:3.2.0"],\ ["semver", "npm:7.3.7"],\ ["tsutils", "virtual:5e27cd7a319c4b7c3909eb012bf293660fa275bf4eddce08571aa0562ef7b9b8f3c02315f6dad27820a35a49c368107bf917cd6e2a8d99abe84b6a230d415fc4#npm:3.21.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -11479,7 +11479,7 @@ const RAW_RUNTIME_STATE = ["@typescript-eslint/typescript-estree", "virtual:fe98bd70d13aaca1010fe6d701118ea3af3e45d43c8d6c5a099bc3b50f958b72e1ed6da100c174f4c93673179c6f276656d496d7d151b1435a7d2a99739ef29a#npm:5.3.1"],\ ["debug", "virtual:142ba651bd70dac073ff3db3802f4ea29eff00d44224dd3049edf764b3f7df3c6422788fa486ce2f45a8f2e710e5925abafab7126fee39d5d57a83f2087201ff#npm:4.3.4"],\ ["eslint", "npm:8.2.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -11635,7 +11635,7 @@ const RAW_RUNTIME_STATE = ["is-glob", "npm:4.0.3"],\ ["semver", "npm:7.3.7"],\ ["tsutils", "virtual:5e27cd7a319c4b7c3909eb012bf293660fa275bf4eddce08571aa0562ef7b9b8f3c02315f6dad27820a35a49c368107bf917cd6e2a8d99abe84b6a230d415fc4#npm:3.21.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@types/typescript",\ @@ -12057,7 +12057,7 @@ const RAW_RUNTIME_STATE = ]],\ ["semver", "npm:7.3.7"],\ ["tslib", "npm:2.4.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "linkType": "SOFT"\ }]\ @@ -13081,7 +13081,7 @@ const RAW_RUNTIME_STATE = ["micromatch", "npm:4.0.5"],\ ["p-limit", "npm:2.2.0"],\ ["tslib", "npm:2.4.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "linkType": "SOFT"\ }]\ @@ -13141,7 +13141,7 @@ const RAW_RUNTIME_STATE = ["eslint", "npm:8.2.0"],\ ["eslint-plugin-arca", "npm:0.12.1"],\ ["eslint-plugin-react", "virtual:4b728ee22ccd3ae66b83e3be6d39acfb5b7a775112cc78b6b4322feb849fcfe6e39510452356cb4477dc6089bee57db31d02bbfb03b9fc8e914effa16a4145be#npm:7.31.8"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@types/eslint",\ @@ -13299,7 +13299,7 @@ const RAW_RUNTIME_STATE = ["typedoc", "virtual:118b26a6cee620b5aa3e7e8d8b8e34cd9e486f75b92701001168da9be550fadd8c9d9b12643c642e2d528c2624fd8fe7e128eec9d715340efac44400432a0e0c#patch:typedoc@npm%3A0.17.0-3#~/.yarn/patches/typedoc-npm-0.17.0-3-0ce05847cf.patch::version=0.17.0-3&hash=803669"],\ ["typedoc-neo-theme", "npm:1.0.7"],\ ["typedoc-plugin-yarn", "portal:./typedoc-plugin-yarn::locator=%40yarnpkg%2Fgatsby%40workspace%3Apackages%2Fgatsby"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"],\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"],\ ["unescape-html", "npm:1.1.0"],\ ["unfetch", "npm:4.1.0"],\ ["unified", "npm:7.1.0"],\ @@ -13394,7 +13394,7 @@ const RAW_RUNTIME_STATE = ["jest", "virtual:e470d99b1e4fdf4c5db5d090ff5472cdeba0404b7ffd31cd2efab3493dd184c67bc45f60c2ef1c040e2c41afe38c6280bffc5df2fbe3aefaa2b6eacf685ab07c#npm:29.2.1"],\ ["pirates", "npm:4.0.5"],\ ["tslib", "npm:2.4.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "linkType": "SOFT"\ }]\ @@ -22744,7 +22744,8 @@ const RAW_RUNTIME_STATE = ["workspace:packages/yarnpkg-types", {\ "packageLocation": "./packages/yarnpkg-types/",\ "packageDependencies": [\ - ["@yarnpkg/types", "workspace:packages/yarnpkg-types"]\ + ["@yarnpkg/types", "workspace:packages/yarnpkg-types"],\ + ["tslib", "npm:2.4.0"]\ ],\ "linkType": "SOFT"\ }]\ @@ -48280,7 +48281,7 @@ const RAW_RUNTIME_STATE = ["tsutils", "virtual:5e27cd7a319c4b7c3909eb012bf293660fa275bf4eddce08571aa0562ef7b9b8f3c02315f6dad27820a35a49c368107bf917cd6e2a8d99abe84b6a230d415fc4#npm:3.21.0"],\ ["@types/typescript", null],\ ["tslib", "npm:1.13.0"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@types/typescript",\ @@ -48501,7 +48502,7 @@ const RAW_RUNTIME_STATE = ["typedoc-default-themes", "npm:0.8.0-0"],\ ["typedoc-neo-theme", "npm:1.0.7"],\ ["typedoc-plugin-yarn", "portal:./typedoc-plugin-yarn::locator=%40yarnpkg%2Fgatsby%40workspace%3Apackages%2Fgatsby"],\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "packagePeers": [\ "@strictsoftware/typedoc-plugin-monorepo",\ @@ -48628,10 +48629,10 @@ const RAW_RUNTIME_STATE = ],\ "linkType": "HARD"\ }],\ - ["patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058", {\ - "packageLocation": "./.yarn/cache/typescript-patch-d8b3555c5b-1568732705.zip/node_modules/typescript/",\ + ["patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2", {\ + "packageLocation": "./.yarn/cache/typescript-patch-5d9a25bdc8-cf8fb58b23.zip/node_modules/typescript/",\ "packageDependencies": [\ - ["typescript", "patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058"]\ + ["typescript", "patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2"]\ ],\ "linkType": "HARD"\ }]\ diff --git a/.yarn/cache/typescript-patch-d8b3555c5b-1568732705.zip b/.yarn/cache/typescript-npm-5.1.0-beta-cd60421662-b48af60cec.zip similarity index 52% rename from .yarn/cache/typescript-patch-d8b3555c5b-1568732705.zip rename to .yarn/cache/typescript-npm-5.1.0-beta-cd60421662-b48af60cec.zip index 06b97bab7dc8..70edc066de3d 100644 Binary files a/.yarn/cache/typescript-patch-d8b3555c5b-1568732705.zip and b/.yarn/cache/typescript-npm-5.1.0-beta-cd60421662-b48af60cec.zip differ diff --git a/.yarn/cache/typescript-npm-5.0.1-rc-c8e0816ce2-282f8b515b.zip b/.yarn/cache/typescript-patch-5d9a25bdc8-cf8fb58b23.zip similarity index 52% rename from .yarn/cache/typescript-npm-5.0.1-rc-c8e0816ce2-282f8b515b.zip rename to .yarn/cache/typescript-patch-5d9a25bdc8-cf8fb58b23.zip index f47899282aa7..e5bfdca2aa74 100644 Binary files a/.yarn/cache/typescript-npm-5.0.1-rc-c8e0816ce2-282f8b515b.zip and b/.yarn/cache/typescript-patch-5d9a25bdc8-cf8fb58b23.zip differ diff --git a/.yarn/sdks/typescript/package.json b/.yarn/sdks/typescript/package.json index 53efce9d72f0..318e9b6761ac 100644 --- a/.yarn/sdks/typescript/package.json +++ b/.yarn/sdks/typescript/package.json @@ -1,6 +1,6 @@ { "name": "typescript", - "version": "5.0.0-beta-sdk", + "version": "5.1.0-beta-sdk", "main": "./lib/typescript.js", "type": "commonjs" } diff --git a/.yarn/versions/5fe011d9.yml b/.yarn/versions/5fe011d9.yml new file mode 100644 index 000000000000..1494bd471424 --- /dev/null +++ b/.yarn/versions/5fe011d9.yml @@ -0,0 +1,23 @@ +releases: + "@yarnpkg/cli": patch + "@yarnpkg/plugin-compat": 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/.yarn/versions/75340348.yml b/.yarn/versions/75340348.yml new file mode 100644 index 000000000000..22e76f05f959 --- /dev/null +++ b/.yarn/versions/75340348.yml @@ -0,0 +1,27 @@ +releases: + "@yarnpkg/cli": patch + "@yarnpkg/plugin-pnp": patch + "@yarnpkg/pnp": patch + +declined: + - "@yarnpkg/plugin-compat" + - "@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-pnpm" + - "@yarnpkg/plugin-stage" + - "@yarnpkg/plugin-typescript" + - "@yarnpkg/plugin-version" + - "@yarnpkg/plugin-workspace-tools" + - "@yarnpkg/builder" + - "@yarnpkg/core" + - "@yarnpkg/doctor" + - "@yarnpkg/nm" + - "@yarnpkg/pnpify" + - "@yarnpkg/sdks" diff --git a/.yarn/versions/87cc1e30.yml b/.yarn/versions/87cc1e30.yml new file mode 100644 index 000000000000..9e1016b4400a --- /dev/null +++ b/.yarn/versions/87cc1e30.yml @@ -0,0 +1,5 @@ +releases: + "@yarnpkg/types": patch + +declined: + - "@yarnpkg/plugin-constraints" diff --git a/.yarn/versions/fefcfcf9.yml b/.yarn/versions/fefcfcf9.yml new file mode 100644 index 000000000000..145744c0efdf --- /dev/null +++ b/.yarn/versions/fefcfcf9.yml @@ -0,0 +1,36 @@ +releases: + "@yarnpkg/fslib": patch + +declined: + - "@yarnpkg/plugin-compat" + - "@yarnpkg/plugin-constraints" + - "@yarnpkg/plugin-dlx" + - "@yarnpkg/plugin-essentials" + - "@yarnpkg/plugin-exec" + - "@yarnpkg/plugin-file" + - "@yarnpkg/plugin-git" + - "@yarnpkg/plugin-github" + - "@yarnpkg/plugin-init" + - "@yarnpkg/plugin-link" + - "@yarnpkg/plugin-nm" + - "@yarnpkg/plugin-npm" + - "@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" + - vscode-zipfs + - "@yarnpkg/builder" + - "@yarnpkg/cli" + - "@yarnpkg/core" + - "@yarnpkg/doctor" + - "@yarnpkg/libzip" + - "@yarnpkg/nm" + - "@yarnpkg/pnp" + - "@yarnpkg/pnpify" + - "@yarnpkg/sdks" + - "@yarnpkg/shell" diff --git a/package.json b/package.json index 7df81a969c42..0206441bd933 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ "jest": "^29.2.1", "pirates": "^4.0.5", "tslib": "^2.4.0", - "typescript": "5.0.1-rc" + "typescript": "5.1.0-beta" }, "resolutions": { "ink": "patch:ink@npm%3A3.0.8#~/.yarn/patches/ink-npm-3.0.8-3a8005f59f.patch", diff --git a/packages/gatsby/content/getting-started/editor-sdks.md b/packages/gatsby/content/getting-started/editor-sdks.md index c02fe2e3e6f1..7b07ad4d7e68 100644 --- a/packages/gatsby/content/getting-started/editor-sdks.md +++ b/packages/gatsby/content/getting-started/editor-sdks.md @@ -70,6 +70,8 @@ Run the following command, which will generate a new directory called `.yarn/sdk yarn dlx @yarnpkg/sdks vim ``` +Note that if you're using `coc-tsserver` then you might want to check what version it uses by running `:CocCommand tsserver.chooseVersion` — make sure that "Local version" is selected, not "Bundled with coc-tsserver". + #### Neovim Native LSP > **Note:** Requires Neovim version >=0.6 diff --git a/packages/gatsby/package.json b/packages/gatsby/package.json index 19a3cf19b8d0..efbd104c4c79 100644 --- a/packages/gatsby/package.json +++ b/packages/gatsby/package.json @@ -89,7 +89,7 @@ "typedoc": "patch:typedoc@npm%3A0.17.0-3#~/.yarn/patches/typedoc-npm-0.17.0-3-0ce05847cf.patch", "typedoc-neo-theme": "^1.0.7", "typedoc-plugin-yarn": "portal:./typedoc-plugin-yarn", - "typescript": "5.0.1-rc", + "typescript": "5.1.0-beta", "unescape-html": "^1.1.0", "unfetch": "^4.1.0", "unified": "^7.1.0", diff --git a/packages/gatsby/static/configuration/yarnrc.json b/packages/gatsby/static/configuration/yarnrc.json index bc610c8b1336..b1117a1a2a74 100644 --- a/packages/gatsby/static/configuration/yarnrc.json +++ b/packages/gatsby/static/configuration/yarnrc.json @@ -105,7 +105,7 @@ }, "enableColors": { "_package": "@yarnpkg/core", - "description": "If true (by default detects terminal capabilities), Yarn will format its pretty-print its output by using colors to differentiate important parts of its messages.", + "description": "If true (by default detects terminal capabilities), Yarn will format its pretty-print output by using colors to differentiate important parts of its messages.", "type": "boolean", "examples": [true] }, @@ -123,7 +123,7 @@ }, "enableImmutableCache": { "_package": "@yarnpkg/core", - "description": "If true, Yarn will refuse the change the cache in any way (whether it would add files or remove them) when running `yarn install`.", + "description": "If true, Yarn will refuse to change the cache in any way (whether it would add files or remove them) when running `yarn install`.", "type": "boolean", "default": false }, @@ -183,7 +183,7 @@ }, "enableTelemetry": { "_package": "@yarnpkg/core", - "description": "If true (the default outside of CI environments), Yarn will periodically send anonymous data to our servers tracking some usage information such as the number of dependency in your project, how many install you ran, etc. Consult the [Telemetry](/advanced/telemetry) page for more details about it.", + "description": "If true (the default outside of CI environments), Yarn will periodically send anonymous data to our servers tracking some usage information such as the number of dependencies in your project, how many installs you ran, etc. Consult the [Telemetry](/advanced/telemetry) page for more details about it.", "type": "boolean", "examples": [true] }, @@ -496,7 +496,7 @@ "type": "object", "patternProperties": { "^(?:^[a-zA-Z][a-zA-Z0-9+-.]*:)?[^\\s]*$": { - "description": "This key represent the registry that's covered by the settings defined in the nested object. The protocol is optional (using `https://npm.pkg.github.com` would work just as well).", + "description": "This key represents the registry that's covered by the settings defined in the nested object. The protocol is optional (using `https://npm.pkg.github.com` would work just as well).", "type": "object", "properties": { "npmAlwaysAuth": { @@ -716,7 +716,7 @@ }, "rcFilename": { "_package": "@yarnpkg/core", - "description": "This setting defines the name of the files that Yarn looks for when resolving the rc files. For obvious reasons this settings cannot be set within rc files, and must be defined in the environment using the `YARN_RC_FILENAME` variable.", + "description": "This setting defines the name of the files that Yarn looks for when resolving the rc files. For obvious reasons, this setting cannot be set within rc files, and must be defined in the environment using the `YARN_RC_FILENAME` variable.", "type": "string", "pattern": "^[^<>:;,?\"*|/]+$", "default": ".yarnrc.yml" diff --git a/packages/plugin-compat/extra/typescript/gen-typescript-patch.js b/packages/plugin-compat/extra/typescript/gen-typescript-patch.js index 0c119d8163e6..69c77d093e87 100644 --- a/packages/plugin-compat/extra/typescript/gen-typescript-patch.js +++ b/packages/plugin-compat/extra/typescript/gen-typescript-patch.js @@ -160,7 +160,14 @@ const SLICES = [ from: `2c85874875fdf1f1182733b99afe47604915bfec`, to: `9a2c1c80b05a5fbd5bc6d2bfcbaa617793a236ab`, onto: `89515ce7e31d0bfaef776ac25929a78015cceb82`, - range: `>=5.0.1-rc`, + range: `>=5.0.1-rc <5.1.0-beta`, + }, + // https://github.com/merceyz/TypeScript/tree/merceyz/pnp-5.1 + { + from: `a6ef895fb06014c416cce2f80969912ec5ea47d5`, + to: `a6ef895fb06014c416cce2f80969912ec5ea47d5`, + onto: `1c5cc6152322cd5b131b6e617e0947bcb068fc4a`, + range: `>=5.1.0-beta`, }, ]; diff --git a/packages/plugin-compat/extra/typescript/patch-02c20e6d5668807b199467622bb0d6a8.diff b/packages/plugin-compat/extra/typescript/patch-02c20e6d5668807b199467622bb0d6a8.diff index 98081579eb67..ffab573aa6ee 100644 --- a/packages/plugin-compat/extra/typescript/patch-02c20e6d5668807b199467622bb0d6a8.diff +++ b/packages/plugin-compat/extra/typescript/patch-02c20e6d5668807b199467622bb0d6a8.diff @@ -1,6 +1,6 @@ diff --git a/lib/tsc.js b/lib/tsc.js index 92bf3cf99..5df945acb 100644 -semver exclusivity >=5.0.1-rc +semver exclusivity >=5.0.1-rc <5.1.0-beta --- a/lib/tsc.js +++ b/lib/tsc.js @@ -5153,6 +5153,9 @@ var sys = (() => { @@ -329,7 +329,7 @@ semver exclusivity >=5.0.1-rc synchronizeProgram(); diff --git a/lib/tsserver.js b/lib/tsserver.js index 20cb517f8..eeac46d44 100644 -semver exclusivity >=5.0.1-rc +semver exclusivity >=5.0.1-rc <5.1.0-beta --- a/lib/tsserver.js +++ b/lib/tsserver.js @@ -8601,6 +8601,9 @@ var sys = (() => { @@ -966,7 +966,7 @@ semver exclusivity >=5.0.1-rc this.installer.on("message", (m) => this.handleMessage(m)); diff --git a/lib/tsserverlibrary.js b/lib/tsserverlibrary.js index a69e846e7..d1973b29c 100644 -semver exclusivity >=5.0.1-rc +semver exclusivity >=5.0.1-rc <5.1.0-beta --- a/lib/tsserverlibrary.js +++ b/lib/tsserverlibrary.js @@ -6412,6 +6412,9 @@ ${lanes.join("\n")} @@ -1649,7 +1649,7 @@ semver exclusivity >=5.0.1-rc if (!watchers.has(path)) { diff --git a/lib/typescript.js b/lib/typescript.js index 4b53c156e..54d44a8d6 100644 -semver exclusivity >=5.0.1-rc +semver exclusivity >=5.0.1-rc <5.1.0-beta --- a/lib/typescript.js +++ b/lib/typescript.js @@ -6412,6 +6412,9 @@ ${lanes.join("\n")} @@ -2230,7 +2230,7 @@ semver exclusivity >=5.0.1-rc kindPrecedence = { diff --git a/lib/typingsInstaller.js b/lib/typingsInstaller.js index 00afe537d..97a3bab6b 100644 -semver exclusivity >=5.0.1-rc +semver exclusivity >=5.0.1-rc <5.1.0-beta --- a/lib/typingsInstaller.js +++ b/lib/typingsInstaller.js @@ -4587,6 +4587,9 @@ var sys = (() => { diff --git a/packages/plugin-compat/extra/typescript/patch-0fce2ce089fe15ad286b7a14693f6c4e.diff b/packages/plugin-compat/extra/typescript/patch-0fce2ce089fe15ad286b7a14693f6c4e.diff new file mode 100644 index 000000000000..53b8b8312908 --- /dev/null +++ b/packages/plugin-compat/extra/typescript/patch-0fce2ce089fe15ad286b7a14693f6c4e.diff @@ -0,0 +1,2405 @@ +diff --git a/lib/tsc.js b/lib/tsc.js +index 012388982..34e6d3071 100644 +semver exclusivity >=5.1.0-beta +--- a/lib/tsc.js ++++ b/lib/tsc.js +@@ -5054,6 +5054,9 @@ var sys = (() => { + return Buffer.from && Buffer.from !== Int8Array.from ? Buffer.from(input, encoding) : new Buffer(input, encoding); + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -36340,6 +36343,46 @@ function getDefaultValueForOption(option) { + } + } + ++// src/compiler/pnp.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 ++ ); ++} ++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) { + host.trace(formatMessage.apply(void 0, arguments)); +@@ -36550,7 +36593,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); +@@ -36563,6 +36606,15 @@ function arePathsEqual(path1, path2, host) { + const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 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); +@@ -38421,7 +38473,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) { +@@ -38456,11 +38516,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"))) { +@@ -38754,6 +38843,18 @@ function traceIfEnabled(state, diagnostic, ...args) { + trace(state.host, diagnostic, ...args); + } + } ++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) { +@@ -42079,7 +42180,15 @@ function getAllModulePathsWorker(importingFileName, importedFileName, host) { + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(importingFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -42271,7 +42380,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; + } +@@ -42309,14 +42452,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(sourceDirectory, 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(sourceDirectory, 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); +@@ -42329,9 +42474,9 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + const importMode = overrideMode || importingSourceFile.impliedNodeFormat; + 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 === 99 /* ESNext */); +- const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) }; + return { ...withJsExtension, verbatimFromExports: true }; +@@ -119761,6 +119906,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; +@@ -119822,6 +119972,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) { +@@ -119854,7 +120008,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); +@@ -119866,7 +120020,7 @@ function createWatchProgram(host) { + resolutionCache.clear(); + } + } +- const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions); ++ const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions); + const { + originalReadFile, + originalFileExists, +@@ -120072,13 +120226,19 @@ function createWatchProgram(host) { + reloadLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ reloadLevel = 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 (reloadLevel) { + case 1 /* Partial */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -120088,12 +120248,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 1bcfee524..bf80053e9 100644 +semver exclusivity >=5.1.0-beta +--- a/lib/tsserver.js ++++ b/lib/tsserver.js +@@ -8547,6 +8547,9 @@ var sys = (() => { + return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding); + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -40801,6 +40804,67 @@ function getDefaultValueForOption(option) { + } + } + ++// src/compiler/pnp.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 ++ ); ++} ++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) { + host.trace(formatMessage.apply(void 0, arguments)); +@@ -41011,7 +41075,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); +@@ -41024,6 +41088,15 @@ function arePathsEqual(path1, path2, host) { + const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 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); +@@ -41268,6 +41341,21 @@ function getConditions(options, esmMode) { + } + 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"); +@@ -43021,7 +43109,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) { +@@ -43056,11 +43152,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"))) { +@@ -43354,6 +43479,18 @@ function traceIfEnabled(state, diagnostic, ...args) { + trace(state.host, diagnostic, ...args); + } + } ++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) => { +@@ -46733,7 +46870,15 @@ function getAllModulePathsWorker(importingFileName, importedFileName, host) { + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(importingFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -46925,7 +47070,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; + } +@@ -46963,14 +47142,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(sourceDirectory, 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(sourceDirectory, 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); +@@ -46983,9 +47164,9 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa + const importMode = overrideMode || importingSourceFile.impliedNodeFormat; + 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 === 99 /* ESNext */); +- const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) }; + return { ...withJsExtension, verbatimFromExports: true }; +@@ -117187,6 +117368,7 @@ var ConfigFileProgramReloadLevel = /* @__PURE__ */ ((ConfigFileProgramReloadLeve + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["None"] = 0] = "None"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Partial"] = 1] = "Partial"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Full"] = 2] = "Full"; ++ ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Resolutions"] = 3] = "Resolutions"; + return ConfigFileProgramReloadLevel2; + })(ConfigFileProgramReloadLevel || {}); + function updateSharedExtendedConfigFileWatcher(projectPath, options, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath3) { +@@ -124711,6 +124893,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; +@@ -124772,6 +124959,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) { +@@ -124804,7 +124995,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); +@@ -124816,7 +125007,7 @@ function createWatchProgram(host) { + resolutionCache.clear(); + } + } +- const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions); ++ const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions); + const { + originalReadFile, + originalFileExists, +@@ -125022,13 +125213,19 @@ function createWatchProgram(host) { + reloadLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ reloadLevel = 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 (reloadLevel) { + case 1 /* Partial */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -125038,12 +125235,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() { +@@ -130495,7 +130699,14 @@ function createPackageJsonImportFilter(fromFile, preferences, host) { + return false; + } + function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) { +- if (!stringContains(importedFileName, "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 (!stringContains(importedFileName, "node_modules")) { + return void 0; + } + const specifier = ts_moduleSpecifiers_exports.getNodeModulesPackageName( +@@ -130986,6 +131197,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); +@@ -153414,7 +153628,31 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c + ); + } + }; +- if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) { ++ const checkExports = (packageFile, packageDirectory, fragmentSubpath) => { ++ const packageJson = readJson(packageFile, host); ++ const exports = packageJson.exports; ++ if (exports) { ++ if (typeof exports !== "object" || exports === null) { ++ return true; ++ } ++ const keys = getOwnKeys(exports); ++ const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; ++ addCompletionEntriesFromPathsOrExports( ++ result, ++ fragmentSubpath, ++ packageDirectory, ++ extensionOptions, ++ host, ++ keys, ++ (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), ++ comparePatternKeys ++ ); ++ return true; ++ } ++ return false; ++ }; ++ const shouldCheckExports = fragmentDirectory && getResolvePackageJsonExports(compilerOptions); ++ if (shouldCheckExports) { + const nodeModulesDirectoryLookup = ancestorLookup; + ancestorLookup = (ancestor) => { + const components = getPathComponents(fragment); +@@ -153433,32 +153671,52 @@ function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, c + const packageDirectory = combinePaths(ancestor, "node_modules", packagePath); + const packageFile = combinePaths(packageDirectory, "package.json"); + if (tryFileExists(host, packageFile)) { +- const packageJson = readJson(packageFile, host); +- const exports = packageJson.exports; +- if (exports) { +- if (typeof exports !== "object" || exports === 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(exports); +- const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); +- const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; +- addCompletionEntriesFromPathsOrExports( +- result, +- fragmentSubpath, ++ } ++ if (shouldGetCompletions) { ++ getCompletionEntriesForDirectoryFragment( ++ subPath, + packageDirectory, + extensionOptions, + host, +- keys, +- (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), +- comparePatternKeys ++ /*moduleSpecifierIsRelative*/ ++ false, ++ /*exclude*/ ++ void 0, ++ result + ); +- return; + } + } +- return nodeModulesDirectoryLookup(ancestor); +- }; ++ } ++ } else { ++ forEachAncestorDirectory(scriptPath, ancestorLookup); + } +- forEachAncestorDirectory(scriptPath, ancestorLookup); + } + } + return arrayFrom(result.values()); +@@ -153585,9 +153843,15 @@ function getCompletionEntriesFromTypings(host, options, 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) { +@@ -174821,6 +175085,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; + } +@@ -175392,6 +175679,7 @@ var _ProjectService = class { + watchFile: returnNoopFileWatcher, + watchDirectory: returnNoopFileWatcher + } : getWatchFactory(this.host, watchLogLevel, log, getDetailWatchInfo2); ++ this.pnpWatcher = this.watchPnpFile(); + } + toPath(fileName) { + return toPath(fileName, this.currentDirectory, this.toCanonicalFileName); +@@ -177192,7 +177480,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) { +@@ -177236,6 +177524,8 @@ Dynamic files must always be opened with service's current directory or service + if (args.watchOptions) { + this.hostConfiguration.watchOptions = (_a = convertWatchOptions(args.watchOptions)) == null ? void 0 : _a.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(); + } + } + } +@@ -178147,6 +178437,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(path) { + const watchers = this.packageJsonFilesMap || (this.packageJsonFilesMap = /* @__PURE__ */ new Map()); + if (!watchers.has(path)) { +@@ -182675,6 +182988,10 @@ function initializeNodeSystem() { + } + try { + const args = [combinePaths(libDirectory, "watchGuard.js"), path]; ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ args.unshift("-r", pnpApiPath); ++ } + if (logger.hasLevel(3 /* verbose */)) { + logger.info(`Starting ${process.execPath} with args:${stringifyIndented(args)}`); + } +@@ -182887,6 +183204,10 @@ function startNodeSession(options, logger, cancellationToken) { + break; + } + } ++ const pnpApiPath = getPnpApiPath(__filename); ++ if (pnpApiPath) { ++ execArgv.unshift("-r", pnpApiPath); ++ } + const typingsInstaller = combinePaths(getDirectoryPath(sys.getExecutingFilePath()), "typingsInstaller.js"); + this.installer = childProcess.fork(typingsInstaller, args, { execArgv }); + this.installer.on("message", (m) => this.handleMessage(m)); +diff --git a/lib/tsserverlibrary.js b/lib/tsserverlibrary.js +index 0d1d2fcd0..85552699b 100644 +semver exclusivity >=5.1.0-beta +--- a/lib/tsserverlibrary.js ++++ b/lib/tsserverlibrary.js +@@ -6345,6 +6345,9 @@ ${lanes.join("\n")} + return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding); + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -38688,6 +38691,73 @@ ${lanes.join("\n")} + } + }); + ++ // src/compiler/pnp.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 ++ ); ++ } ++ 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; ++ } ++ var init_pnp = __esm({ ++ "src/compiler/pnp.ts"() { ++ "use strict"; ++ init_path(); ++ } ++ }); ++ + // src/compiler/moduleNameResolver.ts + function trace(host) { + host.trace(formatMessage.apply(void 0, arguments)); +@@ -38897,7 +38967,7 @@ ${lanes.join("\n")} + return getDefaultTypeRoots(currentDirectory); + } + } +- function getDefaultTypeRoots(currentDirectory) { ++ function getNodeModulesTypeRoots(currentDirectory) { + let typeRoots; + forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => { + const atTypes = combinePaths(directory, nodeModulesAtTypes); +@@ -38909,6 +38979,15 @@ ${lanes.join("\n")} + const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 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); +@@ -39153,6 +39232,21 @@ ${lanes.join("\n")} + } + 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"); +@@ -40892,7 +40986,15 @@ ${lanes.join("\n")} + 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) { +@@ -40927,11 +41029,40 @@ ${lanes.join("\n")} + 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"))) { +@@ -41224,11 +41355,24 @@ ${lanes.join("\n")} + trace(state.host, diagnostic, ...args); + } + } ++ 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; ++ } + var typeScriptVersion, nodeModulesAtTypes, NodeResolutionFeatures, nodeModulesPathPart, mangledScopedPackageSeparator; + var init_moduleNameResolver = __esm({ + "src/compiler/moduleNameResolver.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + nodeModulesAtTypes = combinePaths("node_modules", "@types"); + NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => { + NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None"; +@@ -44625,7 +44769,15 @@ ${lanes.join("\n")} + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(importingFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -44817,7 +44969,41 @@ ${lanes.join("\n")} + 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; + } +@@ -44855,14 +45041,16 @@ ${lanes.join("\n")} + if (isRedirect && !isPackageRootPath) { + return void 0; + } +- const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); +- const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); +- if (!(startsWith(sourceDirectory, 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(sourceDirectory, 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); +@@ -44875,9 +45063,9 @@ ${lanes.join("\n")} + const importMode = overrideMode || importingSourceFile.impliedNodeFormat; + 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 === 99 /* ESNext */); +- const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) }; + return { ...withJsExtension, verbatimFromExports: true }; +@@ -45023,6 +45211,7 @@ ${lanes.join("\n")} + "src/compiler/moduleSpecifiers.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + } + }); + +@@ -115572,6 +115761,7 @@ ${lanes.join("\n")} + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["None"] = 0] = "None"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Partial"] = 1] = "Partial"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Full"] = 2] = "Full"; ++ ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Resolutions"] = 3] = "Resolutions"; + return ConfigFileProgramReloadLevel2; + })(ConfigFileProgramReloadLevel || {}); + WatchLogLevel = /* @__PURE__ */ ((WatchLogLevel2) => { +@@ -122881,6 +123071,11 @@ ${lanes.join("\n")} + 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; +@@ -122942,6 +123137,10 @@ ${lanes.join("\n")} + configFileWatcher.close(); + configFileWatcher = void 0; + } ++ if (pnpFileWatcher) { ++ pnpFileWatcher.close(); ++ pnpFileWatcher = void 0; ++ } + extendedConfigCache == null ? void 0 : extendedConfigCache.clear(); + extendedConfigCache = void 0; + if (sharedExtendedConfigFileWatchers) { +@@ -122974,7 +123173,7 @@ ${lanes.join("\n")} + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } +- function synchronizeProgram() { ++ function synchronizeProgram(forceAllFilesAsInvalidated = false) { + writeLog(`Synchronizing program`); + Debug.assert(compilerOptions); + Debug.assert(rootFileNames); +@@ -122986,7 +123185,7 @@ ${lanes.join("\n")} + resolutionCache.clear(); + } + } +- const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions); ++ const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions); + const { + originalReadFile, + originalFileExists, +@@ -123192,13 +123391,19 @@ ${lanes.join("\n")} + reloadLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ reloadLevel = 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 (reloadLevel) { + case 1 /* Partial */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -123208,12 +123413,19 @@ ${lanes.join("\n")} + (_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() { +@@ -123499,6 +123711,7 @@ ${lanes.join("\n")} + "src/compiler/watchPublic.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + } + }); + +@@ -128764,7 +128977,14 @@ ${lanes.join("\n")} + return false; + } + function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) { +- if (!stringContains(importedFileName, "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 (!stringContains(importedFileName, "node_modules")) { + return void 0; + } + const specifier = ts_moduleSpecifiers_exports.getNodeModulesPackageName( +@@ -129026,6 +129246,7 @@ ${lanes.join("\n")} + var init_utilities4 = __esm({ + "src/services/utilities.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + scanner = createScanner( + 99 /* Latest */, +@@ -129298,6 +129519,9 @@ ${lanes.join("\n")} + 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); +@@ -129481,6 +129705,7 @@ ${lanes.join("\n")} + var init_exportInfoMap = __esm({ + "src/services/exportInfoMap.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + ImportKind = /* @__PURE__ */ ((ImportKind2) => { + ImportKind2[ImportKind2["Named"] = 0] = "Named"; +@@ -152497,7 +152722,31 @@ ${lanes.join("\n")} + ); + } + }; +- if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) { ++ const checkExports = (packageFile, packageDirectory, fragmentSubpath) => { ++ const packageJson = readJson(packageFile, host); ++ const exports = packageJson.exports; ++ if (exports) { ++ if (typeof exports !== "object" || exports === null) { ++ return true; ++ } ++ const keys = getOwnKeys(exports); ++ const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; ++ addCompletionEntriesFromPathsOrExports( ++ result, ++ fragmentSubpath, ++ packageDirectory, ++ extensionOptions, ++ host, ++ keys, ++ (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), ++ comparePatternKeys ++ ); ++ return true; ++ } ++ return false; ++ }; ++ const shouldCheckExports = fragmentDirectory && getResolvePackageJsonExports(compilerOptions); ++ if (shouldCheckExports) { + const nodeModulesDirectoryLookup = ancestorLookup; + ancestorLookup = (ancestor) => { + const components = getPathComponents(fragment); +@@ -152516,32 +152765,52 @@ ${lanes.join("\n")} + const packageDirectory = combinePaths(ancestor, "node_modules", packagePath); + const packageFile = combinePaths(packageDirectory, "package.json"); + if (tryFileExists(host, packageFile)) { +- const packageJson = readJson(packageFile, host); +- const exports = packageJson.exports; +- if (exports) { +- if (typeof exports !== "object" || exports === 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(exports); +- const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); +- const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; +- addCompletionEntriesFromPathsOrExports( +- result, +- fragmentSubpath, ++ } ++ if (shouldGetCompletions) { ++ getCompletionEntriesForDirectoryFragment( ++ subPath, + packageDirectory, + extensionOptions, + host, +- keys, +- (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), +- comparePatternKeys ++ /*moduleSpecifierIsRelative*/ ++ false, ++ /*exclude*/ ++ void 0, ++ result + ); +- return; + } + } +- return nodeModulesDirectoryLookup(ancestor); +- }; ++ } ++ } else { ++ forEachAncestorDirectory(scriptPath, ancestorLookup); + } +- forEachAncestorDirectory(scriptPath, ancestorLookup); + } + } + return arrayFrom(result.values()); +@@ -152668,9 +152937,15 @@ ${lanes.join("\n")} + 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) { +@@ -152753,6 +153028,7 @@ ${lanes.join("\n")} + var init_stringCompletions = __esm({ + "src/services/stringCompletions.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + init_ts_Completions(); + kindPrecedence = { +@@ -170163,6 +170439,7 @@ ${options.prefix}` : "\n" : options.prefix + var init_project = __esm({ + "src/server/project.ts"() { + "use strict"; ++ init_pnp(); + init_ts7(); + init_ts7(); + init_ts_server3(); +@@ -172160,6 +172437,29 @@ ${options.prefix}` : "\n" : options.prefix + 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; + } +@@ -172544,6 +172844,7 @@ ${options.prefix}` : "\n" : options.prefix + var init_editorServices = __esm({ + "src/server/editorServices.ts"() { + "use strict"; ++ init_pnp(); + init_ts7(); + init_ts_server3(); + maxProgramSizeForNonTsFiles = 20 * 1024 * 1024; +@@ -172757,6 +173058,7 @@ ${options.prefix}` : "\n" : options.prefix + watchFile: returnNoopFileWatcher, + watchDirectory: returnNoopFileWatcher + } : getWatchFactory(this.host, watchLogLevel, log, getDetailWatchInfo2); ++ this.pnpWatcher = this.watchPnpFile(); + } + toPath(fileName) { + return toPath(fileName, this.currentDirectory, this.toCanonicalFileName); +@@ -174557,7 +174859,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) { +@@ -174601,6 +174903,8 @@ Dynamic files must always be opened with service's current directory or service + if (args.watchOptions) { + this.hostConfiguration.watchOptions = (_a = convertWatchOptions(args.watchOptions)) == null ? void 0 : _a.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(); + } + } + } +@@ -175512,6 +175816,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(path) { + const watchers = this.packageJsonFilesMap || (this.packageJsonFilesMap = /* @__PURE__ */ new Map()); + if (!watchers.has(path)) { +diff --git a/lib/typescript.js b/lib/typescript.js +index 1b800b1d0..377a93466 100644 +semver exclusivity >=5.1.0-beta +--- a/lib/typescript.js ++++ b/lib/typescript.js +@@ -6345,6 +6345,9 @@ ${lanes.join("\n")} + return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding); + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -38688,6 +38691,73 @@ ${lanes.join("\n")} + } + }); + ++ // src/compiler/pnp.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 ++ ); ++ } ++ 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; ++ } ++ var init_pnp = __esm({ ++ "src/compiler/pnp.ts"() { ++ "use strict"; ++ init_path(); ++ } ++ }); ++ + // src/compiler/moduleNameResolver.ts + function trace(host) { + host.trace(formatMessage.apply(void 0, arguments)); +@@ -38897,7 +38967,7 @@ ${lanes.join("\n")} + return getDefaultTypeRoots(currentDirectory); + } + } +- function getDefaultTypeRoots(currentDirectory) { ++ function getNodeModulesTypeRoots(currentDirectory) { + let typeRoots; + forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => { + const atTypes = combinePaths(directory, nodeModulesAtTypes); +@@ -38909,6 +38979,15 @@ ${lanes.join("\n")} + const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 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); +@@ -39153,6 +39232,21 @@ ${lanes.join("\n")} + } + 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"); +@@ -40892,7 +40986,15 @@ ${lanes.join("\n")} + 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) { +@@ -40927,11 +41029,40 @@ ${lanes.join("\n")} + 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"))) { +@@ -41224,11 +41355,24 @@ ${lanes.join("\n")} + trace(state.host, diagnostic, ...args); + } + } ++ 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; ++ } + var typeScriptVersion, nodeModulesAtTypes, NodeResolutionFeatures, nodeModulesPathPart, mangledScopedPackageSeparator; + var init_moduleNameResolver = __esm({ + "src/compiler/moduleNameResolver.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + nodeModulesAtTypes = combinePaths("node_modules", "@types"); + NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => { + NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None"; +@@ -44625,7 +44769,15 @@ ${lanes.join("\n")} + /*preferSymlinks*/ + true, + (path, isRedirect) => { +- const isInNodeModules = pathContainsNodeModules(path); ++ let isInNodeModules = pathContainsNodeModules(path); ++ const pnpapi = getPnpApi(path); ++ if (!isInNodeModules && pnpapi) { ++ const fromLocator = pnpapi.findPackageLocator(importingFileName); ++ const toLocator = pnpapi.findPackageLocator(path); ++ if (fromLocator && toLocator && fromLocator !== toLocator) { ++ isInNodeModules = true; ++ } ++ } + allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + } +@@ -44817,7 +44969,41 @@ ${lanes.join("\n")} + 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; + } +@@ -44855,14 +45041,16 @@ ${lanes.join("\n")} + if (isRedirect && !isPackageRootPath) { + return void 0; + } +- const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); +- const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); +- if (!(startsWith(sourceDirectory, 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(sourceDirectory, 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); +@@ -44875,9 +45063,9 @@ ${lanes.join("\n")} + const importMode = overrideMode || importingSourceFile.impliedNodeFormat; + 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 === 99 /* ESNext */); +- const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName2, packageJsonContent.exports, conditions) : void 0; ++ const fromExports = packageJsonContent.exports ? tryGetModuleNameFromExports(options, path, packageRootPath, packageName, packageJsonContent.exports, conditions) : void 0; + if (fromExports) { + const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) }; + return { ...withJsExtension, verbatimFromExports: true }; +@@ -45023,6 +45211,7 @@ ${lanes.join("\n")} + "src/compiler/moduleSpecifiers.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + } + }); + +@@ -115572,6 +115761,7 @@ ${lanes.join("\n")} + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["None"] = 0] = "None"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Partial"] = 1] = "Partial"; + ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Full"] = 2] = "Full"; ++ ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Resolutions"] = 3] = "Resolutions"; + return ConfigFileProgramReloadLevel2; + })(ConfigFileProgramReloadLevel || {}); + WatchLogLevel = /* @__PURE__ */ ((WatchLogLevel2) => { +@@ -122881,6 +123071,11 @@ ${lanes.join("\n")} + 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; +@@ -122942,6 +123137,10 @@ ${lanes.join("\n")} + configFileWatcher.close(); + configFileWatcher = void 0; + } ++ if (pnpFileWatcher) { ++ pnpFileWatcher.close(); ++ pnpFileWatcher = void 0; ++ } + extendedConfigCache == null ? void 0 : extendedConfigCache.clear(); + extendedConfigCache = void 0; + if (sharedExtendedConfigFileWatchers) { +@@ -122974,7 +123173,7 @@ ${lanes.join("\n")} + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } +- function synchronizeProgram() { ++ function synchronizeProgram(forceAllFilesAsInvalidated = false) { + writeLog(`Synchronizing program`); + Debug.assert(compilerOptions); + Debug.assert(rootFileNames); +@@ -122986,7 +123185,7 @@ ${lanes.join("\n")} + resolutionCache.clear(); + } + } +- const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions); ++ const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(forceAllFilesAsInvalidated ? returnTrue : customHasInvalidatedResolutions); + const { + originalReadFile, + originalFileExists, +@@ -123192,13 +123391,19 @@ ${lanes.join("\n")} + reloadLevel = 2 /* Full */; + scheduleProgramUpdate(); + } ++ function scheduleResolutionReload() { ++ writeLog("Clearing resolutions"); ++ resolutionCache.clear(); ++ reloadLevel = 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 (reloadLevel) { + case 1 /* Partial */: + (_a = perfLogger) == null ? void 0 : _a.logStartUpdateProgram("PartialConfigReload"); +@@ -123208,12 +123413,19 @@ ${lanes.join("\n")} + (_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() { +@@ -123499,6 +123711,7 @@ ${lanes.join("\n")} + "src/compiler/watchPublic.ts"() { + "use strict"; + init_ts2(); ++ init_pnp(); + } + }); + +@@ -128778,7 +128991,14 @@ ${lanes.join("\n")} + return false; + } + function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) { +- if (!stringContains(importedFileName, "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 (!stringContains(importedFileName, "node_modules")) { + return void 0; + } + const specifier = ts_moduleSpecifiers_exports.getNodeModulesPackageName( +@@ -129040,6 +129260,7 @@ ${lanes.join("\n")} + var init_utilities4 = __esm({ + "src/services/utilities.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + scanner = createScanner( + 99 /* Latest */, +@@ -129312,6 +129533,9 @@ ${lanes.join("\n")} + 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); +@@ -129495,6 +129719,7 @@ ${lanes.join("\n")} + var init_exportInfoMap = __esm({ + "src/services/exportInfoMap.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + ImportKind = /* @__PURE__ */ ((ImportKind2) => { + ImportKind2[ImportKind2["Named"] = 0] = "Named"; +@@ -152511,7 +152736,31 @@ ${lanes.join("\n")} + ); + } + }; +- if (fragmentDirectory && getResolvePackageJsonExports(compilerOptions)) { ++ const checkExports = (packageFile, packageDirectory, fragmentSubpath) => { ++ const packageJson = readJson(packageFile, host); ++ const exports = packageJson.exports; ++ if (exports) { ++ if (typeof exports !== "object" || exports === null) { ++ return true; ++ } ++ const keys = getOwnKeys(exports); ++ const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; ++ addCompletionEntriesFromPathsOrExports( ++ result, ++ fragmentSubpath, ++ packageDirectory, ++ extensionOptions, ++ host, ++ keys, ++ (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), ++ comparePatternKeys ++ ); ++ return true; ++ } ++ return false; ++ }; ++ const shouldCheckExports = fragmentDirectory && getResolvePackageJsonExports(compilerOptions); ++ if (shouldCheckExports) { + const nodeModulesDirectoryLookup = ancestorLookup; + ancestorLookup = (ancestor) => { + const components = getPathComponents(fragment); +@@ -152530,32 +152779,52 @@ ${lanes.join("\n")} + const packageDirectory = combinePaths(ancestor, "node_modules", packagePath); + const packageFile = combinePaths(packageDirectory, "package.json"); + if (tryFileExists(host, packageFile)) { +- const packageJson = readJson(packageFile, host); +- const exports = packageJson.exports; +- if (exports) { +- if (typeof exports !== "object" || exports === 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(exports); +- const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : ""); +- const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"]; +- addCompletionEntriesFromPathsOrExports( +- result, +- fragmentSubpath, ++ } ++ if (shouldGetCompletions) { ++ getCompletionEntriesForDirectoryFragment( ++ subPath, + packageDirectory, + extensionOptions, + host, +- keys, +- (key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)), +- comparePatternKeys ++ /*moduleSpecifierIsRelative*/ ++ false, ++ /*exclude*/ ++ void 0, ++ result + ); +- return; + } + } +- return nodeModulesDirectoryLookup(ancestor); +- }; ++ } ++ } else { ++ forEachAncestorDirectory(scriptPath, ancestorLookup); + } +- forEachAncestorDirectory(scriptPath, ancestorLookup); + } + } + return arrayFrom(result.values()); +@@ -152682,9 +152951,15 @@ ${lanes.join("\n")} + 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) { +@@ -152767,6 +153042,7 @@ ${lanes.join("\n")} + var init_stringCompletions = __esm({ + "src/services/stringCompletions.ts"() { + "use strict"; ++ init_pnp(); + init_ts4(); + init_ts_Completions(); + kindPrecedence = { +diff --git a/lib/typingsInstaller.js b/lib/typingsInstaller.js +index 9fb36b5c5..b15c24bd1 100644 +semver exclusivity >=5.1.0-beta +--- a/lib/typingsInstaller.js ++++ b/lib/typingsInstaller.js +@@ -4467,6 +4467,9 @@ var sys = (() => { + return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding); + } + function isFileSystemCaseSensitive() { ++ if (typeof process.versions.pnp !== `undefined`) { ++ return true; ++ } + if (platform === "win32" || platform === "win64") { + return false; + } +@@ -27036,6 +27039,17 @@ function specToDiagnostic(spec, disallowTrailingRecursion) { + } + } + ++// src/compiler/pnp.ts ++function getPnpApi(path2) { ++ if (typeof process.versions.pnp === "undefined") { ++ return; ++ } ++ const { findPnpApi } = require("module"); ++ if (findPnpApi) { ++ return findPnpApi(`${path2}/`); ++ } ++} ++ + // src/compiler/moduleNameResolver.ts + function trace(host) { + host.trace(formatMessage.apply(void 0, arguments)); +@@ -28506,7 +28520,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) { +@@ -28541,11 +28563,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"))) { +@@ -28779,6 +28830,18 @@ function traceIfEnabled(state, diagnostic, ...args) { + trace(state.host, diagnostic, ...args); + } + } ++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/checker.ts + var nextNodeId = 1; diff --git a/packages/plugin-compat/sources/patches/typescript.patch.ts b/packages/plugin-compat/sources/patches/typescript.patch.ts index e50ccca2fbe2..79e4f2c10446 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 e29c1f857c60..7a7739808e8c 100644 --- a/packages/yarnpkg-builder/package.json +++ b/packages/yarnpkg-builder/package.json @@ -22,7 +22,7 @@ "devDependencies": { "@types/semver": "^7.1.0", "@yarnpkg/monorepo": "workspace:^", - "typescript": "5.0.1-rc" + "typescript": "5.1.0-beta" }, "scripts": { "postpack": "rm -rf lib", diff --git a/packages/yarnpkg-doctor/package.json b/packages/yarnpkg-doctor/package.json index f1faf3c20317..c1419e633c27 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.0.1-rc" + "typescript": "5.1.0-beta" }, "devDependencies": { "@types/micromatch": "^4.0.1", diff --git a/packages/yarnpkg-fslib/sources/index.ts b/packages/yarnpkg-fslib/sources/index.ts index e4e04f5c99ee..e85125a0507a 100644 --- a/packages/yarnpkg-fslib/sources/index.ts +++ b/packages/yarnpkg-fslib/sources/index.ts @@ -6,9 +6,9 @@ export {constants}; export {errors}; export {statUtils}; -export type {LinkStrategy} from './algorithms/copyPromise'; -export {setupCopyIndex} from './algorithms/copyPromise'; -export {opendir} from './algorithms/opendir'; +export type {LinkStrategy} from './algorithms/copyPromise'; +export {setupCopyIndex} from './algorithms/copyPromise'; +export {opendir, CustomDir} from './algorithms/opendir'; export {watchFile, unwatchFile, unwatchAllFiles} from './algorithms/watchFile'; export {normalizeLineEndings} from './FakeFS'; diff --git a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js index dea375b0537a..352357a7a5bb 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js +++ b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.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/esm-loader/fspatch.ts b/packages/yarnpkg-pnp/sources/esm-loader/fspatch.ts index 443a4a232227..acf4849a0a27 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/fspatch.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/fspatch.ts @@ -1,7 +1,10 @@ -import fs from 'fs'; +import fs from 'fs'; + +import {HAS_LAZY_LOADED_TRANSLATORS} from './loaderFlags'; //#region ESM to CJS support -/* +if (!HAS_LAZY_LOADED_TRANSLATORS) { + /* In order to import CJS files from ESM Node does some translating internally[1]. This translator calls an unpatched `readFileSync`[2] which itself calls an internal `tryStatSync`[3] which calls @@ -16,34 +19,33 @@ import fs from 'fs'; 5: https://github.com/nodejs/node/pull/39513 */ -const binding = (process as any).binding(`fs`) as { - fstat: (fd: number, useBigint: false, req: any, ctx: object) => Float64Array; -}; -const originalfstat = binding.fstat; + const binding = (process as any).binding(`fs`) as { + fstat: (fd: number, useBigint: false, req: any, ctx: object) => Float64Array; + }; + const originalfstat = binding.fstat; -// Those values must be synced with packages/yarnpkg-fslib/sources/ZipOpenFS.ts -// -const ZIP_MASK = 0xff000000; -const ZIP_MAGIC = 0x2a000000; + // Those values must be synced with packages/yarnpkg-fslib/sources/ZipOpenFS.ts + const ZIP_MASK = 0xff000000; + const ZIP_MAGIC = 0x2a000000; -binding.fstat = function(...args) { - const [fd, useBigint, req] = args; - if ((fd & ZIP_MASK) === ZIP_MAGIC && useBigint === false && req === undefined) { - try { - const stats = fs.fstatSync(fd); - // The reverse of this internal util - // https://github.com/nodejs/node/blob/8886b63cf66c29d453fdc1ece2e489dace97ae9d/lib/internal/fs/utils.js#L542-L551 - return new Float64Array([ - stats.dev, - stats.mode, - stats.nlink, - stats.uid, - stats.gid, - stats.rdev, - stats.blksize, - stats.ino, - stats.size, - stats.blocks, + binding.fstat = function(...args) { + const [fd, useBigint, req] = args; + if ((fd & ZIP_MASK) === ZIP_MAGIC && useBigint === false && req === undefined) { + try { + const stats = fs.fstatSync(fd); + // The reverse of this internal util + // https://github.com/nodejs/node/blob/8886b63cf66c29d453fdc1ece2e489dace97ae9d/lib/internal/fs/utils.js#L542-L551 + return new Float64Array([ + stats.dev, + stats.mode, + stats.nlink, + stats.uid, + stats.gid, + stats.rdev, + stats.blksize, + stats.ino, + stats.size, + stats.blocks, // atime sec // atime ns // mtime sec @@ -52,10 +54,11 @@ binding.fstat = function(...args) { // ctime ns // birthtime sec // birthtime ns - ]); - } catch {} - } + ]); + } catch {} + } - return originalfstat.apply(this, args); -}; + return originalfstat.apply(this, args); + }; +} //#endregion diff --git a/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts b/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts index d430c533c53d..19cabe4f422f 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/loaderFlags.ts @@ -11,3 +11,7 @@ export const HAS_JSON_IMPORT_ASSERTION_REQUIREMENT = major > 17 || (major === 17 // The message switched to using an array in https://github.com/nodejs/node/pull/45348 export const WATCH_MODE_MESSAGE_USES_ARRAYS = major > 19 || (major === 19 && minor >= 2) || (major === 18 && minor >= 13); + +// https://github.com/nodejs/node/pull/45659 changed the internal translators to be lazy loaded +// TODO: Update the version range if https://github.com/nodejs/node/pull/46425 lands. +export const HAS_LAZY_LOADED_TRANSLATORS = major > 19 || (major === 19 && minor >= 3); diff --git a/packages/yarnpkg-types/package.json b/packages/yarnpkg-types/package.json index a7cb150f5d2b..e34a14eadde8 100644 --- a/packages/yarnpkg-types/package.json +++ b/packages/yarnpkg-types/package.json @@ -29,5 +29,8 @@ ], "engines": { "node": ">=14.15.0" + }, + "dependencies": { + "tslib": "^2.4.0" } } diff --git a/packages/yarnpkg-types/sources/index.ts b/packages/yarnpkg-types/sources/index.ts index 69f98c2386d8..fa95c33aa183 100644 --- a/packages/yarnpkg-types/sources/index.ts +++ b/packages/yarnpkg-types/sources/index.ts @@ -1,10 +1,7 @@ -import {Config} from './yarn'; +import * as Yarn from './yarn'; -// Strangely, the tslib error sometimes disappear in the IDE ... so we use ts-ignore rather than ts-expect-error -// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -// @ts-ignore: TS incorrectly thinks it needs tslib for this type export -export type * as Yarn from './yarn'; +export {Yarn}; -export function defineConfig(config: Config) { +export function defineConfig(config: Yarn.Config) { return config; } diff --git a/packages/yarnpkg-types/sources/yarn.ts b/packages/yarnpkg-types/sources/yarn.ts index 95e6ab1c2ee9..66cb690b2823 100644 --- a/packages/yarnpkg-types/sources/yarn.ts +++ b/packages/yarnpkg-types/sources/yarn.ts @@ -1,9 +1,6 @@ -// Strangely, the tslib error sometimes disappear in the IDE ... so we use ts-ignore rather than ts-expect-error -// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -// @ts-ignore: TS incorrectly thinks it needs tslib for this type export -import type * as Constraints from './constraints'; +import * as Constraints from './constraints'; -export type * as Constraints from './constraints'; +export {Constraints}; export type Config = { /** diff --git a/scripts/benchmarks/gatsby.json b/scripts/benchmarks/gatsby.json index 44783560a134..4f248f34321f 100644 --- a/scripts/benchmarks/gatsby.json +++ b/scripts/benchmarks/gatsby.json @@ -1,18 +1,7 @@ { "dependencies": { - "gatsby": "^4", - "gatsby-plugin-gatsby-cloud": "^4", - "gatsby-plugin-image": "^2", - "gatsby-plugin-manifest": "^4", - "gatsby-plugin-offline": "^5", - "gatsby-plugin-react-helmet": "^5", - "gatsby-plugin-sharp": "^4", - "gatsby-source-filesystem": "^4", - "gatsby-transformer-sharp": "^4", - "prettier": "^2", - "prop-types": "^15", + "gatsby": "^5", "react": "^18", - "react-dom": "^18", - "react-helmet": "^6" + "react-dom": "^18" } } diff --git a/scripts/benchmarks/next.json b/scripts/benchmarks/next.json index b5ac9f7b267b..293d6f1b9771 100644 --- a/scripts/benchmarks/next.json +++ b/scripts/benchmarks/next.json @@ -1,12 +1,7 @@ { - "private": true, "dependencies": { - "next": "^12", - "react": "^18", - "react-dom": "^18" - }, - "devDependencies": { - "@types/react": "^18", - "@types/react-dom": "^18" + "next": "^13", + "react": "^18", + "react-dom": "^18" } } diff --git a/yarn.lock b/yarn.lock index 4d9a8a5e811c..f4f34fe88211 100644 --- a/yarn.lock +++ b/yarn.lock @@ -6995,7 +6995,7 @@ __metadata: esbuild: "npm:esbuild-wasm@^0.15.15" semver: "npm:^7.1.2" tslib: "npm:^2.4.0" - typescript: "npm:5.0.1-rc" + typescript: "npm:5.1.0-beta" bin: builder: ./sources/boot-cli-dev.js languageName: unknown @@ -7114,7 +7114,7 @@ __metadata: micromatch: "npm:^4.0.2" p-limit: "npm:^2.2.0" tslib: "npm:^2.4.0" - typescript: "npm:5.0.1-rc" + typescript: "npm:5.1.0-beta" bin: doctor: ./sources/boot-cli-dev.js languageName: unknown @@ -7297,7 +7297,7 @@ __metadata: typedoc: "patch:typedoc@npm%3A0.17.0-3#~/.yarn/patches/typedoc-npm-0.17.0-3-0ce05847cf.patch" typedoc-neo-theme: "npm:^1.0.7" typedoc-plugin-yarn: "portal:./typedoc-plugin-yarn" - typescript: "npm:5.0.1-rc" + typescript: "npm:5.1.0-beta" unescape-html: "npm:^1.1.0" unfetch: "npm:^4.1.0" unified: "npm:^7.1.0" @@ -7356,7 +7356,7 @@ __metadata: jest: "npm:^29.2.1" pirates: "npm:^4.0.5" tslib: "npm:^2.4.0" - typescript: "npm:5.0.1-rc" + typescript: "npm:5.1.0-beta" dependenciesMeta: core-js: built: false @@ -7915,6 +7915,8 @@ __metadata: "@yarnpkg/types@workspace:^, @yarnpkg/types@workspace:packages/yarnpkg-types": version: 0.0.0-use.local resolution: "@yarnpkg/types@workspace:packages/yarnpkg-types" + dependencies: + tslib: "npm:^2.4.0" languageName: unknown linkType: soft @@ -29225,13 +29227,13 @@ pem@dexus/pem: languageName: node linkType: hard -"typescript@npm:5.0.1-rc": - version: 5.0.1-rc - resolution: "typescript@npm:5.0.1-rc" +"typescript@npm:5.1.0-beta": + version: 5.1.0-beta + resolution: "typescript@npm:5.1.0-beta" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 282f8b515bd8033b131a6e6ca17b51706bddfaf04090675d592b2c4186603e8634bd9a386f9d0292dc635e9ed62a925b00454a869c6c81fd9884de45c96bec88 + checksum: b48af60cecab067787f1743205538c07f36d489719f2240c314c736f7a9e7afa07929e38dea75bfc02467d64dd77f5eaeb465b8bff17c21805f52442b60eb8ff languageName: node linkType: hard @@ -29245,13 +29247,13 @@ pem@dexus/pem: languageName: node linkType: hard -"typescript@patch:typescript@npm%3A5.0.1-rc#optional!builtin": - version: 5.0.1-rc - resolution: "typescript@patch:typescript@npm%3A5.0.1-rc#optional!builtin::version=5.0.1-rc&hash=b5f058" +"typescript@patch:typescript@npm%3A5.1.0-beta#optional!builtin": + version: 5.1.0-beta + resolution: "typescript@patch:typescript@npm%3A5.1.0-beta#optional!builtin::version=5.1.0-beta&hash=77c9e2" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 1568732705e75508c9ea60f66d8f99bf508c4c93e73c81fafb81957ecb1d685520a58fd2d15f5f20f940a7de7f6eef939663797f90700f87ff8dd4d0b2d588dd + checksum: cf8fb58b23fb40b9c9bf4d2f2871963e32aa26bd59b58e0ba7b5bef07db98c6618f444d35768500cc2433af624ef2955b1f75591d05e2231bfb7cccb110bc8e3 languageName: node linkType: hard