Update "src/utils/url"

Author: minimal-ui-kit

packages/minimal-shared/src/utils/url/url.test.ts

@@ -1,78 +1,75 @@
-import { highlightText } from '../../../tests/highlight-text';
 import { hasParams, isEqualPath, removeParams, isExternalLink, removeLastSlash } from './url';
 
 // ----------------------------------------------------------------------
 
-describe('hasParams()', () => {
-  it(`1. Should return ${highlightText.val('true')} if URL has query parameters`, () => {
-    expect(hasParams('https://example.com?page=1')).toBe(true);
-  });
+const mapWithIndex = <T extends readonly any[][]>(cases: T) =>
+  cases.map((testCase, index) => [index + 1, ...testCase] as const);
 
-  it(`2. Should return ${highlightText.val('false')} if URL does not have query parameters`, () => {
-    expect(hasParams('https://example.com')).toBe(false);
-  });
+describe('hasParams()', () => {
+  const cases = [
+    ['Should return true with single param', '/dashboard?page=1', true],
+    ['Should return true with multiple params', '/dashboard?x=1&y=2', true],
+    ['Should return false with no params', '/dashboard', false],
+    ['Should return false with trailing "?"', '/dashboard?', false],
+    ['Should return false for empty string', '', false],
+  ];
 
-  it(`3. Should return ${highlightText.val('false')} if URL has empty query parameters`, () => {
-    expect(hasParams('https://example.com?')).toBe(false);
+  test.each(mapWithIndex(cases))('%i. %s', (_i, _desc, input, expected) => {
+    expect(hasParams(input)).toBe(expected);
   });
 });
 
 describe('removeLastSlash()', () => {
-  it(`1. Should remove trailing slash from pathname`, () => {
-    expect(removeLastSlash('/dashboard/calendar/')).toBe('/dashboard/calendar');
-  });
+  const cases = [
+    ['Removes trailing slash', '/dashboard/', '/dashboard'],
+    ['Keeps path without slash', '/dashboard', '/dashboard'],
+    ['Removes slash from nested path', '/dashboard/user/', '/dashboard/user'],
+    ['Preserves root slash', '/', '/'],
+    ['Removes extra trailing slashes', '/test//', '/test/'],
+  ];
 
-  it(`2. Should return the same pathname if there is no trailing slash`, () => {
-    expect(removeLastSlash('/dashboard/calendar')).toBe('/dashboard/calendar');
-  });
-
-  it(`3. Should not remove the slash if pathname is just "/"`, () => {
-    expect(removeLastSlash('/')).toBe('/');
+  test.each(mapWithIndex(cases))('%i. %s', (_i, _desc, input, expected) => {
+    expect(removeLastSlash(input)).toBe(expected);
   });
 });
 
 describe('isEqualPath()', () => {
-  it(`1. Should return true if both paths are equal after removing trailing slashes`, () => {
-    expect(isEqualPath('/dashboard/calendar/', '/dashboard/calendar/')).toBe(true);
-  });
+  const cases = [
+    ['Exact match', '/dashboard', '/dashboard', true],
+    ['Match with trailing slash', '/dashboard/', '/dashboard', true],
+    ['Both paths have trailing slashes', '/dashboard/', '/dashboard/', true],
+    ['Different paths', '/dashboard', '/settings', false],
+  ];
 
-  it(`2. Should return true if both paths are equal after removing trailing slashes`, () => {
-    expect(isEqualPath('/dashboard/calendar', '/dashboard/calendar/')).toBe(true);
+  test.each(mapWithIndex(cases))('%i. %s', (_i, _desc, a, b, expected) => {
+    expect(isEqualPath(a, b)).toBe(expected);
   });
 });
 
 describe('removeParams()', () => {
-  it(`1. Should remove query parameters from URL`, () => {
-    expect(removeParams('https://example.com/page?param=value')).toBe('/page');
-  });
+  const cases = [
+    ['Removes simple query', '/dashboard?page=1', '/dashboard'],
+    ['Removes complex query', '/dashboard/user?id=123&filter=active', '/dashboard/user'],
+    ['Ignores when no query', '/dashboard/user', '/dashboard/user'],
+    ['Removes query with trailing slash', '/dashboard/user/?id=1', '/dashboard/user'],
+    ['Removes query from full URL', 'https://example.com/page?id=1', '/page'],
+  ];
 
-  it(`2. Should return the same URL if there are no query parameters`, () => {
-    expect(removeParams('https://example.com/page')).toBe('/page');
-  });
-
-  it(`3. Should return the same URL if there are no query parameters`, () => {
-    expect(removeParams('https://example.com/')).toBe('/');
-  });
-
-  it(`4. Should return the same URL if there are no query parameters`, () => {
-    expect(removeParams('https://example.com')).toBe('/');
-  });
-
-  it(`5. Should return the same URL if it is invalid`, () => {
-    expect(removeParams('invalid-url')).toBe('/invalid-url');
+  test.each(mapWithIndex(cases))('%i. %s', (_i, _desc, input, expected) => {
+    expect(removeParams(input)).toBe(expected);
   });
 });
 
 describe('isExternalLink()', () => {
-  it(`1. Should return ${highlightText.val('true')} if URL is an external link`, () => {
-    expect(isExternalLink('https://example.com')).toBe(true);
-  });
-
-  it(`2. Should return ${highlightText.val('false')} if URL is not an external link`, () => {
-    expect(isExternalLink('/internal/page')).toBe(false);
-  });
-
-  it(`3. Should return ${highlightText.val('true')} if URL starts with http`, () => {
-    expect(isExternalLink('http://example.com')).toBe(true);
+  const cases = [
+    ['Detects http link', 'http://example.com', true],
+    ['Detects https link', 'https://example.com', true],
+    ['Returns false for local path', '/dashboard', false],
+    ['Returns false for anchor', '#section', false],
+    ['Does not false-positive on "http123"', 'http123', false],
+  ];
+
+  test.each(mapWithIndex(cases))('%i. %s', (_i, _desc, input, expected) => {
+    expect(isExternalLink(input)).toBe(expected);
   });
 });

packages/minimal-shared/src/utils/url/url.ts

@@ -1,56 +1,52 @@
 /**
  * Checks if a URL has query parameters.
  *
- * @param {string} url - The URL to check.
- * @returns {boolean} - True if the URL has query parameters, false otherwise.
+ * @param url - The URL to check.
+ * @returns True if the URL has query parameters, false otherwise.
  *
  * @example
- * const hasQueryParams = hasParams('https://example.com?page=1');
- * console.log(hasQueryParams); // true
+ * hasParams('https://example.com?page=1'); // true
+ * hasParams('https://example.com'); // false
  */
-
-export const hasParams = (url: string): boolean => {
-  const queryString = url.split('?')[1];
-  return queryString ? new URLSearchParams(queryString).toString().length > 0 : false;
-};
+export function hasParams(url: string): boolean {
+  try {
+    const urlObj = new URL(url, window.location.origin);
+    return Array.from(urlObj.searchParams.keys()).length > 0;
+  } catch {
+    return false;
+  }
+}
 
 // ----------------------------------------------------------------------
 
 /**
- * Removes the trailing slash from a pathname if it exists.
+ * Removes the trailing slash from a pathname if present.
  *
- * @param {string} pathname - The pathname to process.
- * @returns {string} - The pathname without the trailing slash.
+ * @param pathname - The pathname to process.
+ * @returns The pathname without the trailing slash.
  *
  * @example
- * const cleanPathname = removeLastSlash('/dashboard/calendar/');
- * console.log(cleanPathname); // '/dashboard/calendar'
+ * removeLastSlash('/dashboard/'); // '/dashboard'
+ * removeLastSlash('/dashboard'); // '/dashboard'
  */
 export function removeLastSlash(pathname: string): string {
-  /**
-   * Remove last slash
-   * [1]
-   * @input  = '/dashboard/calendar/'
-   * @output = '/dashboard/calendar'
-   * [2]
-   * @input  = '/dashboard/calendar'
-   * @output = '/dashboard/calendar'
-   */
-  if (pathname !== '/' && pathname.endsWith('/')) {
-    return pathname.slice(0, -1);
-  }
+  const isValid = pathname !== '/' && pathname.endsWith('/');
 
-  return pathname;
+  return isValid ? pathname.slice(0, -1) : pathname;
 }
 
 // ----------------------------------------------------------------------
 
 /**
- * Checks if two URLs have the same path.
+ * Checks if two paths are equal after removing trailing slashes.
+ *
+ * @param targetUrl - The target URL to compare.
+ * @param pathname - The pathname to compare.
+ * @returns True if the paths are equal, false otherwise.
  *
- * @param {string} targetUrl - The target URL to compare.
- * @param {string} pathname - The pathname to compare.
- * @returns {boolean} - True if the paths are equal, false otherwise.
+ * @example
+ * isEqualPath('/dashboard/', '/dashboard'); // true
+ * isEqualPath('/home', '/dashboard'); // false
  */
 export function isEqualPath(targetUrl: string, pathname: string): boolean {
   return removeLastSlash(targetUrl) === removeLastSlash(pathname);
@@ -59,16 +55,15 @@ export function isEqualPath(targetUrl: string, pathname: string): boolean {
 // ----------------------------------------------------------------------
 
 /**
- * Removes query parameters from a URL.
+ * Removes query parameters from a URL and returns only the cleaned pathname.
  *
- * @param {string} url - The URL to process.
- * @returns {string} - The URL without query parameters.
+ * @param url - The URL to process.
+ * @returns The pathname without query parameters.
  *
  * @example
- * const cleanUrl = removeParams('https://example.com/page?param=value');
- * console.log(cleanUrl); // 'https://example.com/page'
+ * removeParams('https://example.com/dashboard/user?id=123'); // '/dashboard/user'
+ * removeParams('/dashboard/user?id=123'); // '/dashboard/user'
  */
-
 export function removeParams(url: string): string {
   try {
     const urlObj = new URL(url, window.location.origin);
@@ -82,16 +77,15 @@ export function removeParams(url: string): string {
 // ----------------------------------------------------------------------
 
 /**
- * Checks if a URL is an external link.
+ * Determines whether a given URL is external (i.e., starts with "http").
  *
- * @param {string} url - The URL to check.
- * @returns {boolean} - True if the URL is an external link, false otherwise.
+ * @param url - The URL to check.
+ * @returns True if the URL is external, false otherwise.
  *
  * @example
- * const isExternal = isExternalLink('https://example.com');
- * console.log(isExternal); // true
+ * isExternalLink('https://example.com'); // true
+ * isExternalLink('/internal'); // false
  */
-
 export function isExternalLink(url: string): boolean {
-  return url.startsWith('http');
+  return /^https?:\/\//i.test(url);
 }