@sumaris-net/ngx-components 18.12.4 → 18.12.6

package/doc/changelog.md

@@ -1438,7 +1438,7 @@ enh: Environment: add useHash property to configure Angular router to use hash U
 - enh(inputs) `canHaveFocus()`: add `isNotEmpty` option 
 
 # 18.12.2
-- enh(MapPipe) Allow to pass arguments to the `map` pipe (e.g. `value | map: displayFn: ['label', 'name']` will call `displayFn(value, ['label', 'name']`) 
+- enh(MapPipe) Allow to pass arguments to the `map` pipe (e.g. `value | map: converToSomething: 'arg2'` will call `converToSomething(value, 'arg2'`) 
 
 # 18.12.3
 - enh(AppTable, AppAsyncTable) FUnction `trackFn()` can now return `any` (instead of `number`) - like the official Angular `TrackByFunction`
@@ -1446,3 +1446,9 @@ enh: Environment: add useHash property to configure Angular router to use hash U
 # 18.12.4
 - enh(deps) Fix version of webpack
 - enh(deps) Upgrade ngx-material-table into 18.0.4
+
+# 18.12.5
+- enh(functions) Add function `UrlUtils.appendQueryParams()` to append q queryParams (as a map) to an url
+
+# 18.12.6
+- enh(functions) Allow `UrlUtils.appendQueryParams()` to get url as `string | any[]` 

package/esm2022/src/app/shared/file/url.utils.mjs

