@sumaris-net/ngx-components 18.5.13 → 18.6.0

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

@@ -0,0 +1,164 @@
+import { isNilOrBlank } from '../functions';
+export 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);
+    }
+}
+//# 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 } 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"]}