From 084172577e492a673652c1c1d5eebbce04f980e1 Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Sun, 21 Aug 2022 01:13:56 +0300
Subject: [PATCH 1/2] path: add `fromURL`

---
 doc/api/path.md                     | 33 +++++++++++++++++++++++++++++
 lib/path.js                         | 13 ++++++++++++
 test/parallel/test-path-from-url.js | 29 +++++++++++++++++++++++++
 3 files changed, 75 insertions(+)
 create mode 100644 test/parallel/test-path-from-url.js

diff --git a/doc/api/path.md b/doc/api/path.md
index 0bbb5b80c57ef3..dc2801e7cc3a88 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -267,6 +267,38 @@ path.format({
 // Returns: 'C:\\path\\dir\\file.txt'
 ```
 
+## `path.fromURL(pathOrUrl)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `pathOrUrl` {string|URL}.
+* Returns: {string}
+
+Converts a [`URL`][] instance to a path string,
+returns `pathOrUrl` if it is already a string.
+
+A [`TypeError`][] is thrown if `pathOrUrl` is a
+[`URL`][] with a schema other than `file://`.
+
+```js
+path.fromURL(new URL('file:///Users/node/dev'));
+// Returns: '/Users/node/dev'
+
+path.fromURL('file:///Users/node/dev');
+// Returns: 'file:///Users/node/dev'
+
+path.fromURL(new URL('file:///c:/foo.txt'));
+// Returns On Windows: 'c:\\foo.txt'
+
+path.fromURL('index/path');
+// Returns: 'index/path'
+
+path.fromURL(new URL('http://example.com'));
+// Throws 'TypeError [ERR_INVALID_URL_SCHEME]: The URL must be of scheme file'
+```
+
 ## `path.isAbsolute(path)`
 
 <!-- YAML
@@ -604,6 +636,7 @@ The API is accessible via `require('node:path').win32` or `require('node:path/wi
 
 [MSDN-Rel-Path]: https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#fully-qualified-vs-relative-paths
 [`TypeError`]: errors.md#class-typeerror
+[`URL`]: url.md#the-whatwg-url-api
 [`path.parse()`]: #pathparsepath
 [`path.posix`]: #pathposix
 [`path.sep`]: #pathsep
diff --git a/lib/path.js b/lib/path.js
index fd95361dd02842..025957cb8305b9 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -1533,6 +1533,19 @@ const posix = {
   posix: null
 };
 
+let urlModule;
+function fromURL(fileURLOrPath) {
+  // Lazy require to avoid circular dependency
+  urlModule ??= require('internal/url');
+  if (!urlModule.isURLInstance(fileURLOrPath)) {
+    validateString(fileURLOrPath, 'fileURLOrPath');
+  }
+
+  return urlModule.toPathIfFileURL(fileURLOrPath);
+}
+
+posix.fromURL = win32.fromURL = fromURL;
+
 posix.win32 = win32.win32 = win32;
 posix.posix = win32.posix = posix;
 
diff --git a/test/parallel/test-path-from-url.js b/test/parallel/test-path-from-url.js
new file mode 100644
index 00000000000000..2ab17ca06a4086
--- /dev/null
+++ b/test/parallel/test-path-from-url.js
@@ -0,0 +1,29 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('node:assert');
+const { fromURL } = require('node:path');
+const { describe, it } = require('node:test');
+
+
+describe('path.fromURL', { concurrency: true }, () => {
+  it('should passthrough path string', () => assert
+    .strictEqual(fromURL('/Users/node/dev'), '/Users/node/dev'));
+  it('should passthrough an empty string', () => assert
+    .strictEqual(fromURL(''), ''));
+  it('should passthrough a URL string with file schema', () => assert
+    .strictEqual(fromURL('file:///Users/node/dev'), 'file:///Users/node/dev'));
+  it('should parse a URL instance with file schema', () => assert
+    .strictEqual(fromURL(new URL('file:///Users/node/dev')), '/Users/node/dev'));
+  it('should parse a URL instance with file schema', () => assert
+    .strictEqual(fromURL(new URL('file:///path/to/file')), '/path/to/file'));
+  it('should remove the host from a URL instance', () => assert
+    .strictEqual(fromURL(new URL('file://localhost/etc/fstab')), '/etc/fstab'));
+  it('should parse a windows file URI', { skip: !common.isWindows }, () => assert
+    .strictEqual(fromURL(new URL('file:///c:/foo.txt')), 'c:\\foo.txt'));
+  it('should throw an error if the URL is not a file URL', () => assert
+    .throws(() => fromURL(new URL('http://localhost/etc/fstab')), { code: 'ERR_INVALID_URL_SCHEME' }));
+  it('should throw an error if converting invalid types', () => [{}, [], 1, null, undefined,
+                                                                 Promise.resolve(new URL('file:///some/path/')), Symbol(), true, false, 1n, 0, 0n, () => {}]
+    .forEach((item) => assert.throws(() => fromURL(item), { code: 'ERR_INVALID_ARG_TYPE' })));
+});

From a0a1614ad0563ed68ceac932c67f281318b8af5f Mon Sep 17 00:00:00 2001
From: Moshe Atlow <moshe@atlow.co.il>
Date: Tue, 23 Aug 2022 09:15:00 +0300
Subject: [PATCH 2/2] CR

---
 lib/internal/url.js                 |  2 ++
 lib/path.js                         | 53 ++++++++++++++++++++++-------
 test/parallel/test-path-from-url.js |  8 +++--
 3 files changed, 48 insertions(+), 15 deletions(-)

diff --git a/lib/internal/url.js b/lib/internal/url.js
index 2a4ffefe245070..a097d852b9d364 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -1594,6 +1594,8 @@ module.exports = {
   toUSVString,
   fileURLToPath,
   pathToFileURL,
+  getPathFromURLPosix,
+  getPathFromURLWin32,
   toPathIfFileURL,
   isURLInstance,
   URL,
diff --git a/lib/path.js b/lib/path.js
index 025957cb8305b9..1d8a54e2693319 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -47,6 +47,21 @@ const {
   validateString,
 } = require('internal/validators');
 
+const {
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_URL_SCHEME,
+  },
+} = require('internal/errors');
+
+
+let urlModule;
+function lazyURLModule() {
+  // Lazy require to avoid circular dependency
+  urlModule ??= require('internal/url');
+  return urlModule;
+}
+
 const platformIsWin32 = (process.platform === 'win32');
 
 function isPathSeparator(code) {
@@ -1061,6 +1076,19 @@ const win32 = {
     return ret;
   },
 
+  fromURL(fileURLOrPath) {
+    if (typeof fileURLOrPath === 'string') {
+      return fileURLOrPath;
+    }
+    if (!lazyURLModule().isURLInstance(fileURLOrPath)) {
+      throw new ERR_INVALID_ARG_TYPE('fileURLOrPath', ['string', 'URL'], fileURLOrPath);
+    }
+    if (fileURLOrPath.protocol !== 'file:')
+      throw new ERR_INVALID_URL_SCHEME('file');
+
+    return lazyURLModule().getPathFromURLWin32(fileURLOrPath);
+  },
+
   sep: '\\',
   delimiter: ';',
   win32: null,
@@ -1527,24 +1555,25 @@ const posix = {
     return ret;
   },
 
+  fromURL(fileURLOrPath) {
+    if (typeof fileURLOrPath === 'string') {
+      return fileURLOrPath;
+    }
+    if (!lazyURLModule().isURLInstance(fileURLOrPath)) {
+      throw new ERR_INVALID_ARG_TYPE('fileURLOrPath', ['string', 'URL'], fileURLOrPath);
+    }
+    if (fileURLOrPath.protocol !== 'file:')
+      throw new ERR_INVALID_URL_SCHEME('file');
+
+    return lazyURLModule().getPathFromURLPosix(fileURLOrPath);
+  },
+
   sep: '/',
   delimiter: ':',
   win32: null,
   posix: null
 };
 
-let urlModule;
-function fromURL(fileURLOrPath) {
-  // Lazy require to avoid circular dependency
-  urlModule ??= require('internal/url');
-  if (!urlModule.isURLInstance(fileURLOrPath)) {
-    validateString(fileURLOrPath, 'fileURLOrPath');
-  }
-
-  return urlModule.toPathIfFileURL(fileURLOrPath);
-}
-
-posix.fromURL = win32.fromURL = fromURL;
 
 posix.win32 = win32.win32 = win32;
 posix.posix = win32.posix = posix;
diff --git a/test/parallel/test-path-from-url.js b/test/parallel/test-path-from-url.js
index 2ab17ca06a4086..246d2b1ccf6b8d 100644
--- a/test/parallel/test-path-from-url.js
+++ b/test/parallel/test-path-from-url.js
@@ -2,7 +2,7 @@
 
 const common = require('../common');
 const assert = require('node:assert');
-const { fromURL } = require('node:path');
+const { fromURL, win32 } = require('node:path');
 const { describe, it } = require('node:test');
 
 
@@ -19,8 +19,10 @@ describe('path.fromURL', { concurrency: true }, () => {
     .strictEqual(fromURL(new URL('file:///path/to/file')), '/path/to/file'));
   it('should remove the host from a URL instance', () => assert
     .strictEqual(fromURL(new URL('file://localhost/etc/fstab')), '/etc/fstab'));
-  it('should parse a windows file URI', { skip: !common.isWindows }, () => assert
-    .strictEqual(fromURL(new URL('file:///c:/foo.txt')), 'c:\\foo.txt'));
+  it('should parse a windows file URI', () => {
+    const fn = common.isWindows ? fromURL : win32.fromURL;
+    assert.strictEqual(fn(new URL('file:///c:/foo.txt')), 'c:\\foo.txt');
+  });
   it('should throw an error if the URL is not a file URL', () => assert
     .throws(() => fromURL(new URL('http://localhost/etc/fstab')), { code: 'ERR_INVALID_URL_SCHEME' }));
   it('should throw an error if converting invalid types', () => [{}, [], 1, null, undefined,