@@ -1,4 +1,4 @@
-import { isNilOrBlank } from '../functions';
+import { isNilOrBlank, isNotNil } from '../functions';
 export class UrlUtils {
     /**
      * Determines if a given URL is a relative URL.
@@ -65,7 +65,7 @@ export class UrlUtils {
         if (!relativePath)
             throw new Error("Missing 'relativePath' argument");
         if (!this.isRelativeUrl(relativePath))
-            throw new Error("Should be a relative path");
+            throw new Error('Should be a relative path');
         // Detect absolute URL
         if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {
             baseUrl = this.getRootUrl(baseUrl);
@@ -93,6 +93,37 @@ export class UrlUtils {
         }, [])
             .join('/');
     }
+    /**
+     * This function completes a base URL with an object containing key-value pairs
+     * representing the query parameters to add. It properly encodes the
+     * parameters and ensures they are added with the appropriate separator ('?' or '&').
+     * Parameters with null or undefined values are automatically filtered out.
+     *
+     * @example
+     * // In a template
+     * <a [href]="'https://example.com' | appendQueryParams:{id: 123, name: 'test'}">Link</a>
+     * // Result: https://example.com?id=123&name=test
+     *
+     * @example
+     * // If the URL already contains parameters
+     * <a [href]="'https://example.com?page=1' | appendQueryParams:{sort: 'asc'}">Link</a>
+     * // Result: https://example.com?page=1&sort=asc
+     *
+     * @param url
+     * @param queryParams
+     */
+    static appendQueryParams(url, queryParams) {
+        const urlStr = typeof url === 'string' ? url : this.addStartingSlash(url.join('/'));
+        if (isNilOrBlank(urlStr) || !queryParams)
+            return urlStr;
+        const queryString = Object.entries(queryParams)
+            .filter(([_, value]) => isNotNil(value))
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('&');
+        if (isNilOrBlank(queryString))
+            return urlStr;
+        return urlStr + (urlStr.includes('?') ? '&' : '?') + queryString;
+    }
     /**
      * Extracts and returns the root URL from the given complete URL string.
      *
@@ -161,4 +192,4 @@ export class UrlUtils {
         return this.addTrailingSlash(basePath) + this.removeStartingSlash(relativePath);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/url.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,MAAM,OAAgB,QAAQ;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,IAAmB;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACxB,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC5H,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,IAAmB;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACxB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC7E,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,IAAmB;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QACxB,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,GAAW;QAC3B,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,qBAAqB,CAAC,GAAW;QACtC,IAAI,CAAC,GAAG;YAAE,OAAO,GAAG,CAAC;QACrB,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,GAAW;QAC5B,IAAI,YAAY,CAAC,GAAG,CAAC;YAAE,OAAO,EAAE,CAAC;QAEjC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC/B,CAAC;IAED,MAAM,CAAC,kBAAkB,CAAC,OAAe,EAAE,YAAoB,EAAE,IAAmC;QAClG,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY;YAAE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAEpF,sBAAsB;QACtB,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAC/F,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CAAC,GAAW;QAC7B,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;aACtB,KAAK,CAAC,GAAG,CAAC;aACV,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;YACpB,IAAI,IAAI,KAAK,GAAG;gBAAE,OAAO,GAAG,CAAC;YAC7B,IAAI,IAAI,KAAK,IAAI,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;gBAAE,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC7D,OAAO,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC,EAAE,EAAE,CAAC;aACL,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,GAAW;QAC3B,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,IAAI,YAAY,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,GAAG,EAAE,CAAC,CAAC;QACnF,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,OAAO,GAAG,QAAQ,KAAK,WAAW,EAAE,CAAC;IACvC,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,SAAS,CAAC,GAAW;QAC1B,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC;QACjD,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,QAAQ,CAAC,CAAC,qCAAqC;QAClF,MAAM,UAAU,GAAG,QAAQ,GAAG,GAAG,GAAG,IAAI,CAAC;QACzC,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAY;QAC1B,IAAI,CAAC;YACH,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9C,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,GAAW;QACjC,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,GAAW;QACjC,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC;IAC/C,CAAC;IAED,MAAM,CAAC,mBAAmB,CAAC,GAAW;QACpC,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IACtD,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,QAAgB,EAAE,YAAoB;QAClD,IAAI,CAAC,QAAQ;YAAE,OAAO,YAAY,CAAC;QACnC,IAAI,CAAC,YAAY;YAAE,OAAO,QAAQ,CAAC;QACnC,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAClF,CAAC;CACF","sourcesContent":["import { isNilOrBlank } from '../functions';\n\nexport abstract class UrlUtils {\n  /**\n   * Determines if a given URL is a relative URL.\n   *\n   * @param {string | null} href - The URL to check.\n   * @return {boolean} True if the URL is relative, false otherwise.\n   */\n  static isRelativeUrl(href: string | null): boolean {\n    if (!href) return false;\n    return !href.startsWith('http:') && !href.startsWith('https:') && !href.startsWith('mailto:') && !href.startsWith('tel:');\n  }\n\n  /**\n   * Determines if a given URL is an internal URL.\n   *\n   * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.\n   * @return {boolean} Returns true if the URL is internal, otherwise false.\n   */\n  static isInternalUrl(href: string | null): boolean {\n    if (!href) return false;\n    return href.startsWith(window.location.origin) || this.isRelativeUrl(href);\n  }\n\n  static isExternalUrl(href: string | null): boolean {\n    if (!href) return false;\n    return !this.isInternalUrl(href);\n  }\n\n  /**\n   * Removes the query string from the given URL, returning only the base URL.\n   *\n   * @param {string} url - The URL from which the query string will be stripped.\n   * @return {string} The URL without the query string.\n   */\n  static stripQuery(url: string): string {\n    return /[^?]*/.exec(url)[0];\n  }\n\n  /**\n   * Removes the fragment and query components from a given URL string.\n   *\n   * @param {string} url - The URL string to process.\n   * @return {string} The URL without its fragment and query components.\n   */\n  static stripFragmentAndQuery(url: string): string {\n    if (!url) return url;\n    return this.stripQuery(/[^#]*/.exec(url)[0]);\n  }\n\n  /**\n   * Extracts the fragment identifier from the given URL.\n   *\n   * @param {string} url - The URL from which to extract the fragment.\n   * @return {string} The fragment identifier of the URL, excluding the '#' symbol.\n   */\n  static getFragment(url: string): string {\n    if (isNilOrBlank(url)) return '';\n\n    const match = url.match(/#(.*)$/);\n    return match ? match[1] : '';\n  }\n\n  static resolveRelativeUrl(baseUrl: string, relativePath: string, opts?: {absoluteByDefault: boolean}): string {\n    if (!baseUrl) throw new Error(\"Missing 'baseUrl' argument\");\n    if (!relativePath) throw new Error(\"Missing 'relativePath' argument\");\n    if (!this.isRelativeUrl(relativePath)) throw new Error(\"Should be a relative path\");\n\n    // Detect absolute URL\n    if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {\n      baseUrl = this.getRootUrl(baseUrl);\n    }\n\n    return UrlUtils.normalizeUrl(UrlUtils.concat(baseUrl, relativePath));\n  }\n\n  /**\n   * Resolves a given URL by normalizing its parts, removing unnecessary path segments like \".\" and \"..\".\n   *\n   * @param {string} url - The URL to be resolved. Must be a non-empty string.\n   * @return {string} The resolved and cleaned URL string.\n   * @throws {Error} If the provided URL is missing or undefined.\n   */\n  static normalizeUrl(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    return this.cleanUrl(url)\n      .split('/')\n      .reduce((res, part) => {\n        if (part === '.') return res;\n        if (part === '..' && res.length > 0) return res.slice(0, -1);\n        return res.concat(part);\n      }, [])\n      .join('/');\n  }\n\n  /**\n   * Extracts and returns the root URL from the given complete URL string.\n   *\n   * @param {string} url - The complete URL string from which the root URL will be extracted.\n   * @return {string} The root URL including the protocol and host (and port if present).\n   * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.\n   */\n  static getRootUrl(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    let [protocol, path] = url.split('//', 2);\n    if (!protocol || isNilOrBlank(path)) throw new Error(`Invalid URL format: ${url}`);\n    const hostAndPort = path.split('/', 2)[0];\n    return `${protocol}//${hostAndPort}`;\n  }\n\n  /**\n   * Retrieves the parent URL or directory path from the provided URL.\n   * This method handles both relative and absolute URLs.\n   *\n   * @param {string} url - The URL from which to derive the parent path.\n   *                       Must be a valid URL or relative path.\n   * @return {string} The parent URL or directory path. Throws an error if the input is invalid.\n   */\n  static getParent(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    const cleanUrl = this.stripFragmentAndQuery(url);\n    if (cleanUrl.endsWith('/')) return cleanUrl; // Skip if already a parent directory\n    const parentPath = cleanUrl + '/' + '..';\n    if (this.isRelativeUrl(url)) {\n      return this.resolveRelativeUrl(window.location.href, parentPath);\n    }\n    return this.normalizeUrl(parentPath);\n  }\n\n  /**\n   * Cleans the provided URL by encoding it safely and replacing specific patterns.\n   *\n   * @param {string} href - The URL string to be cleaned.\n   * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.\n   */\n  static cleanUrl(href: string): string {\n    try {\n      href = encodeURI(href).replace(/%25/g, '%');\n    } catch (e) {\n      return null;\n    }\n    return href;\n  }\n\n  static addTrailingSlash(url: string): string {\n    return url.endsWith('/') ? url : url + '/';\n  }\n\n  static addStartingSlash(url: string): string {\n    return url.startsWith('/') ? url : '/' + url;\n  }\n\n  static removeStartingSlash(url: string): string {\n    return url.startsWith('/') ? url.substring(1) : url;\n  }\n\n  static concat(basePath: string, relativePath: string): string {\n    if (!basePath) return relativePath;\n    if (!relativePath) return basePath;\n    return this.addTrailingSlash(basePath) + this.removeStartingSlash(relativePath);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"url.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/file/url.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNilOrBlank, isNotNil } from '../functions';\n\nexport abstract class UrlUtils {\n  /**\n   * Determines if a given URL is a relative URL.\n   *\n   * @param {string | null} href - The URL to check.\n   * @return {boolean} True if the URL is relative, false otherwise.\n   */\n  static isRelativeUrl(href: string | null): boolean {\n    if (!href) return false;\n    return !href.startsWith('http:') && !href.startsWith('https:') && !href.startsWith('mailto:') && !href.startsWith('tel:');\n  }\n\n  /**\n   * Determines if a given URL is an internal URL.\n   *\n   * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.\n   * @return {boolean} Returns true if the URL is internal, otherwise false.\n   */\n  static isInternalUrl(href: string | null): boolean {\n    if (!href) return false;\n    return href.startsWith(window.location.origin) || this.isRelativeUrl(href);\n  }\n\n  static isExternalUrl(href: string | null): boolean {\n    if (!href) return false;\n    return !this.isInternalUrl(href);\n  }\n\n  /**\n   * Removes the query string from the given URL, returning only the base URL.\n   *\n   * @param {string} url - The URL from which the query string will be stripped.\n   * @return {string} The URL without the query string.\n   */\n  static stripQuery(url: string): string {\n    return /[^?]*/.exec(url)[0];\n  }\n\n  /**\n   * Removes the fragment and query components from a given URL string.\n   *\n   * @param {string} url - The URL string to process.\n   * @return {string} The URL without its fragment and query components.\n   */\n  static stripFragmentAndQuery(url: string): string {\n    if (!url) return url;\n    return this.stripQuery(/[^#]*/.exec(url)[0]);\n  }\n\n  /**\n   * Extracts the fragment identifier from the given URL.\n   *\n   * @param {string} url - The URL from which to extract the fragment.\n   * @return {string} The fragment identifier of the URL, excluding the '#' symbol.\n   */\n  static getFragment(url: string): string {\n    if (isNilOrBlank(url)) return '';\n\n    const match = url.match(/#(.*)$/);\n    return match ? match[1] : '';\n  }\n\n  static resolveRelativeUrl(baseUrl: string, relativePath: string, opts?: { absoluteByDefault: boolean }): string {\n    if (!baseUrl) throw new Error(\"Missing 'baseUrl' argument\");\n    if (!relativePath) throw new Error(\"Missing 'relativePath' argument\");\n    if (!this.isRelativeUrl(relativePath)) throw new Error('Should be a relative path');\n\n    // Detect absolute URL\n    if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {\n      baseUrl = this.getRootUrl(baseUrl);\n    }\n\n    return UrlUtils.normalizeUrl(UrlUtils.concat(baseUrl, relativePath));\n  }\n\n  /**\n   * Resolves a given URL by normalizing its parts, removing unnecessary path segments like \".\" and \"..\".\n   *\n   * @param {string} url - The URL to be resolved. Must be a non-empty string.\n   * @return {string} The resolved and cleaned URL string.\n   * @throws {Error} If the provided URL is missing or undefined.\n   */\n  static normalizeUrl(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    return this.cleanUrl(url)\n      .split('/')\n      .reduce((res, part) => {\n        if (part === '.') return res;\n        if (part === '..' && res.length > 0) return res.slice(0, -1);\n        return res.concat(part);\n      }, [])\n      .join('/');\n  }\n\n  /**\n   * This function completes a base URL with an object containing key-value pairs\n   * representing the query parameters to add. It properly encodes the\n   * parameters and ensures they are added with the appropriate separator ('?' or '&').\n   * Parameters with null or undefined values are automatically filtered out.\n   *\n   * @example\n   * // In a template\n   * <a [href]=\"'https://example.com' | appendQueryParams:{id: 123, name: 'test'}\">Link</a>\n   * // Result: https://example.com?id=123&name=test\n   *\n   * @example\n   * // If the URL already contains parameters\n   * <a [href]=\"'https://example.com?page=1' | appendQueryParams:{sort: 'asc'}\">Link</a>\n   * // Result: https://example.com?page=1&sort=asc\n   *\n   * @param url\n   * @param queryParams\n   */\n  static appendQueryParams(url: string | any[], queryParams: { [key: string]: any }): string {\n    const urlStr = typeof url === 'string' ? url : this.addStartingSlash(url.join('/'));\n    if (isNilOrBlank(urlStr) || !queryParams) return urlStr;\n    const queryString = Object.entries(queryParams)\n      .filter(([_, value]) => isNotNil(value))\n      .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)\n      .join('&');\n    if (isNilOrBlank(queryString)) return urlStr;\n    return urlStr + (urlStr.includes('?') ? '&' : '?') + queryString;\n  }\n\n  /**\n   * Extracts and returns the root URL from the given complete URL string.\n   *\n   * @param {string} url - The complete URL string from which the root URL will be extracted.\n   * @return {string} The root URL including the protocol and host (and port if present).\n   * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.\n   */\n  static getRootUrl(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    let [protocol, path] = url.split('//', 2);\n    if (!protocol || isNilOrBlank(path)) throw new Error(`Invalid URL format: ${url}`);\n    const hostAndPort = path.split('/', 2)[0];\n    return `${protocol}//${hostAndPort}`;\n  }\n\n  /**\n   * Retrieves the parent URL or directory path from the provided URL.\n   * This method handles both relative and absolute URLs.\n   *\n   * @param {string} url - The URL from which to derive the parent path.\n   *                       Must be a valid URL or relative path.\n   * @return {string} The parent URL or directory path. Throws an error if the input is invalid.\n   */\n  static getParent(url: string): string {\n    if (!url) throw new Error(\"Missing 'url' argument\");\n    const cleanUrl = this.stripFragmentAndQuery(url);\n    if (cleanUrl.endsWith('/')) return cleanUrl; // Skip if already a parent directory\n    const parentPath = cleanUrl + '/' + '..';\n    if (this.isRelativeUrl(url)) {\n      return this.resolveRelativeUrl(window.location.href, parentPath);\n    }\n    return this.normalizeUrl(parentPath);\n  }\n\n  /**\n   * Cleans the provided URL by encoding it safely and replacing specific patterns.\n   *\n   * @param {string} href - The URL string to be cleaned.\n   * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.\n   */\n  static cleanUrl(href: string): string {\n    try {\n      href = encodeURI(href).replace(/%25/g, '%');\n    } catch (e) {\n      return null;\n    }\n    return href;\n  }\n\n  static addTrailingSlash(url: string): string {\n    return url.endsWith('/') ? url : url + '/';\n  }\n\n  static addStartingSlash(url: string): string {\n    return url.startsWith('/') ? url : '/' + url;\n  }\n\n  static removeStartingSlash(url: string): string {\n    return url.startsWith('/') ? url.substring(1) : url;\n  }\n\n  static concat(basePath: string, relativePath: string): string {\n    if (!basePath) return relativePath;\n    if (!relativePath) return basePath;\n    return this.addTrailingSlash(basePath) + this.removeStartingSlash(relativePath);\n  }\n}\n"]}

package/esm2022/src/app/shared/pipes/url.pipes.mjs

@@ -1,5 +1,5 @@
 import { Pipe } from '@angular/core';
-import { isNilOrBlank, isNotNil } from '../functions';
+import { UrlUtils } from '../file/url.utils';
 import * as i0 from "@angular/core";
 /**
  * Pipe permettant d'ajouter des paramètres de requête à une URL.
@@ -21,15 +21,7 @@ import * as i0 from "@angular/core";
  */
 export class AppendQueryParamsPipePipe {
     transform(url, queryParams) {
-        if (isNilOrBlank(url) || !queryParams)
-            return url;
-        let queryString = Object.entries(queryParams)
-            .filter(([_, value]) => isNotNil(value))
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('&');
-        if (isNilOrBlank(queryString))
-            return url;
-        return url + (url.includes('?') ? '&' : '?') + queryString;
+        return UrlUtils.appendQueryParams(url, queryParams);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppendQueryParamsPipePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
     static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AppendQueryParamsPipePipe, name: "appendQueryParams" });
@@ -40,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                     name: 'appendQueryParams',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXJsLnBpcGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9zaGFyZWQvcGlwZXMvdXJsLnBpcGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBQ3BELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFFN0M7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBaUJHO0FBSUgsTUFBTSxPQUFPLHlCQUF5QjtJQUNwQyxTQUFTLENBQUMsR0FBVyxFQUFFLFdBQW1DO1FBQ3hELE9BQU8sUUFBUSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN0RCxDQUFDO3dHQUhVLHlCQUF5QjtzR0FBekIseUJBQXlCOzs0RkFBekIseUJBQXlCO2tCQUhyQyxJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxtQkFBbUI7aUJBQzFCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVXJsVXRpbHMgfSBmcm9tICcuLi9maWxlL3VybC51dGlscyc7XG5cbi8qKlxuICogUGlwZSBwZXJtZXR0YW50IGQnYWpvdXRlciBkZXMgcGFyYW3DqHRyZXMgZGUgcmVxdcOqdGUgw6AgdW5lIFVSTC5cbiAqXG4gKiBDZXR0ZSBwaXBlIHByZW5kIHVuZSBVUkwgZGUgYmFzZSBldCB1biBvYmpldCBjb250ZW5hbnQgZGVzIHBhaXJlcyBjbMOpLXZhbGV1clxuICogcmVwcsOpc2VudGFudCBsZXMgcGFyYW3DqHRyZXMgZGUgcmVxdcOqdGUgw6AgYWpvdXRlci4gRWxsZSBlbmNvZGUgY29ycmVjdGVtZW50IGxlc1xuICogcGFyYW3DqHRyZXMgZXQgcydhc3N1cmUgZGUgbGVzIGFqb3V0ZXIgYXZlYyBsZSBzw6lwYXJhdGV1ciBhcHByb3ByacOpICgnPycgb3UgJyYnKS5cbiAqIExlcyBwYXJhbcOodHJlcyBhdmVjIGRlcyB2YWxldXJzIG51bGxlcyBvdSB1bmRlZmluZWQgc29udCBhdXRvbWF0aXF1ZW1lbnQgZmlsdHLDqXMuXG4gKlxuICogQGV4YW1wbGVcbiAqIC8vIERhbnMgdW4gdGVtcGxhdGVcbiAqIDxhIFtocmVmXT1cIidodHRwczovL2V4YW1wbGUuY29tJyB8IGFwcGVuZFF1ZXJ5UGFyYW1zOntpZDogMTIzLCBuYW1lOiAndGVzdCd9XCI+TGllbjwvYT5cbiAqIC8vIFLDqXN1bHRhdDogaHR0cHM6Ly9leGFtcGxlLmNvbT9pZD0xMjMmbmFtZT10ZXN0XG4gKlxuICogQGV4YW1wbGVcbiAqIC8vIFNpIGwnVVJMIGNvbnRpZW50IGTDqWrDoCBkZXMgcGFyYW3DqHRyZXNcbiAqIDxhIFtocmVmXT1cIidodHRwczovL2V4YW1wbGUuY29tP3BhZ2U9MScgfCBhcHBlbmRRdWVyeVBhcmFtczp7c29ydDogJ2FzYyd9XCI+TGllbjwvYT5cbiAqIC8vIFLDqXN1bHRhdDogaHR0cHM6Ly9leGFtcGxlLmNvbT9wYWdlPTEmc29ydD1hc2NcbiAqL1xuQFBpcGUoe1xuICBuYW1lOiAnYXBwZW5kUXVlcnlQYXJhbXMnLFxufSlcbmV4cG9ydCBjbGFzcyBBcHBlbmRRdWVyeVBhcmFtc1BpcGVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh1cmw6IHN0cmluZywgcXVlcnlQYXJhbXM6IHsgW2tleTogc3RyaW5nXTogYW55IH0pOiBhbnkge1xuICAgIHJldHVybiBVcmxVdGlscy5hcHBlbmRRdWVyeVBhcmFtcyh1cmwsIHF1ZXJ5UGFyYW1zKTtcbiAgfVxufVxuIl19

package/fesm2022/sumaris-net.ngx-components.mjs

@@ -5568,6 +5568,200 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 }]
         }] });
 
