@sumaris-net/ngx-components 18.26.13 → 18.26.14-alpha2

package/esm2022/src/app/shared/gitlab/gitlab.utils.mjs

@@ -0,0 +1,170 @@
+import { HttpUtils } from '../http/http.utils';
+import { UrlUtils } from '../file/url.utils';
+export class GitlabUtils {
+    static API_V4_PATH = '/api/v4/';
+    static API_V4_PROJECTS_PATH = '/api/v4/projects/';
+    /**
+     * Checks whether a URL points to a Gitlab instance.
+     *
+     * A URL is considered a Gitlab URL either when its host starts with 'gitlab.'
+     * (e.g. 'https://gitlab.ifremer.fr/...'), or when it is a repository file URL
+     * (see {@link isRepoFileUrl}) - in which case the host is NOT checked, since
+     * a self-hosted Gitlab instance may use a custom domain name.
+     *
+     * @example
+     * GitlabUtils.isGitlabUrl('https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app'); // true
+     * GitlabUtils.isGitlabUrl('https://my-custom-domain.com/foo/-/raw/master/README.md'); // true (repo file URL)
+     * GitlabUtils.isGitlabUrl('https://github.com/foo/bar'); // false
+     */
+    static isGitlabUrl(url) {
+        if (!url)
+            return false;
+        return url.startsWith('https://gitlab.') || GitlabUtils.isRepoFileUrl(url);
+    }
+    /**
+     * Checks whether a URL is a Gitlab repository file URL, i.e. a URL used to
+     * view a single file in a repository ('/-/blob/') or to download its raw
+     * content ('/-/raw/').
+     *
+     * @example
+     * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/raw/master/README.md'); // true
+     * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/blob/master/README.md'); // true
+     * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/api/v4/projects/a%2Fb'); // false
+     */
+    static isRepoFileUrl(url) {
+        if (!url)
+            return false;
+        return url.includes('/-/raw/') || url.includes('/-/blob/');
+    }
+    /**
+     * Converts a repository file URL into its 'raw content' equivalent, by
+     * replacing the '/-/blob/' (file viewer) or '/-/tree/' (directory viewer)
+     * segment with '/-/raw/'.
+     *
+     * If the URL is not a repository file URL (see {@link isRepoFileUrl}), it is
+     * returned unchanged.
+     *
+     * @example
+     * GitlabUtils.getRawRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/blob/master/README.md');
+     * // 'https://gitlab.ifremer.fr/a/b/-/raw/master/README.md'
+     */
+    static getRawRepoFileUrl(url) {
+        if (!GitlabUtils.isRepoFileUrl(url))
+            return url;
+        return url.replace('/-/blob/', '/-/raw/').replace('/-/tree/', '/-/raw/');
+    }
+    /**
+     * Checks whether a URL targets the Gitlab REST API (any endpoint under
+     * '/api/v4/'). Repository file URLs (see {@link isRepoFileUrl}) are always
+     * excluded, even if they happen to contain '/api/v4/' somewhere in their path.
+     */
+    static isApiUrl(url) {
+        if (!url || GitlabUtils.isRepoFileUrl(url))
+            return false;
+        return url.includes(GitlabUtils.API_V4_PATH);
+    }
+    /**
+     * Checks whether a URL targets the Gitlab 'projects' REST API (any endpoint
+     * under '/api/v4/projects/'), e.g. project releases, branches, etc.
+     */
+    static isApiProjectsUrl(url) {
+        if (!url || GitlabUtils.isRepoFileUrl(url))
+            return false;
+        return url.includes(GitlabUtils.API_V4_PROJECTS_PATH);
+    }
+    /**
+     * Checks whether a URL targets the Gitlab project releases REST API, e.g.
+     * 'https://gitlab.ifremer.fr/api/v4/projects/{id}/releases' (all releases)
+     * or 'https://gitlab.ifremer.fr/api/v4/projects/{id}/releases/{tag_name}'
+     * (a single release).
+     */
+    static isProjectReleasesApiUrl(url) {
+        return GitlabUtils.isApiProjectsUrl(url) && url.includes('/releases');
+    }
+    /**
+     * Fetches releases from the Gitlab project releases REST API.
+     *
+     * The given URL can either target the collection endpoint
+     * ('.../releases', returning all releases), or a single release endpoint
+     * ('.../releases/{tag_name}', returning one release, wrapped into an array).
+     *
+     * @return the list of releases, an empty array if the API call failed for a
+     *   single release, or `null` if the URL is not a project releases API URL.
+     */
+    static async getProjectReleases(http, url) {
+        if (!GitlabUtils.isProjectReleasesApiUrl(url))
+            return null;
+        // Many releases API urls end with /releases
+        if (url.trim().endsWith('/releases')) {
+            return await HttpUtils.getJson(http, url);
+        }
+        // One release API url
+        try {
+            const release = await HttpUtils.getJson(http, url);
+            return release ? [release] : [];
+        }
+        catch (err) {
+            console.error('Failed to fetch release from the Gitlab API ' + url, err);
+            return null;
+        }
+    }
+    /**
+     * Extracts the URL-encoded project path (e.g. 'group%2Fsubgroup%2Fproject')
+     * from a Gitlab 'projects' API URL. The returned value is NOT decoded, so it
+     * still contains '%2F' in place of '/'.
+     *
+     * @example
+     * GitlabUtils.getProjectNameFromApiUrl('https://gitlab.ifremer.fr/api/v4/projects/sih-public%2Fsumaris%2Fsumaris-app/releases');
+     * // 'sih-public%2Fsumaris%2Fsumaris-app'
+     */
+    static getProjectNameFromApiUrl(url) {
+        if (!url?.includes(GitlabUtils.API_V4_PROJECTS_PATH))
+            return null;
+        return url.slice(url.indexOf(GitlabUtils.API_V4_PROJECTS_PATH) + GitlabUtils.API_V4_PROJECTS_PATH.length)
+            .split('/', 2)[0];
+    }
+    /**
+     * Resolves the Gitlab web page associated to a URL:
+     * - for an API 'projects' URL (see {@link isApiUrl}), this is the project's
+     *   home page, e.g. 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app';
+     * - for a repository file URL (see {@link isRepoFileUrl}), this is the
+     *   project's raw content base path (e.g. '.../my-project/-/raw/'), since
+     *   the project path cannot be reliably distinguished from the file path
+     *   once slashes are un-encoded.
+     *
+     * @return `null` if the project page cannot be resolved from the given URL.
+     */
+    static getProjectPage(url) {
+        if (GitlabUtils.isRepoFileUrl(url)) {
+            const fixUrl = GitlabUtils.getRawRepoFileUrl(url);
+            const index = fixUrl.indexOf('/-/raw/');
+            if (index >= 0)
+                return fixUrl.slice(0, index + '/-/raw/'.length);
+        }
+        else if (GitlabUtils.isApiUrl(url)) {
+            const index = url.indexOf(GitlabUtils.API_V4_PROJECTS_PATH);
+            if (index >= 0) {
+                const baseUrl = url.slice(0, index);
+                const projectName = GitlabUtils.getProjectNameFromApiUrl(url);
+                return UrlUtils.concat(baseUrl, projectName.replace(/%2F/g, '/'));
+            }
+        }
+        return null;
+    }
+    /**
+     * Builds the URL of the Gitlab web page listing a project's releases (e.g.
+     * 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/releases'),
+     * optionally anchored on a specific version/tag.
+     *
+     * @param url any URL from which the project page can be resolved (see {@link getProjectPage})
+     * @param version optional tag name (e.g. '2.16.2') appended to the releases page
+     * @return `null` if the project page cannot be resolved from the given URL.
+     */
+    static getProjectReleasePage(url, version) {
+        const basePath = GitlabUtils.getProjectPage(url);
+        if (!basePath)
+            return null;
+        return UrlUtils.concat(UrlUtils.concat(basePath, '/-/releases'), version);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gitlab.utils.js","sourceRoot":"","sources":["../../../../../../src/app/shared/gitlab/gitlab.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpUtils} from '../http/http.utils';\nimport {HttpClient} from '@angular/common/http';\nimport { UrlUtils } from '../file/url.utils';\n\nexport interface IGitlabRelease {\n  name: string;\n  tag_name: string;\n  description: string\n}\n\nexport class GitlabUtils {\n  static API_V4_PATH = '/api/v4/';\n  static API_V4_PROJECTS_PATH = '/api/v4/projects/';\n\n  /**\n   * Checks whether a URL points to a Gitlab instance.\n   *\n   * A URL is considered a Gitlab URL either when its host starts with 'gitlab.'\n   * (e.g. 'https://gitlab.ifremer.fr/...'), or when it is a repository file URL\n   * (see {@link isRepoFileUrl}) - in which case the host is NOT checked, since\n   * a self-hosted Gitlab instance may use a custom domain name.\n   *\n   * @example\n   * GitlabUtils.isGitlabUrl('https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app'); // true\n   * GitlabUtils.isGitlabUrl('https://my-custom-domain.com/foo/-/raw/master/README.md'); // true (repo file URL)\n   * GitlabUtils.isGitlabUrl('https://github.com/foo/bar'); // false\n   */\n  static isGitlabUrl(url: string) {\n    if (!url) return false;\n    return url.startsWith('https://gitlab.') || GitlabUtils.isRepoFileUrl(url);\n  }\n\n  /**\n   * Checks whether a URL is a Gitlab repository file URL, i.e. a URL used to\n   * view a single file in a repository ('/-/blob/') or to download its raw\n   * content ('/-/raw/').\n   *\n   * @example\n   * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/raw/master/README.md'); // true\n   * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/blob/master/README.md'); // true\n   * GitlabUtils.isRepoFileUrl('https://gitlab.ifremer.fr/api/v4/projects/a%2Fb'); // false\n   */\n  static isRepoFileUrl(url: string) {\n    if (!url) return false;\n    return url.includes('/-/raw/') || url.includes('/-/blob/');\n  }\n\n  /**\n   * Converts a repository file URL into its 'raw content' equivalent, by\n   * replacing the '/-/blob/' (file viewer) or '/-/tree/' (directory viewer)\n   * segment with '/-/raw/'.\n   *\n   * If the URL is not a repository file URL (see {@link isRepoFileUrl}), it is\n   * returned unchanged.\n   *\n   * @example\n   * GitlabUtils.getRawRepoFileUrl('https://gitlab.ifremer.fr/a/b/-/blob/master/README.md');\n   * // 'https://gitlab.ifremer.fr/a/b/-/raw/master/README.md'\n   */\n  static getRawRepoFileUrl(url: string) {\n    if (!GitlabUtils.isRepoFileUrl(url)) return url;\n    return url.replace('/-/blob/', '/-/raw/').replace('/-/tree/', '/-/raw/');\n  }\n\n  /**\n   * Checks whether a URL targets the Gitlab REST API (any endpoint under\n   * '/api/v4/'). Repository file URLs (see {@link isRepoFileUrl}) are always\n   * excluded, even if they happen to contain '/api/v4/' somewhere in their path.\n   */\n  static isApiUrl(url: string) {\n    if (!url || GitlabUtils.isRepoFileUrl(url)) return false;\n    return url.includes(GitlabUtils.API_V4_PATH);\n  }\n\n  /**\n   * Checks whether a URL targets the Gitlab 'projects' REST API (any endpoint\n   * under '/api/v4/projects/'), e.g. project releases, branches, etc.\n   */\n  static isApiProjectsUrl(url: string) {\n    if (!url || GitlabUtils.isRepoFileUrl(url)) return false;\n    return url.includes(GitlabUtils.API_V4_PROJECTS_PATH);\n  }\n\n  /**\n   * Checks whether a URL targets the Gitlab project releases REST API, e.g.\n   * 'https://gitlab.ifremer.fr/api/v4/projects/{id}/releases' (all releases)\n   * or 'https://gitlab.ifremer.fr/api/v4/projects/{id}/releases/{tag_name}'\n   * (a single release).\n   */\n  static isProjectReleasesApiUrl(url: string) {\n    return GitlabUtils.isApiProjectsUrl(url) && url.includes('/releases');\n  }\n\n  /**\n   * Fetches releases from the Gitlab project releases REST API.\n   *\n   * The given URL can either target the collection endpoint\n   * ('.../releases', returning all releases), or a single release endpoint\n   * ('.../releases/{tag_name}', returning one release, wrapped into an array).\n   *\n   * @return the list of releases, an empty array if the API call failed for a\n   *   single release, or `null` if the URL is not a project releases API URL.\n   */\n  static async getProjectReleases(http: HttpClient, url: string) {\n    if (!GitlabUtils.isProjectReleasesApiUrl(url)) return null;\n\n    // Many releases API urls end with /releases\n    if (url.trim().endsWith('/releases')) {\n      return await HttpUtils.getJson<IGitlabRelease[]>(http, url);\n    }\n\n    // One release API url\n    try {\n    const release = await HttpUtils.getJson<IGitlabRelease>(http, url);\n    return release ? [release] : [];\n    } catch (err) {\n      console.error('Failed to fetch release from the Gitlab API ' + url, err);\n      return null;\n    }\n  }\n\n  /**\n   * Extracts the URL-encoded project path (e.g. 'group%2Fsubgroup%2Fproject')\n   * from a Gitlab 'projects' API URL. The returned value is NOT decoded, so it\n   * still contains '%2F' in place of '/'.\n   *\n   * @example\n   * GitlabUtils.getProjectNameFromApiUrl('https://gitlab.ifremer.fr/api/v4/projects/sih-public%2Fsumaris%2Fsumaris-app/releases');\n   * // 'sih-public%2Fsumaris%2Fsumaris-app'\n   */\n  static getProjectNameFromApiUrl(url: string) {\n    if (!url?.includes(GitlabUtils.API_V4_PROJECTS_PATH)) return null;\n\n    return url.slice(url.indexOf(GitlabUtils.API_V4_PROJECTS_PATH) + GitlabUtils.API_V4_PROJECTS_PATH.length)\n      .split('/', 2)[0];\n  }\n\n  /**\n   * Resolves the Gitlab web page associated to a URL:\n   * - for an API 'projects' URL (see {@link isApiUrl}), this is the project's\n   *   home page, e.g. 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app';\n   * - for a repository file URL (see {@link isRepoFileUrl}), this is the\n   *   project's raw content base path (e.g. '.../my-project/-/raw/'), since\n   *   the project path cannot be reliably distinguished from the file path\n   *   once slashes are un-encoded.\n   *\n   * @return `null` if the project page cannot be resolved from the given URL.\n   */\n  static getProjectPage(url: string) {\n    if (GitlabUtils.isRepoFileUrl(url)) {\n      const fixUrl = GitlabUtils.getRawRepoFileUrl(url);\n      const index = fixUrl.indexOf('/-/raw/');\n      if (index >= 0) return fixUrl.slice(0, index + '/-/raw/'.length);\n    } else if (GitlabUtils.isApiUrl(url)) {\n      const index = url.indexOf(GitlabUtils.API_V4_PROJECTS_PATH);\n      if (index >= 0) {\n        const baseUrl = url.slice(0, index);\n        const projectName = GitlabUtils.getProjectNameFromApiUrl(url);\n        return UrlUtils.concat(baseUrl, projectName.replace(/%2F/g, '/'));\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Builds the URL of the Gitlab web page listing a project's releases (e.g.\n   * 'https://gitlab.ifremer.fr/sih-public/sumaris/sumaris-app/-/releases'),\n   * optionally anchored on a specific version/tag.\n   *\n   * @param url any URL from which the project page can be resolved (see {@link getProjectPage})\n   * @param version optional tag name (e.g. '2.16.2') appended to the releases page\n   * @return `null` if the project page cannot be resolved from the given URL.\n   */\n  static getProjectReleasePage(url: string, version?: string) {\n    const basePath = GitlabUtils.getProjectPage(url);\n    if (!basePath) return null;\n\n    return UrlUtils.concat(\n      UrlUtils.concat(basePath, '/-/releases'),\n      version\n    );\n  }\n}\n"]}