@sumaris-net/ngx-components 18.27.2 → 18.27.4

package/esm2022/src/app/shared/alerts.mjs

@@ -7,8 +7,11 @@ export class Alerts {
      * @param alertCtrl
      * @param translate
      * @param event
+     * @param opts
+     * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)
+     * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)
      */
-    static async askSaveBeforeLeave(alertCtrl, translate, event) {
+    static async askSaveBeforeLeave(alertCtrl, translate, event, opts) {
         let confirm = false;
         let cancel = false;
         const translations = translate.instant([
@@ -42,6 +45,8 @@ export class Alerts {
                     },
                 },
             ],
+            backdropDismiss: opts?.backdropDismiss,
+            keyboardClose: opts?.keyboardClose,
         });
         await alert.present();
         await alert.onDidDismiss();
@@ -63,10 +68,13 @@ export class Alerts {
      * @param immediate is action has an immediate effect ?
      * @param event
      * @param interpolateParams
+     * @param opts
+     * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)
+     * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)
      */
-    static async askActionConfirmation(alertCtrl, translate, immediate, event, interpolateParams) {
+    static async askActionConfirmation(alertCtrl, translate, immediate, event, opts, interpolateParams) {
         const messageKey = immediate === true ? 'CONFIRM.ACTION_IMMEDIATE' : 'CONFIRM.ACTION';
-        return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams);
+        return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, opts, interpolateParams);
     }
     /**
      * Ask the user to confirm. If return undefined: user has cancelled
@@ -77,13 +85,21 @@ export class Alerts {
      * @param translate
      * @param event
      * @param interpolateParams
+     * @param opts
+     * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)
+     * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)
+     *
+     * Note: interpolateParams and opts are merged for translation for compatibility
      */
-    static async askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams) {
+    static async askConfirmation(messageKey, alertCtrl, translate, event, opts, interpolateParams) {
         if (!alertCtrl || !translate)
             throw new Error("Missing required argument 'alertCtrl' or 'translate'");
         let confirm = false;
         let cancel = false;
-        const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], interpolateParams);
+        const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], {
+            ...interpolateParams,
+            ...opts,
+        });
         const alert = await alertCtrl.create({
             header: translations['CONFIRM.ALERT_HEADER'],
             message: translations[messageKey],
@@ -103,6 +119,8 @@ export class Alerts {
                     },
                 },
             ],
+            backdropDismiss: opts?.backdropDismiss,
+            keyboardClose: opts?.keyboardClose,
         });
         await alert.present();
         await alert.onDidDismiss();
@@ -123,11 +141,19 @@ export class Alerts {
      * @param translate
      * @param event
      * @param interpolateParams
+     * @param opts
+     * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)
+     * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)
+     *
+     * Note: interpolateParams and opts are merged for translation for compatibility
      */
-    static async askDeleteConfirmation(alertCtrl, translate, event, interpolateParams) {
+    static async askDeleteConfirmation(alertCtrl, translate, event, opts, interpolateParams) {
         let confirm = false;
         let cancel = false;
-        const translations = translate.instant(['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'], interpolateParams);
+        const translations = translate.instant(['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'], {
+            ...interpolateParams,
+            ...opts,
+        });
         const alert = await alertCtrl.create({
             header: translations['CONFIRM.ALERT_HEADER'],
             message: translations['CONFIRM.DELETE'],
@@ -147,6 +173,8 @@ export class Alerts {
                     },
                 },
             ],
+            backdropDismiss: opts?.backdropDismiss,
+            keyboardClose: opts?.keyboardClose,
         });
         await alert.present();
         await alert.onDidDismiss();
@@ -194,6 +222,8 @@ export class Alerts {
                         },
                     },
                 ],
+                backdropDismiss: opts?.backdropDismiss,
+                keyboardClose: opts?.keyboardClose,
             });
         }
         else {
@@ -215,6 +245,8 @@ export class Alerts {
                         handler: () => { },
                     },
                 ],