+class UrlUtils {
+    /**
+     * Determines if a given URL is a relative URL.
+     *
+     * @param {string | null} href - The URL to check.
+     * @return {boolean} True if the URL is relative, false otherwise.
+     */
+    static isRelativeUrl(href) {
+        if (!href)
+            return false;
+        return !href.startsWith('http:') && !href.startsWith('https:') && !href.startsWith('mailto:') && !href.startsWith('tel:');
+    }
+    /**
+     * Determines if a given URL is an internal URL.
+     *
+     * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.
+     * @return {boolean} Returns true if the URL is internal, otherwise false.
+     */
+    static isInternalUrl(href) {
+        if (!href)
+            return false;
+        return href.startsWith(window.location.origin) || this.isRelativeUrl(href);
+    }
+    static isExternalUrl(href) {
+        if (!href)
+            return false;
+        return !this.isInternalUrl(href);
+    }
+    /**
+     * Removes the query string from the given URL, returning only the base URL.
+     *
+     * @param {string} url - The URL from which the query string will be stripped.
+     * @return {string} The URL without the query string.
+     */
+    static stripQuery(url) {
+        return /[^?]*/.exec(url)[0];
+    }
+    /**
+     * Removes the fragment and query components from a given URL string.
+     *
+     * @param {string} url - The URL string to process.
+     * @return {string} The URL without its fragment and query components.
+     */
+    static stripFragmentAndQuery(url) {
+        if (!url)
+            return url;
+        return this.stripQuery(/[^#]*/.exec(url)[0]);
+    }
+    /**
+     * Extracts the fragment identifier from the given URL.
+     *
+     * @param {string} url - The URL from which to extract the fragment.
+     * @return {string} The fragment identifier of the URL, excluding the '#' symbol.
+     */
+    static getFragment(url) {
+        if (isNilOrBlank(url))
+            return '';
+        const match = url.match(/#(.*)$/);
+        return match ? match[1] : '';
+    }
+    static resolveRelativeUrl(baseUrl, relativePath, opts) {
+        if (!baseUrl)
+            throw new Error("Missing 'baseUrl' argument");
+        if (!relativePath)
+            throw new Error("Missing 'relativePath' argument");
+        if (!this.isRelativeUrl(relativePath))
+            throw new Error('Should be a relative path');
+        // Detect absolute URL
+        if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {
+            baseUrl = this.getRootUrl(baseUrl);
+        }
+        return UrlUtils.normalizeUrl(UrlUtils.concat(baseUrl, relativePath));
+    }
+    /**
+     * Resolves a given URL by normalizing its parts, removing unnecessary path segments like "." and "..".
+     *
+     * @param {string} url - The URL to be resolved. Must be a non-empty string.
+     * @return {string} The resolved and cleaned URL string.
+     * @throws {Error} If the provided URL is missing or undefined.
+     */
+    static normalizeUrl(url) {
+        if (!url)
+            throw new Error("Missing 'url' argument");
+        return this.cleanUrl(url)
+            .split('/')
+            .reduce((res, part) => {
+            if (part === '.')
+                return res;
+            if (part === '..' && res.length > 0)
+                return res.slice(0, -1);
+            return res.concat(part);
+        }, [])
+            .join('/');
+    }
+    /**
+     * This function completes a base URL with an object containing key-value pairs
+     * representing the query parameters to add. It properly encodes the
+     * parameters and ensures they are added with the appropriate separator ('?' or '&').
+     * Parameters with null or undefined values are automatically filtered out.
+     *
+     * @example
+     * // In a template
+     * <a [href]="'https://example.com' | appendQueryParams:{id: 123, name: 'test'}">Link</a>
+     * // Result: https://example.com?id=123&name=test
+     *
+     * @example
+     * // If the URL already contains parameters
+     * <a [href]="'https://example.com?page=1' | appendQueryParams:{sort: 'asc'}">Link</a>
+     * // Result: https://example.com?page=1&sort=asc
+     *
+     * @param url
+     * @param queryParams
+     */
+    static appendQueryParams(url, queryParams) {
+        const urlStr = typeof url === 'string' ? url : this.addStartingSlash(url.join('/'));
+        if (isNilOrBlank(urlStr) || !queryParams)
+            return urlStr;
+        const queryString = Object.entries(queryParams)
+            .filter(([_, value]) => isNotNil(value))
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('&');
+        if (isNilOrBlank(queryString))
+            return urlStr;
+        return urlStr + (urlStr.includes('?') ? '&' : '?') + queryString;
+    }
+    /**
+     * Extracts and returns the root URL from the given complete URL string.
+     *
+     * @param {string} url - The complete URL string from which the root URL will be extracted.
+     * @return {string} The root URL including the protocol and host (and port if present).
+     * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.
+     */
+    static getRootUrl(url) {
+        if (!url)
+            throw new Error("Missing 'url' argument");
+        let [protocol, path] = url.split('//', 2);
+        if (!protocol || isNilOrBlank(path))
+            throw new Error(`Invalid URL format: ${url}`);
+        const hostAndPort = path.split('/', 2)[0];
+        return `${protocol}//${hostAndPort}`;
+    }
+    /**
+     * Retrieves the parent URL or directory path from the provided URL.
+     * This method handles both relative and absolute URLs.
+     *
+     * @param {string} url - The URL from which to derive the parent path.
+     *                       Must be a valid URL or relative path.
+     * @return {string} The parent URL or directory path. Throws an error if the input is invalid.
+     */
+    static getParent(url) {
+        if (!url)
+            throw new Error("Missing 'url' argument");
+        const cleanUrl = this.stripFragmentAndQuery(url);
+        if (cleanUrl.endsWith('/'))
+            return cleanUrl; // Skip if already a parent directory
+        const parentPath = cleanUrl + '/' + '..';
+        if (this.isRelativeUrl(url)) {
+            return this.resolveRelativeUrl(window.location.href, parentPath);
+        }
+        return this.normalizeUrl(parentPath);
+    }
+    /**
+     * Cleans the provided URL by encoding it safely and replacing specific patterns.
+     *
+     * @param {string} href - The URL string to be cleaned.
+     * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.
+     */
+    static cleanUrl(href) {
+        try {
+            href = encodeURI(href).replace(/%25/g, '%');
+        }
+        catch (e) {
+            return null;
+        }
+        return href;
+    }
+    static addTrailingSlash(url) {
+        return url.endsWith('/') ? url : url + '/';
+    }
+    static addStartingSlash(url) {
+        return url.startsWith('/') ? url : '/' + url;
+    }
+    static removeStartingSlash(url) {
+        return url.startsWith('/') ? url.substring(1) : url;
+    }
+    static concat(basePath, relativePath) {
+        if (!basePath)
+            return relativePath;
+        if (!relativePath)
+            return basePath;
+        return this.addTrailingSlash(basePath) + this.removeStartingSlash(relativePath);
+    }
+}
+
 /**
  * Pipe permettant d'ajouter des paramètres de requête à une URL.
  *
@@ -5588,15 +5782,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
  */
 class AppendQueryParamsPipePipe {
     transform(url, queryParams) {
-        if (isNilOrBlank(url) || !queryParams)
-            return url;
-        let queryString = Object.entries(queryParams)
-            .filter(([_, value]) => isNotNil(value))
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('&');
-        if (isNilOrBlank(queryString))
-            return url;
-        return url + (url.includes('?') ? '&' : '?') + queryString;
+        return UrlUtils.appendQueryParams(url, queryParams);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AppendQueryParamsPipePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
     static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AppendQueryParamsPipePipe, name: "appendQueryParams" });
@@ -27934,169 +28120,6 @@ class CsvUtils {
     }
 }
 
-class UrlUtils {
-    /**
-     * Determines if a given URL is a relative URL.
-     *
-     * @param {string | null} href - The URL to check.
-     * @return {boolean} True if the URL is relative, false otherwise.
-     */
-    static isRelativeUrl(href) {
-        if (!href)
-            return false;
-        return !href.startsWith('http:') && !href.startsWith('https:') && !href.startsWith('mailto:') && !href.startsWith('tel:');
-    }
-    /**
-     * Determines if a given URL is an internal URL.
-     *
-     * @param {string | null} href - The URL to be checked. Can be a string representing the URL or null.
-     * @return {boolean} Returns true if the URL is internal, otherwise false.
-     */
-    static isInternalUrl(href) {
-        if (!href)
-            return false;
-        return href.startsWith(window.location.origin) || this.isRelativeUrl(href);
-    }
-    static isExternalUrl(href) {
-        if (!href)
-            return false;
-        return !this.isInternalUrl(href);
-    }
-    /**
-     * Removes the query string from the given URL, returning only the base URL.
-     *
-     * @param {string} url - The URL from which the query string will be stripped.
-     * @return {string} The URL without the query string.
-     */
-    static stripQuery(url) {
-        return /[^?]*/.exec(url)[0];
-    }
-    /**
-     * Removes the fragment and query components from a given URL string.
-     *
-     * @param {string} url - The URL string to process.
-     * @return {string} The URL without its fragment and query components.
-     */
-    static stripFragmentAndQuery(url) {
-        if (!url)
-            return url;
-        return this.stripQuery(/[^#]*/.exec(url)[0]);
-    }
-    /**
-     * Extracts the fragment identifier from the given URL.
-     *
-     * @param {string} url - The URL from which to extract the fragment.
-     * @return {string} The fragment identifier of the URL, excluding the '#' symbol.
-     */
-    static getFragment(url) {
-        if (isNilOrBlank(url))
-            return '';
-        const match = url.match(/#(.*)$/);
-        return match ? match[1] : '';
-    }
-    static resolveRelativeUrl(baseUrl, relativePath, opts) {
-        if (!baseUrl)
-            throw new Error("Missing 'baseUrl' argument");
-        if (!relativePath)
-            throw new Error("Missing 'relativePath' argument");
-        if (!this.isRelativeUrl(relativePath))
-            throw new Error("Should be a relative path");
-        // Detect absolute URL
-        if (relativePath.startsWith('/') || (opts?.absoluteByDefault && !relativePath.startsWith('.'))) {
-            baseUrl = this.getRootUrl(baseUrl);
-        }
-        return UrlUtils.normalizeUrl(UrlUtils.concat(baseUrl, relativePath));
-    }
-    /**
-     * Resolves a given URL by normalizing its parts, removing unnecessary path segments like "." and "..".
-     *
-     * @param {string} url - The URL to be resolved. Must be a non-empty string.
-     * @return {string} The resolved and cleaned URL string.
-     * @throws {Error} If the provided URL is missing or undefined.
-     */
-    static normalizeUrl(url) {
-        if (!url)
-            throw new Error("Missing 'url' argument");
-        return this.cleanUrl(url)
-            .split('/')
-            .reduce((res, part) => {
-            if (part === '.')
-                return res;
-            if (part === '..' && res.length > 0)
-                return res.slice(0, -1);
-            return res.concat(part);
-        }, [])
-            .join('/');
-    }
-    /**
-     * Extracts and returns the root URL from the given complete URL string.
-     *
-     * @param {string} url - The complete URL string from which the root URL will be extracted.
-     * @return {string} The root URL including the protocol and host (and port if present).
-     * @throws {Error} Throws an error if the provided URL is missing or is in an invalid format.
-     */
-    static getRootUrl(url) {
-        if (!url)
-            throw new Error("Missing 'url' argument");
-        let [protocol, path] = url.split('//', 2);
-        if (!protocol || isNilOrBlank(path))
-            throw new Error(`Invalid URL format: ${url}`);
-        const hostAndPort = path.split('/', 2)[0];
-        return `${protocol}//${hostAndPort}`;
-    }
-    /**
-     * Retrieves the parent URL or directory path from the provided URL.
-     * This method handles both relative and absolute URLs.
-     *
-     * @param {string} url - The URL from which to derive the parent path.
-     *                       Must be a valid URL or relative path.
-     * @return {string} The parent URL or directory path. Throws an error if the input is invalid.
-     */
-    static getParent(url) {
-        if (!url)
-            throw new Error("Missing 'url' argument");
-        const cleanUrl = this.stripFragmentAndQuery(url);
-        if (cleanUrl.endsWith('/'))
-            return cleanUrl; // Skip if already a parent directory
-        const parentPath = cleanUrl + '/' + '..';
-        if (this.isRelativeUrl(url)) {
-            return this.resolveRelativeUrl(window.location.href, parentPath);
-        }
-        return this.normalizeUrl(parentPath);
-    }
-    /**
-     * Cleans the provided URL by encoding it safely and replacing specific patterns.
-     *
-     * @param {string} href - The URL string to be cleaned.
-     * @return {string|null} The cleaned and encoded URL string, or null if an error occurs.
-     */
-    static cleanUrl(href) {
-        try {
-            href = encodeURI(href).replace(/%25/g, '%');
-        }
-        catch (e) {
-            return null;
-        }
-        return href;
-    }
-    static addTrailingSlash(url) {
-        return url.endsWith('/') ? url : url + '/';
-    }
-    static addStartingSlash(url) {
-        return url.startsWith('/') ? url : '/' + url;
-    }
-    static removeStartingSlash(url) {
-        return url.startsWith('/') ? url.substring(1) : url;
-    }
-    static concat(basePath, relativePath) {
-        if (!basePath)
-            return relativePath;
-        if (!relativePath)
-            return basePath;
-        return this.addTrailingSlash(basePath) + this.removeStartingSlash(relativePath);
-    }
-}
-
 /**
  * Define here theme colors
  */