normalize-url 8.0.2 → 8.1.1

package/index.d.ts

@@ -278,6 +278,45 @@ export type Options = {
 	```
 	*/
 	readonly sortQueryParameters?: boolean;
+
+	/**
+	Removes the entire URL path, leaving only the domain.
+
+	@default false
+
+	@example
+	```
+	normalizeUrl('https://example.com/path/to/page', {
+		removePath: true
+	});
+	//=> 'https://example.com'
+	```
+	*/
+	readonly removePath?: boolean;
+
+	/**
+	Custom function to transform the URL path components.
+
+	The function receives an array of non-empty path components and should return a modified array.
+
+	@default false
+
+	@example
+	```
+	// Keep only the first path component
+	normalizeUrl('https://example.com/api/v1/users', {
+		transformPath: (pathComponents) => pathComponents.slice(0, 1)
+	});
+	//=> 'https://example.com/api'
+
+	// Remove specific components
+	normalizeUrl('https://example.com/admin/users', {
+		transformPath: (pathComponents) => pathComponents.filter(c => c !== 'admin')
+	});
+	//=> 'https://example.com/users'
+	```
+	*/
+	readonly transformPath?: (pathComponents: string[]) => string[];
 };
 
 /**

package/index.js

@@ -29,14 +29,12 @@ const normalizeDataURL = (urlString, {stripHash}) => {
 		throw new Error(`Invalid URL: ${urlString}`);
 	}
 
-	let {type, data, hash} = match.groups;
+	const {type, data, hash} = match.groups;
 	const mediaType = type.split(';');
-	hash = stripHash ? '' : hash;
 
-	let isBase64 = false;
-	if (mediaType[mediaType.length - 1] === 'base64') {
+	const isBase64 = mediaType.at(-1) === 'base64';
+	if (isBase64) {
 		mediaType.pop();
-		isBase64 = true;
 	}
 
 	// Lowercase MIME type
@@ -58,9 +56,7 @@ const normalizeDataURL = (urlString, {stripHash}) => {
 		})
 		.filter(Boolean);
 
-	const normalizedMediaType = [
-		...attributes,
-	];
+	const normalizedMediaType = [...attributes];
 
 	if (isBase64) {
 		normalizedMediaType.push('base64');
@@ -70,7 +66,8 @@ const normalizeDataURL = (urlString, {stripHash}) => {
 		normalizedMediaType.unshift(mimeType);
 	}
 
-	return `data:${normalizedMediaType.join(';')},${isBase64 ? data.trim() : data}${hash ? `#${hash}` : ''}`;
+	const hashPart = stripHash || !hash ? '' : `#${hash}`;
+	return `data:${normalizedMediaType.join(';')},${isBase64 ? data.trim() : data}${hashPart}`;
 };
 
 export default function normalizeUrl(urlString, options) {
@@ -89,6 +86,8 @@ export default function normalizeUrl(urlString, options) {
 		removeDirectoryIndex: false,
 		removeExplicitPort: false,
 		sortQueryParameters: true,
+		removePath: false,
+		transformPath: false,
 		...options,
 	};
 
@@ -191,15 +190,27 @@ export default function normalizeUrl(urlString, options) {
 	}
 
 	if (Array.isArray(options.removeDirectoryIndex) && options.removeDirectoryIndex.length > 0) {
-		let pathComponents = urlObject.pathname.split('/');
-		const lastComponent = pathComponents[pathComponents.length - 1];
+		const pathComponents = urlObject.pathname.split('/').filter(Boolean);
+		const lastComponent = pathComponents.at(-1);
 
-		if (testParameter(lastComponent, options.removeDirectoryIndex)) {
-			pathComponents = pathComponents.slice(0, -1);
-			urlObject.pathname = pathComponents.slice(1).join('/') + '/';
+		if (lastComponent && testParameter(lastComponent, options.removeDirectoryIndex)) {
+			pathComponents.pop();
+			urlObject.pathname = pathComponents.length > 0 ? `/${pathComponents.join('/')}/` : '/';
 		}
 	}
 
+	// Remove path
+	if (options.removePath) {
+		urlObject.pathname = '/';
+	}
+
+	// Transform path components
+	if (options.transformPath && typeof options.transformPath === 'function') {
+		const pathComponents = urlObject.pathname.split('/').filter(Boolean);
+		const newComponents = options.transformPath(pathComponents);
+		urlObject.pathname = newComponents?.length > 0 ? `/${newComponents.join('/')}` : '/';
+	}
+
 	if (urlObject.hostname) {
 		// Remove trailing dot
 		urlObject.hostname = urlObject.hostname.replace(/\.$/, '');
@@ -240,12 +251,21 @@ export default function normalizeUrl(urlString, options) {
 
 	// Sort query parameters
 	if (options.sortQueryParameters) {
+		const originalSearch = urlObject.search;
 		urlObject.searchParams.sort();
 
 		// Calling `.sort()` encodes the search parameters, so we need to decode them again.
 		try {
 			urlObject.search = decodeURIComponent(urlObject.search);
 		} catch {}
+
+		// Fix parameters that originally had no equals sign but got one added by URLSearchParams
+		const partsWithoutEquals = originalSearch.slice(1).split('&').filter(p => p && !p.includes('='));
+		for (const part of partsWithoutEquals) {
+			const decoded = decodeURIComponent(part);
+			// Only replace at word boundaries to avoid partial matches
+			urlObject.search = urlObject.search.replace(`?${decoded}=`, `?${decoded}`).replace(`&${decoded}=`, `&${decoded}`);
+		}
 	}
 
 	if (options.removeTrailingSlash) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "normalize-url",
-	"version": "8.0.2",
+	"version": "8.1.1",
 	"description": "Normalize a URL",
 	"license": "MIT",
 	"repository": "sindresorhus/normalize-url",

package/readme.md

@@ -307,6 +307,41 @@ normalizeUrl('www.sindresorhus.com?b=two&a=one&c=three', {
 //=> 'http://sindresorhus.com/?b=two&a=one&c=three'
 ```
 
+##### removePath
+
+Type: `boolean`\
+Default: `false`
+
+Removes the entire URL path, leaving only the domain.
+
+```js
+normalizeUrl('https://example.com/path/to/page', {
+	removePath: true
+});
+//=> 'https://example.com'
+```
+
+##### transformPath
+
+Type: `Function`\
+Default: `false`
+
+Custom function to transform the URL path components. The function receives an array of non-empty path components and should return a modified array.
+
+```js
+// Keep only the first path component
+normalizeUrl('https://example.com/api/v1/users', {
+	transformPath: (pathComponents) => pathComponents.slice(0, 1)
+});
+//=> 'https://example.com/api'
+
+// Remove specific components
+normalizeUrl('https://example.com/admin/users', {
+	transformPath: (pathComponents) => pathComponents.filter(c => c !== 'admin')
+});
+//=> 'https://example.com/users'
+```
+
 ## Related
 
 - [compare-urls](https://github.com/sindresorhus/compare-urls) - Compare URLs by first normalizing them