+                backdropDismiss: opts?.backdropDismiss,
+                keyboardClose: opts?.keyboardClose,
             });
         }
         await alert.present();
@@ -235,9 +267,11 @@ export class Alerts {
                     role: 'cancel',
                 },
             ],
+            backdropDismiss: opts?.backdropDismiss,
+            keyboardClose: opts?.keyboardClose,
         });
         await alert.present();
         await alert.onDidDismiss();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alerts.js","sourceRoot":"","sources":["../../../../../src/app/shared/alerts.ts"],"names":[],"mappings":"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","sourcesContent":["import { AlertController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\n\nexport class Alerts {\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   * <p>\n   *   from a routed page, prefer using ComponentDirtyGuard\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   */\n  static async askSaveBeforeLeave(alertCtrl: AlertController, translate: TranslateService, event?: Event): Promise<boolean | undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant([\n      'COMMON.BTN_SAVE',\n      'COMMON.BTN_CANCEL',\n      'COMMON.BTN_ABORT_CHANGES',\n      'CONFIRM.SAVE',\n      'CONFIRM.ALERT_HEADER',\n    ]);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.SAVE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_ABORT_CHANGES'],\n          cssClass: 'secondary',\n          handler: () => {},\n        },\n        {\n          text: translations['COMMON.BTN_SAVE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  /**\n   * Ask the user to conform an action. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param immediate is action has an immediate effect ?\n   * @param event\n   * @param interpolateParams\n   */\n  static async askActionConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    immediate?: boolean,\n    event?: Event,\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    const messageKey = immediate === true ? 'CONFIRM.ACTION_IMMEDIATE' : 'CONFIRM.ACTION';\n    return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, interpolateParams);\n  }\n\n  /**\n   * Ask the user to confirm. If return undefined: user has cancelled\n   *\n   * @pram messageKey i18n message key\n   * @param messageKey\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   */\n  static async askConfirmation(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    if (!alertCtrl || !translate) throw new Error(\"Missing required argument 'alertCtrl' or 'translate'\");\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_YES_CONTINUE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   */\n  static async askDeleteConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(\n      ['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'],\n      interpolateParams\n    );\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.DELETE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_YES_DELETE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  static async askSaveBeforeAction(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    opts?: { valid?: boolean; validMessageI18n?: string; invalidMessageI18n?: string },\n    interpolateParams?: any\n  ): Promise<{ confirmed: boolean; save: boolean } | undefined> {\n    let save = false;\n    let confirmed = false;\n    let alert: HTMLIonAlertElement;\n    const validMessageI18n = opts?.validMessageI18n || 'CONFIRM.SAVE_BEFORE_CONTINUE';\n    const invalidMessageI18n = opts?.invalidMessageI18n || 'CONFIRM.CANCEL_CHANGES';\n\n    // Ask user before save\n    if (opts?.valid) {\n      const translations = translate.instant(\n        ['COMMON.BTN_CANCEL', 'COMMON.BTN_SAVE', 'COMMON.BTN_ABORT_CHANGES', 'CONFIRM.ALERT_HEADER', validMessageI18n],\n        interpolateParams\n      );\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations[validMessageI18n],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            cssClass: 'secondary',\n            handler: () => {},\n          },\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirmed = true;\n            },\n          },\n          {\n            text: translations['COMMON.BTN_SAVE'],\n            handler: () => {\n              save = true;\n              confirmed = true;\n            },\n          },\n        ],\n      });\n    } else {\n      const translations = translate.instant(\n        ['COMMON.BTN_ABORT_CHANGES', 'COMMON.BTN_CANCEL', 'CONFIRM.ALERT_HEADER', invalidMessageI18n],\n        interpolateParams\n      );\n\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations[invalidMessageI18n],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirmed = true;\n            },\n          },\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            handler: () => {},\n          },\n        ],\n      });\n    }\n\n    await alert.present();\n    await alert.onDidDismiss();\n\n    return { confirmed, save };\n  }\n\n  static async showError(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    opts?: {\n      titleKey?: string;\n    },\n    interpolateParams?: any\n  ) {\n    if (!messageKey || !alertCtrl || !translate) throw new Error(\"Missing a required argument ('messageKey', 'alertCtrl' or 'translate')\");\n    const titleKey = (opts && opts.titleKey) || 'ERROR.ALERT_HEADER';\n    const translations = translate.instant(['COMMON.BTN_OK', messageKey, titleKey], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations[titleKey],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_OK'],\n          role: 'cancel',\n        },\n      ],\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alerts.js","sourceRoot":"","sources":["../../../../../src/app/shared/alerts.ts"],"names":[],"mappings":"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","sourcesContent":["import { AlertController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\n\nexport class Alerts {\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   * <p>\n   *   from a routed page, prefer using ComponentDirtyGuard\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param opts\n   * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)\n   * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)\n   */\n  static async askSaveBeforeLeave(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    opts?: {\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n    }\n  ): Promise<boolean | undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant([\n      'COMMON.BTN_SAVE',\n      'COMMON.BTN_CANCEL',\n      'COMMON.BTN_ABORT_CHANGES',\n      'CONFIRM.SAVE',\n      'CONFIRM.ALERT_HEADER',\n    ]);\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.SAVE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_ABORT_CHANGES'],\n          cssClass: 'secondary',\n          handler: () => {},\n        },\n        {\n          text: translations['COMMON.BTN_SAVE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n      backdropDismiss: opts?.backdropDismiss,\n      keyboardClose: opts?.keyboardClose,\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  /**\n   * Ask the user to conform an action. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param immediate is action has an immediate effect ?\n   * @param event\n   * @param interpolateParams\n   * @param opts\n   * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)\n   * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)\n   */\n  static async askActionConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    immediate?: boolean,\n    event?: Event,\n    opts?: {\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n      [key: string]: any;\n    },\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    const messageKey = immediate === true ? 'CONFIRM.ACTION_IMMEDIATE' : 'CONFIRM.ACTION';\n    return Alerts.askConfirmation(messageKey, alertCtrl, translate, event, opts, interpolateParams);\n  }\n\n  /**\n   * Ask the user to confirm. If return undefined: user has cancelled\n   *\n   * @pram messageKey i18n message key\n   * @param messageKey\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   * @param opts\n   * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)\n   * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)\n   *\n   * Note: interpolateParams and opts are merged for translation for compatibility\n   */\n  static async askConfirmation(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    opts?: {\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n      [key: string]: any;\n    },\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    if (!alertCtrl || !translate) throw new Error(\"Missing required argument 'alertCtrl' or 'translate'\");\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_YES_CONTINUE', 'COMMON.BTN_CANCEL', messageKey, 'CONFIRM.ALERT_HEADER'], {\n      ...interpolateParams,\n      ...opts,\n    });\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_YES_CONTINUE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n      backdropDismiss: opts?.backdropDismiss,\n      keyboardClose: opts?.keyboardClose,\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  /**\n   * Ask the user to save before leaving. If return undefined: user has cancelled\n   *\n   * @param alertCtrl\n   * @param translate\n   * @param event\n   * @param interpolateParams\n   * @param opts\n   * @param opts.backdropDismiss Whether the alert can be dismissed by clicking the backdrop (default: true)\n   * @param opts.keyboardClose Whether the alert can be dismissed by pressing the back button (default: true)\n   *\n   * Note: interpolateParams and opts are merged for translation for compatibility\n   */\n  static async askDeleteConfirmation(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    event?: Event,\n    opts?: {\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n      [key: string]: any;\n    },\n    interpolateParams?: any\n  ): Promise<boolean | undefined> {\n    let confirm = false;\n    let cancel = false;\n    const translations = translate.instant(['COMMON.BTN_YES_DELETE', 'COMMON.BTN_CANCEL', 'CONFIRM.DELETE', 'CONFIRM.ALERT_HEADER'], {\n      ...interpolateParams,\n      ...opts,\n    });\n    const alert = await alertCtrl.create({\n      header: translations['CONFIRM.ALERT_HEADER'],\n      message: translations['CONFIRM.DELETE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n          handler: () => {\n            cancel = true;\n          },\n        },\n        {\n          text: translations['COMMON.BTN_YES_DELETE'],\n          handler: () => {\n            confirm = true; // update upper value\n          },\n        },\n      ],\n      backdropDismiss: opts?.backdropDismiss,\n      keyboardClose: opts?.keyboardClose,\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n\n    if (confirm) return true; // = Do save and leave\n\n    if (cancel) {\n      // Stop the event\n      if (event) event.preventDefault();\n\n      return undefined; // User cancelled\n    }\n\n    return false; // Leave without saving\n  }\n\n  static async askSaveBeforeAction(\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    opts?: {\n      valid?: boolean;\n      validMessageI18n?: string;\n      invalidMessageI18n?: string;\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n    },\n    interpolateParams?: any\n  ): Promise<{ confirmed: boolean; save: boolean } | undefined> {\n    let save = false;\n    let confirmed = false;\n    let alert: HTMLIonAlertElement;\n    const validMessageI18n = opts?.validMessageI18n || 'CONFIRM.SAVE_BEFORE_CONTINUE';\n    const invalidMessageI18n = opts?.invalidMessageI18n || 'CONFIRM.CANCEL_CHANGES';\n\n    // Ask user before save\n    if (opts?.valid) {\n      const translations = translate.instant(\n        ['COMMON.BTN_CANCEL', 'COMMON.BTN_SAVE', 'COMMON.BTN_ABORT_CHANGES', 'CONFIRM.ALERT_HEADER', validMessageI18n],\n        interpolateParams\n      );\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations[validMessageI18n],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            cssClass: 'secondary',\n            handler: () => {},\n          },\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirmed = true;\n            },\n          },\n          {\n            text: translations['COMMON.BTN_SAVE'],\n            handler: () => {\n              save = true;\n              confirmed = true;\n            },\n          },\n        ],\n        backdropDismiss: opts?.backdropDismiss,\n        keyboardClose: opts?.keyboardClose,\n      });\n    } else {\n      const translations = translate.instant(\n        ['COMMON.BTN_ABORT_CHANGES', 'COMMON.BTN_CANCEL', 'CONFIRM.ALERT_HEADER', invalidMessageI18n],\n        interpolateParams\n      );\n\n      alert = await alertCtrl.create({\n        header: translations['CONFIRM.ALERT_HEADER'],\n        message: translations[invalidMessageI18n],\n        buttons: [\n          {\n            text: translations['COMMON.BTN_ABORT_CHANGES'],\n            cssClass: 'secondary',\n            handler: () => {\n              confirmed = true;\n            },\n          },\n          {\n            text: translations['COMMON.BTN_CANCEL'],\n            role: 'cancel',\n            handler: () => {},\n          },\n        ],\n        backdropDismiss: opts?.backdropDismiss,\n        keyboardClose: opts?.keyboardClose,\n      });\n    }\n\n    await alert.present();\n    await alert.onDidDismiss();\n\n    return { confirmed, save };\n  }\n\n  static async showError(\n    messageKey: string,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    opts?: {\n      titleKey?: string;\n      backdropDismiss?: boolean;\n      keyboardClose?: boolean;\n    },\n    interpolateParams?: any\n  ) {\n    if (!messageKey || !alertCtrl || !translate) throw new Error(\"Missing a required argument ('messageKey', 'alertCtrl' or 'translate')\");\n    const titleKey = (opts && opts.titleKey) || 'ERROR.ALERT_HEADER';\n    const translations = translate.instant(['COMMON.BTN_OK', messageKey, titleKey], interpolateParams);\n    const alert = await alertCtrl.create({\n      header: translations[titleKey],\n      message: translations[messageKey],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_OK'],\n          role: 'cancel',\n        },\n      ],\n      backdropDismiss: opts?.backdropDismiss,\n      keyboardClose: opts?.keyboardClose,\n    });\n    await alert.present();\n    await alert.onDidDismiss();\n  }\n}\n"]}

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"]}