raise-common-lib-new 0.0.2

package/esm2022/lib/service/common-function.service.mjs

@@ -0,0 +1,141 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export class CommonFunctionService {
+    constructor() { }
+    closeTabSubject = new Subject();
+    closeTab$ = this.closeTabSubject.asObservable();
+    pub = new Subject();
+    pub$ = this.pub.asObservable();
+    testMethod() {
+        return "test1111";
+    }
+    setMiddleEllipsis(text, maxWidth = 150, fontSize = 13) {
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        context.font = `${fontSize}px Arial`;
+        let width = context.measureText(text).width;
+        if (width <= maxWidth) {
+            return text;
+        }
+        maxWidth = Math.floor(maxWidth - context.measureText("...").width);
+        let firstPart = "";
+        let secondPart = "";
+        let half = Math.floor(maxWidth / 2);
+        for (let i = 0; i < text.length; i++) {
+            firstPart += text[i];
+            width = context.measureText(firstPart).width;
+            if (width > half) {
+                break;
+            }
+        }
+        for (let i = text.length - 1; i >= 0; i--) {
+            secondPart = text[i] + secondPart;
+            width = context.measureText(secondPart).width;
+            if (width > half) {
+                break;
+            }
+        }
+        return firstPart + "..." + secondPart;
+    }
+    getPureUrl(url) {
+        if (url) {
+            // 如果params的value 携带查询参数， 则截取前面部分
+            url = decodeURIComponent(url);
+            if (url.includes("?")) {
+                url = url.split("?")[0];
+            }
+        }
+        return url;
+    }
+    // 删除当前
+    closeTab(tabIndex) {
+        return this.closeTabSubject.next(tabIndex);
+    }
+    publish(event) {
+        this.pub.next(event);
+    }
+    rtn(str) {
+        if (str && (str !== 0 || str !== "0")) {
+            let arr = str.trim().split(" ");
+            let res = "";
+            for (let i = 0; i < arr.length; i++) {
+                let el = arr[i];
+                if (el) {
+                    arr[i] = el.replace(/[^a-zA-z0-9\u4e00-\u9fa5]/g, "");
+                }
+                else {
+                    arr.splice(i, 1);
+                    i--;
+                }
+            }
+            arr = arr.filter((el) => el);
+            var pattern = new RegExp("[\u4E00-\u9FA5]+");
+            var pattern2 = new RegExp("[A-Za-z0-9]+");
+            if (arr.length > 1) {
+                if (pattern.test(arr[0][0])) {
+                    res = arr[0][0];
+                    return res;
+                }
+                else if (pattern2.test(arr[0][0])) {
+                    if (pattern2.test(arr[1][0])) {
+                        res = arr[0][0] + arr[1][0];
+                    }
+                    else if (pattern.test(arr[1][0])) {
+                        res = arr[0][0] + arr[0][1];
+                    }
+                    if (res != null && res != "" && typeof res == "string") {
+                        return res.toUpperCase();
+                    }
+                    else {
+                        return "";
+                    }
+                }
+            }
+            else if (arr.length == 1) {
+                if (pattern.test(arr[0][0])) {
+                    res = arr[0][0];
+                    return res;
+                }
+                else if (pattern2.test(arr[0][0])) {
+                    if (pattern2.test(arr[0][1])) {
+                        res = arr[0][0] + arr[0][1];
+                        if (res != null && res != "" && typeof res == "string") {
+                            return res.toUpperCase();
+                        }
+                        else {
+                            return "";
+                        }
+                    }
+                    else if (pattern.test(arr[0][1])) {
+                        res = arr[0][1];
+                        if (res != null && res != "" && typeof res == "string") {
+                            return res.toUpperCase();
+                        }
+                        else {
+                            return "";
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            return "";
+        }
+    }
+    Guid() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            let r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommonFunctionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommonFunctionService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CommonFunctionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-function.service.js","sourceRoot":"","sources":["../../../../../projects/raise-common-lib/src/lib/service/common-function.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;;AAK3C,MAAM,OAAO,qBAAqB;IAChC,gBAAe,CAAC;IACR,eAAe,GAAG,IAAI,OAAO,EAAU,CAAC;IACzC,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IAEhD,GAAG,GAAG,IAAI,OAAO,EAAO,CAAC;IACzB,IAAI,GAAoB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAEvD,UAAU;QACR,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,GAAG,EAAE,QAAQ,GAAG,EAAE;QACnD,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACxC,OAAO,CAAC,IAAI,GAAG,GAAG,QAAQ,UAAU,CAAC;QAErC,IAAI,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC;QAE5C,IAAI,KAAK,IAAI,QAAQ,EAAE;YACrB,OAAO,IAAI,CAAC;SACb;QACD,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,IAAI,UAAU,GAAG,EAAE,CAAC;QACpB,IAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC;QACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACpC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC;YAC7C,IAAI,KAAK,GAAG,IAAI,EAAE;gBAChB,MAAM;aACP;SACF;QAED,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACzC,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;YAClC,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC;YAC9C,IAAI,KAAK,GAAG,IAAI,EAAE;gBAChB,MAAM;aACP;SACF;QAED,OAAO,SAAS,GAAG,KAAK,GAAG,UAAU,CAAC;IACxC,CAAC;IAED,UAAU,CAAC,GAAW;QACpB,IAAI,GAAG,EAAE;YACP,iCAAiC;YACjC,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;gBACrB,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;aACzB;SACF;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,OAAO;IACP,QAAQ,CAAC,QAAiB;QACxB,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED,OAAO,CAAC,KAAK;QACX,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,GAAG,CAAC,GAAG;QACL,IAAI,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,GAAG,KAAK,GAAG,CAAC,EAAE;YACrC,IAAI,GAAG,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAChC,IAAI,GAAG,GAAG,EAAE,CAAC;YACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBACnC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;gBAChB,IAAI,EAAE,EAAE;oBACN,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,4BAA4B,EAAE,EAAE,CAAC,CAAC;iBACvD;qBAAM;oBACL,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;oBACjB,CAAC,EAAE,CAAC;iBACL;aACF;YACD,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;YAC7B,IAAI,OAAO,GAAG,IAAI,MAAM,CAAC,kBAAkB,CAAC,CAAC;YAC7C,IAAI,QAAQ,GAAG,IAAI,MAAM,CAAC,cAAc,CAAC,CAAC;YAC1C,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;gBAClB,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;oBAC3B,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAChB,OAAO,GAAG,CAAC;iBACZ;qBAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;oBACnC,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;wBAC5B,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;qBAC7B;yBAAM,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;wBAClC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;qBAC7B;oBACD,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,EAAE,IAAI,OAAO,GAAG,IAAI,QAAQ,EAAE;wBACtD,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC;qBAC1B;yBAAM;wBACL,OAAO,EAAE,CAAC;qBACX;iBACF;aACF;iBAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EAAE;gBAC1B,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;oBAC3B,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAChB,OAAO,GAAG,CAAC;iBACZ;qBAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;oBACnC,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;wBAC5B,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC5B,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,EAAE,IAAI,OAAO,GAAG,IAAI,QAAQ,EAAE;4BACtD,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC;yBAC1B;6BAAM;4BACL,OAAO,EAAE,CAAC;yBACX;qBACF;yBAAM,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;wBAClC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBAChB,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,EAAE,IAAI,OAAO,GAAG,IAAI,QAAQ,EAAE;4BACtD,OAAO,GAAG,CAAC,WAAW,EAAE,CAAC;yBAC1B;6BAAM;4BACL,OAAO,EAAE,CAAC;yBACX;qBACF;iBACF;aACF;SACF;aAAM;YACL,OAAO,EAAE,CAAC;SACX;IACH,CAAC;IAED,IAAI;QACF,OAAO,sCAAsC,CAAC,OAAO,CACnD,OAAO,EACP,UAAU,CAAC;YACT,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAC9B,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;YACrC,OAAO,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC,CACF,CAAC;IACJ,CAAC;wGArIU,qBAAqB;4GAArB,qBAAqB,cAFpB,MAAM;;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { Observable, Subject } from \"rxjs\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class CommonFunctionService {\r\n  constructor() {}\r\n  private closeTabSubject = new Subject<number>();\r\n  public closeTab$ = this.closeTabSubject.asObservable();\r\n\r\n  public pub = new Subject<any>();\r\n  public pub$: Observable<any> = this.pub.asObservable();\r\n\r\n  testMethod() {\r\n    return \"test1111\";\r\n  }\r\n\r\n  setMiddleEllipsis(text, maxWidth = 150, fontSize = 13) {\r\n    const canvas = document.createElement(\"canvas\");\r\n    const context = canvas.getContext(\"2d\");\r\n    context.font = `${fontSize}px Arial`;\r\n\r\n    let width = context.measureText(text).width;\r\n\r\n    if (width <= maxWidth) {\r\n      return text;\r\n    }\r\n    maxWidth = Math.floor(maxWidth - context.measureText(\"...\").width);\r\n    let firstPart = \"\";\r\n    let secondPart = \"\";\r\n    let half = Math.floor(maxWidth / 2);\r\n    for (let i = 0; i < text.length; i++) {\r\n      firstPart += text[i];\r\n      width = context.measureText(firstPart).width;\r\n      if (width > half) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    for (let i = text.length - 1; i >= 0; i--) {\r\n      secondPart = text[i] + secondPart;\r\n      width = context.measureText(secondPart).width;\r\n      if (width > half) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    return firstPart + \"...\" + secondPart;\r\n  }\r\n\r\n  getPureUrl(url: string) {\r\n    if (url) {\r\n      // 如果params的value 携带查询参数， 则截取前面部分\r\n      url = decodeURIComponent(url);\r\n      if (url.includes(\"?\")) {\r\n        url = url.split(\"?\")[0];\r\n      }\r\n    }\r\n    return url;\r\n  }\r\n\r\n  // 删除当前\r\n  closeTab(tabIndex?: number) {\r\n    return this.closeTabSubject.next(tabIndex);\r\n  }\r\n\r\n  publish(event) {\r\n    this.pub.next(event);\r\n  }\r\n\r\n  rtn(str) {\r\n    if (str && (str !== 0 || str !== \"0\")) {\r\n      let arr = str.trim().split(\" \");\r\n      let res = \"\";\r\n      for (let i = 0; i < arr.length; i++) {\r\n        let el = arr[i];\r\n        if (el) {\r\n          arr[i] = el.replace(/[^a-zA-z0-9\\u4e00-\\u9fa5]/g, \"\");\r\n        } else {\r\n          arr.splice(i, 1);\r\n          i--;\r\n        }\r\n      }\r\n      arr = arr.filter((el) => el);\r\n      var pattern = new RegExp(\"[\\u4E00-\\u9FA5]+\");\r\n      var pattern2 = new RegExp(\"[A-Za-z0-9]+\");\r\n      if (arr.length > 1) {\r\n        if (pattern.test(arr[0][0])) {\r\n          res = arr[0][0];\r\n          return res;\r\n        } else if (pattern2.test(arr[0][0])) {\r\n          if (pattern2.test(arr[1][0])) {\r\n            res = arr[0][0] + arr[1][0];\r\n          } else if (pattern.test(arr[1][0])) {\r\n            res = arr[0][0] + arr[0][1];\r\n          }\r\n          if (res != null && res != \"\" && typeof res == \"string\") {\r\n            return res.toUpperCase();\r\n          } else {\r\n            return \"\";\r\n          }\r\n        }\r\n      } else if (arr.length == 1) {\r\n        if (pattern.test(arr[0][0])) {\r\n          res = arr[0][0];\r\n          return res;\r\n        } else if (pattern2.test(arr[0][0])) {\r\n          if (pattern2.test(arr[0][1])) {\r\n            res = arr[0][0] + arr[0][1];\r\n            if (res != null && res != \"\" && typeof res == \"string\") {\r\n              return res.toUpperCase();\r\n            } else {\r\n              return \"\";\r\n            }\r\n          } else if (pattern.test(arr[0][1])) {\r\n            res = arr[0][1];\r\n            if (res != null && res != \"\" && typeof res == \"string\") {\r\n              return res.toUpperCase();\r\n            } else {\r\n              return \"\";\r\n            }\r\n          }\r\n        }\r\n      }\r\n    } else {\r\n      return \"\";\r\n    }\r\n  }\r\n\r\n  Guid() {\r\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(\r\n      /[xy]/g,\r\n      function (c) {\r\n        let r = (Math.random() * 16) | 0,\r\n          v = c == \"x\" ? r : (r & 0x3) | 0x8;\r\n        return v.toString(16);\r\n      }\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/lib/service/dialog.service.mjs

@@ -0,0 +1,132 @@
+// Angular
+import { Injectable } from "@angular/core";
+import { NewActionNotificationComponent, } from "../dialog/new-action-notification/new-action-notification.component";
+import { CommonDeleteComponent } from "../dialog/common-delete-dialog/index.component";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+import * as i2 from "@angular/material/dialog";
+export var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["Create"] = 0] = "Create";
+    MessageType[MessageType["Read"] = 1] = "Read";
+    MessageType[MessageType["Update"] = 2] = "Update";
+    MessageType[MessageType["Delete"] = 3] = "Delete";
+})(MessageType || (MessageType = {}));
+export class DialogService {
+    snackBar;
+    dialog;
+    /**
+     * Service constructor
+     *
+     * @param snackBar: MatSnackBar
+     * @param dialog: MatDialog
+     */
+    translation = null;
+    constructor(snackBar, dialog) {
+        this.snackBar = snackBar;
+        this.dialog = dialog;
+        this.translation = JSON.parse(localStorage.getItem("translation")) || {};
+    }
+    showLoadingNotification(config) {
+        return this.snackBar.openFromComponent(NewActionNotificationComponent, {
+            data: {
+                ...config,
+                message: config.message ||
+                    this.translation.DOWNLOAD_IS_IN_PROGRESS ||
+                    ".Download is in progress",
+                snackBar: this.snackBar,
+                type: "Loading",
+            },
+            verticalPosition: "top",
+            horizontalPosition: "right",
+            panelClass: "new-action-notification",
+        });
+    }
+    showNotification(message, config) {
+        return this.snackBar.openFromComponent(NewActionNotificationComponent, {
+            data: {
+                message,
+                snackBar: this.snackBar,
+                ...(config || {}),
+            },
+            duration: (config && config.duration) || 3000,
+            verticalPosition: "top",
+            horizontalPosition: "right",
+            panelClass: "new-action-notification",
+        });
+    }
+    // 删除确认弹窗
+    deleteElement() {
+        return this.dialog.open(CommonDeleteComponent, {
+            data: {},
+            panelClass: "rs-dialog-wrap",
+        });
+    }
+    // 自定义文案通用弹窗的提示框
+    showCommonDilaog(data) {
+        return this.dialog.open(CommonDeleteComponent, {
+            data,
+            panelClass: "rs-dialog-wrap",
+        });
+    }
+    // 有改动未保存 的提示框
+    showUnsavedChanges(data) {
+        let defaultData = {
+            title: this.translation.UNSAVED_CHANGES || ".UNSAVED_CHANGES",
+            description: this.translation
+                .YOU_HAVE_UNSAVED_CHANGED_ARE_YOU_SURE_YOU_WANT_TO_DISCARD_THEM ||
+                ".YOU_HAVE_UNSAVED_CHANGED_ARE_YOU_SURE_YOU_WANT_TO_DISCARD_THEM",
+            saveBtnLabel: this.translation.DISCARD_CHANGES || ".DISCARD_CHANGES",
+            cancelBtnLabel: this.translation.CONTINUE_EDITING || ".CONTINUE_EDITING",
+        };
+        if (data) {
+            data = Object.assign(defaultData, data);
+        }
+        else {
+            data = defaultData;
+        }
+        // data.size = "medium";
+        return this.dialog.open(CommonDeleteComponent, {
+            data,
+            panelClass: "rs-dialog-wrap",
+        });
+    }
+    // 保存成功提示
+    showSucMsg(res) {
+        this.showMessage(res, MessageType.Create);
+    }
+    // 更新成功提示
+    showUpdateMsg(res) {
+        this.showMessage(res, MessageType.Update);
+    }
+    // 删除成功提示
+    showDelMsg(res) {
+        this.showMessage(res, MessageType.Delete);
+    }
+    // 通用提示
+    showMessage(res, type = MessageType.Create) {
+        let _saveMessage = this.translation.SAVESUCCESS || ".SAVESUCCESS";
+        switch (type) {
+            case MessageType.Update:
+                _saveMessage = this.translation.UPDATESUCCESS || ".UPDATESUCCESS";
+                break;
+            case MessageType.Delete:
+                _saveMessage = this.translation.DELETESUCCESS || ".DELETESUCCESS";
+                break;
+        }
+        if (res.status === "ERROR")
+            _saveMessage = res.messages[0].message;
+        this.showNotification(_saveMessage, {
+            status: res.status === "ERROR" ? "Error" : "Success",
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, deps: [{ token: i1.MatSnackBar }, { token: i2.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatSnackBar }, { type: i2.MatDialog }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../projects/raise-common-lib/src/lib/service/dialog.service.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EACL,8BAA8B,GAE/B,MAAM,qEAAqE,CAAC;AAE7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;;;;AAEvF,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,iDAAM,CAAA;IACN,6CAAI,CAAA;IACJ,iDAAM,CAAA;IACN,iDAAM,CAAA;AACR,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAKD,MAAM,OAAO,aAAa;IAQJ;IAA+B;IAPnD;;;;;OAKG;IACH,WAAW,GAAG,IAAI,CAAC;IACnB,YAAoB,QAAqB,EAAU,MAAiB;QAAhD,aAAQ,GAAR,QAAQ,CAAa;QAAU,WAAM,GAAN,MAAM,CAAW;QAClE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,IAAI,EAAE,CAAA;IAC1E,CAAC;IAED,uBAAuB,CACrB,MAGwB;QAExB,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,8BAA8B,EAAE;YACrE,IAAI,EAAE;gBACJ,GAAG,MAAM;gBACT,OAAO,EACL,MAAM,CAAC,OAAO;oBACd,IAAI,CAAC,WAAW,CAAC,uBAAuB;oBACxC,0BAA0B;gBAC5B,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,IAAI,EAAE,SAAS;aAChB;YACD,gBAAgB,EAAE,KAAK;YACvB,kBAAkB,EAAE,OAAO;YAC3B,UAAU,EAAE,yBAAyB;SACtC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB,CACd,OAAe,EACf,MAMC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,8BAA8B,EAAE;YACrE,IAAI,EAAE;gBACJ,OAAO;gBACP,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC;aAClB;YACD,QAAQ,EAAE,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI;YAC7C,gBAAgB,EAAE,KAAK;YACvB,kBAAkB,EAAE,OAAO;YAC3B,UAAU,EAAE,yBAAyB;SACtC,CAAC,CAAC;IACL,CAAC;IACD,SAAS;IACT,aAAa;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7C,IAAI,EAAE,EAAE;YACR,UAAU,EAAE,gBAAgB;SAC7B,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,gBAAgB,CAAC,IAQhB;QACC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7C,IAAI;YACJ,UAAU,EAAE,gBAAgB;SAC7B,CAAC,CAAC;IACL,CAAC;IAED,cAAc;IACd,kBAAkB,CAAC,IAQlB;QACC,IAAI,WAAW,GAAG;YAChB,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,eAAe,IAAI,kBAAkB;YAC7D,WAAW,EACT,IAAI,CAAC,WAAW;iBACb,8DAA8D;gBACjE,iEAAiE;YACnE,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,eAAe,IAAI,kBAAkB;YACpE,cAAc,EAAE,IAAI,CAAC,WAAW,CAAC,gBAAgB,IAAI,mBAAmB;SACzE,CAAC;QACF,IAAI,IAAI,EAAE;YACR,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;SACzC;aAAM;YACL,IAAI,GAAG,WAAW,CAAC;SACpB;QACD,wBAAwB;QACxB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE;YAC7C,IAAI;YACJ,UAAU,EAAE,gBAAgB;SAC7B,CAAC,CAAC;IACL,CAAC;IAED,SAAS;IACF,UAAU,CAAC,GAAG;QACnB,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,SAAS;IACF,aAAa,CAAC,GAAG;QACtB,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,SAAS;IACF,UAAU,CAAC,GAAG;QACnB,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO;IACC,WAAW,CAAC,GAAG,EAAE,IAAI,GAAG,WAAW,CAAC,MAAM;QAChD,IAAI,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,IAAI,cAAc,CAAC;QAClE,QAAQ,IAAI,EAAE;YACZ,KAAK,WAAW,CAAC,MAAM;gBACrB,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,IAAI,gBAAgB,CAAC;gBAClE,MAAM;YACR,KAAK,WAAW,CAAC,MAAM;gBACrB,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,IAAI,gBAAgB,CAAC;gBAClE,MAAM;SACT;QACD,IAAI,GAAG,CAAC,MAAM,KAAK,OAAO;YAAE,YAAY,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QACnE,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE;YAClC,MAAM,EAAE,GAAG,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;SACrD,CAAC,CAAC;IACL,CAAC;wGA7IU,aAAa;4GAAb,aAAa,cAFZ,MAAM;;4FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["// Angular\r\nimport { Injectable } from \"@angular/core\";\r\nimport { MatSnackBar } from \"@angular/material/snack-bar\";\r\nimport { MatDialog } from \"@angular/material/dialog\";\r\n\r\nimport {\r\n  NewActionNotificationComponent,\r\n  NotificationConfig,\r\n} from \"../dialog/new-action-notification/new-action-notification.component\";\r\n\r\nimport { CommonDeleteComponent } from \"../dialog/common-delete-dialog/index.component\";\r\n\r\nexport enum MessageType {\r\n  Create,\r\n  Read,\r\n  Update,\r\n  Delete,\r\n}\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class DialogService {\r\n  /**\r\n   * Service constructor\r\n   *\r\n   * @param snackBar: MatSnackBar\r\n   * @param dialog: MatDialog\r\n   */\r\n  translation = null;\r\n  constructor(private snackBar: MatSnackBar, private dialog: MatDialog) {\r\n    this.translation = JSON.parse(localStorage.getItem(\"translation\")) || {}\r\n  }\r\n\r\n  showLoadingNotification(\r\n    config: Omit<\r\n      NotificationConfig,\r\n      \"message\" | \"snackBar\" | \"status\" | \"type\"\r\n    > & { message?: string }\r\n  ) {\r\n    return this.snackBar.openFromComponent(NewActionNotificationComponent, {\r\n      data: {\r\n        ...config,\r\n        message:\r\n          config.message ||\r\n          this.translation.DOWNLOAD_IS_IN_PROGRESS ||\r\n          \".Download is in progress\",\r\n        snackBar: this.snackBar,\r\n        type: \"Loading\",\r\n      },\r\n      verticalPosition: \"top\",\r\n      horizontalPosition: \"right\",\r\n      panelClass: \"new-action-notification\",\r\n    });\r\n  }\r\n\r\n  showNotification(\r\n    message: string,\r\n    config?: Omit<\r\n      NotificationConfig,\r\n      \"message\" | \"snackBar\" | \"loadingCallback\" | \"type\"\r\n    > & {\r\n      duration?: number;\r\n      type?: Exclude<NotificationConfig[\"type\"], \"Loading\">;\r\n    }\r\n  ) {\r\n    return this.snackBar.openFromComponent(NewActionNotificationComponent, {\r\n      data: {\r\n        message,\r\n        snackBar: this.snackBar,\r\n        ...(config || {}),\r\n      },\r\n      duration: (config && config.duration) || 3000,\r\n      verticalPosition: \"top\",\r\n      horizontalPosition: \"right\",\r\n      panelClass: \"new-action-notification\",\r\n    });\r\n  }\r\n  // 删除确认弹窗\r\n  deleteElement() {\r\n    return this.dialog.open(CommonDeleteComponent, {\r\n      data: {},\r\n      panelClass: \"rs-dialog-wrap\",\r\n    });\r\n  }\r\n\r\n  // 自定义文案通用弹窗的提示框\r\n  showCommonDilaog(data?: {\r\n    title?: string;\r\n    description?: string;\r\n    saveBtnLabel?: string;\r\n    cancelBtnLabel?: string;\r\n    showErrorIcon?: boolean;\r\n    size?: string;\r\n    hideSaveBtn?: boolean;\r\n  }) {\r\n    return this.dialog.open(CommonDeleteComponent, {\r\n      data,\r\n      panelClass: \"rs-dialog-wrap\",\r\n    });\r\n  }\r\n\r\n  // 有改动未保存 的提示框\r\n  showUnsavedChanges(data?: {\r\n    title?: string;\r\n    description?: string;\r\n    saveBtnLabel?: string;\r\n    cancelBtnLabel?: string;\r\n    showErrorIcon?: boolean;\r\n    size?: string;\r\n    hideSaveBtn?: boolean;\r\n  }) {\r\n    let defaultData = {\r\n      title: this.translation.UNSAVED_CHANGES || \".UNSAVED_CHANGES\",\r\n      description:\r\n        this.translation\r\n          .YOU_HAVE_UNSAVED_CHANGED_ARE_YOU_SURE_YOU_WANT_TO_DISCARD_THEM ||\r\n        \".YOU_HAVE_UNSAVED_CHANGED_ARE_YOU_SURE_YOU_WANT_TO_DISCARD_THEM\",\r\n      saveBtnLabel: this.translation.DISCARD_CHANGES || \".DISCARD_CHANGES\",\r\n      cancelBtnLabel: this.translation.CONTINUE_EDITING || \".CONTINUE_EDITING\",\r\n    };\r\n    if (data) {\r\n      data = Object.assign(defaultData, data);\r\n    } else {\r\n      data = defaultData;\r\n    }\r\n    // data.size = \"medium\";\r\n    return this.dialog.open(CommonDeleteComponent, {\r\n      data,\r\n      panelClass: \"rs-dialog-wrap\",\r\n    });\r\n  }\r\n\r\n  // 保存成功提示\r\n  public showSucMsg(res) {\r\n    this.showMessage(res, MessageType.Create);\r\n  }\r\n\r\n  // 更新成功提示\r\n  public showUpdateMsg(res) {\r\n    this.showMessage(res, MessageType.Update);\r\n  }\r\n\r\n  // 删除成功提示\r\n  public showDelMsg(res) {\r\n    this.showMessage(res, MessageType.Delete);\r\n  }\r\n\r\n  // 通用提示\r\n  private showMessage(res, type = MessageType.Create) {\r\n    let _saveMessage = this.translation.SAVESUCCESS || \".SAVESUCCESS\";\r\n    switch (type) {\r\n      case MessageType.Update:\r\n        _saveMessage = this.translation.UPDATESUCCESS || \".UPDATESUCCESS\";\r\n        break;\r\n      case MessageType.Delete:\r\n        _saveMessage = this.translation.DELETESUCCESS || \".DELETESUCCESS\";\r\n        break;\r\n    }\r\n    if (res.status === \"ERROR\") _saveMessage = res.messages[0].message;\r\n    this.showNotification(_saveMessage, {\r\n      status: res.status === \"ERROR\" ? \"Error\" : \"Success\",\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/service/drawer.service.mjs

@@ -0,0 +1,111 @@
+import { Injectable } from "@angular/core";
+import { NavigationEnd } from "@angular/router";
+import { filter } from "rxjs/operators";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export const DefaultDrawerConfig = {
+    title: "Title",
+    mode: "inner",
+};
+export class DrawerService {
+    router;
+    uniqueDrawerComponent;
+    resultPromiseResolveMap = new Map();
+    openedSubscription;
+    routerSubscription;
+    ListenChangeCbs = new Set();
+    constructor(router) {
+        this.router = router;
+    }
+    get cacheKey() {
+        return this.router.url;
+    }
+    ngOnDestroy() {
+        this.removeDrawer();
+    }
+    listenRouterChange() {
+        this.routerSubscription = this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => {
+            const drawer = this.uniqueDrawerComponent;
+            drawer && drawer.onRouteChange();
+        });
+    }
+    setDrawer(component) {
+        if (this.uniqueDrawerComponent) {
+            this.removeDrawer();
+        }
+        this.uniqueDrawerComponent = component;
+        this.openedSubscription = component.$isOpened.subscribe((value) => !value && this.hide());
+        this.listenRouterChange();
+    }
+    removeDrawer() {
+        this.openedSubscription && this.openedSubscription.unsubscribe();
+        this.routerSubscription && this.routerSubscription.unsubscribe();
+        this.openedSubscription = null;
+        this.routerSubscription = null;
+        this.uniqueDrawerComponent = null;
+    }
+    show(component, config, data = {}) {
+        const drawer = this.uniqueDrawerComponent;
+        if (!this.checkChange("show", { component, config, data }) ||
+            !drawer ||
+            drawer.$isOpened.getValue()) {
+            return {
+                instance: null,
+                result: null,
+            };
+        }
+        return {
+            instance: drawer.show(component, config, data),
+            result: new Promise((resolve) => {
+                const cacheKey = this.cacheKey;
+                this.resultPromiseResolveMap.set(cacheKey, (value) => {
+                    resolve(value);
+                    this.resultPromiseResolveMap.delete(cacheKey);
+                });
+            }),
+        };
+    }
+    hide() {
+        const drawer = this.uniqueDrawerComponent;
+        const resolve = this.resultPromiseResolveMap.get(this.cacheKey);
+        if (resolve && this.checkChange("hide")) {
+            resolve({ type: "hide" });
+            drawer && drawer.back();
+        }
+    }
+    complete(data) {
+        const drawer = this.uniqueDrawerComponent;
+        const resolve = this.resultPromiseResolveMap.get(this.cacheKey);
+        if (resolve && this.checkChange("complete", { data })) {
+            resolve({ type: "complete", data });
+            drawer && drawer.back();
+        }
+    }
+    deleteCache(cacheKey) {
+        const drawer = this.uniqueDrawerComponent;
+        drawer && drawer.deleteCache(cacheKey);
+    }
+    onChange(callback) {
+        this.ListenChangeCbs.add(callback);
+        return () => {
+            this.ListenChangeCbs.delete(callback);
+        };
+    }
+    checkChange(type, detail = {}) {
+        let cancel = false;
+        const event = { type, cancel: () => (cancel = true), detail };
+        this.ListenChangeCbs.forEach((cb) => cb(event));
+        return !cancel;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawerService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawerService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DrawerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer.service.js","sourceRoot":"","sources":["../../../../../projects/raise-common-lib/src/lib/service/drawer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from \"@angular/core\";\r\nimport { NavigationEnd, Router } from \"@angular/router\";\r\nimport { filter } from \"rxjs/operators\";\r\nimport { Subscription } from \"rxjs\";\r\nimport { DrawerComponent } from \"../layout/drawer/index.component\";\r\n\r\nexport type DrawerConfig = {\r\n  title: string;\r\n  subTitle?: string;\r\n  mode?: \"outer\" | \"inner\";\r\n  top?: number;\r\n};\r\n\r\nexport const DefaultDrawerConfig: Readonly<DrawerConfig> = {\r\n  title: \"Title\",\r\n  mode: \"inner\",\r\n};\r\n\r\nexport type DrawerShowInstance<T> = {\r\n  instance: T;\r\n  result: Promise<{ type: \"complete\" | \"hide\"; data?: any }>;\r\n};\r\n\r\nexport type DrawerChangeEvent = {\r\n  type: \"show\" | \"hide\" | \"complete\";\r\n  cancel: () => void;\r\n  detail: Record<string, any>;\r\n};\r\n\r\nexport type DrawerChangeListener = (event: DrawerChangeEvent) => void;\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class DrawerService implements OnDestroy {\r\n  private uniqueDrawerComponent: DrawerComponent;\r\n  private resultPromiseResolveMap = new Map<string, (value: any) => void>();\r\n\r\n  private openedSubscription: Subscription;\r\n  private routerSubscription: Subscription;\r\n  private ListenChangeCbs: Set<DrawerChangeListener> = new Set();\r\n\r\n  constructor(private router: Router) {}\r\n\r\n  get cacheKey() {\r\n    return this.router.url;\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.removeDrawer();\r\n  }\r\n\r\n  listenRouterChange() {\r\n    this.routerSubscription = this.router.events\r\n      .pipe(filter((event) => event instanceof NavigationEnd))\r\n      .subscribe(() => {\r\n        const drawer = this.uniqueDrawerComponent;\r\n        drawer && drawer.onRouteChange();\r\n      });\r\n  }\r\n\r\n  setDrawer(component: DrawerComponent) {\r\n    if (this.uniqueDrawerComponent) {\r\n      this.removeDrawer();\r\n    }\r\n    this.uniqueDrawerComponent = component;\r\n    this.openedSubscription = component.$isOpened.subscribe(\r\n      (value) => !value && this.hide()\r\n    );\r\n    this.listenRouterChange();\r\n  }\r\n\r\n  removeDrawer() {\r\n    this.openedSubscription && this.openedSubscription.unsubscribe();\r\n    this.routerSubscription && this.routerSubscription.unsubscribe();\r\n    this.openedSubscription = null;\r\n    this.routerSubscription = null;\r\n    this.uniqueDrawerComponent = null;\r\n  }\r\n\r\n  show<T>(\r\n    component: new (...args: any[]) => T,\r\n    config: DrawerConfig,\r\n    data = {}\r\n  ): DrawerShowInstance<T> {\r\n    const drawer = this.uniqueDrawerComponent;\r\n    if (\r\n      !this.checkChange(\"show\", { component, config, data }) ||\r\n      !drawer ||\r\n      drawer.$isOpened.getValue()\r\n    ) {\r\n      return {\r\n        instance: null,\r\n        result: null,\r\n      };\r\n    }\r\n    return {\r\n      instance: drawer.show(component, config, data),\r\n      result: new Promise((resolve) => {\r\n        const cacheKey = this.cacheKey;\r\n        this.resultPromiseResolveMap.set(cacheKey, (value) => {\r\n          resolve(value);\r\n          this.resultPromiseResolveMap.delete(cacheKey);\r\n        });\r\n      }),\r\n    };\r\n  }\r\n\r\n  hide() {\r\n    const drawer = this.uniqueDrawerComponent;\r\n    const resolve = this.resultPromiseResolveMap.get(this.cacheKey);\r\n    if (resolve && this.checkChange(\"hide\")) {\r\n      resolve({ type: \"hide\" });\r\n      drawer && drawer.back();\r\n    }\r\n  }\r\n\r\n  complete(data?: any) {\r\n    const drawer = this.uniqueDrawerComponent;\r\n    const resolve = this.resultPromiseResolveMap.get(this.cacheKey);\r\n    if (resolve && this.checkChange(\"complete\", { data })) {\r\n      resolve({ type: \"complete\", data });\r\n      drawer && drawer.back();\r\n    }\r\n  }\r\n\r\n  deleteCache(cacheKey: string) {\r\n    const drawer = this.uniqueDrawerComponent;\r\n    drawer && drawer.deleteCache(cacheKey);\r\n  }\r\n\r\n  onChange(callback: DrawerChangeListener) {\r\n    this.ListenChangeCbs.add(callback);\r\n    return () => {\r\n      this.ListenChangeCbs.delete(callback);\r\n    };\r\n  }\r\n\r\n  private checkChange(\r\n    type: DrawerChangeEvent[\"type\"],\r\n    detail: Record<string, any> = {}\r\n  ) {\r\n    let cancel = false;\r\n    const event = { type, cancel: () => (cancel = true), detail };\r\n    this.ListenChangeCbs.forEach((cb) => cb(event));\r\n    return !cancel;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/service/icon-loader.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/icon";
+import * as i2 from "@angular/platform-browser";
+export class IconLoaderService {
+    registry;
+    domSanitizer;
+    constructor(registry, domSanitizer) {
+        this.registry = registry;
+        this.domSanitizer = domSanitizer;
+    }
+    registerIcons(list) {
+        list.forEach(({ name, path }) => {
+            this.registry.addSvgIcon(name, this.domSanitizer.bypassSecurityTrustResourceUrl(path));
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IconLoaderService, deps: [{ token: i1.MatIconRegistry }, { token: i2.DomSanitizer }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IconLoaderService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: IconLoaderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MatIconRegistry }, { type: i2.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi1sb2FkZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JhaXNlLWNvbW1vbi1saWIvc3JjL2xpYi9zZXJ2aWNlL2ljb24tbG9hZGVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7OztBQUszQyxNQUFNLE9BQU8saUJBQWlCO0lBRWxCO0lBQ0E7SUFGVixZQUNVLFFBQXlCLEVBQ3pCLFlBQTBCO1FBRDFCLGFBQVEsR0FBUixRQUFRLENBQWlCO1FBQ3pCLGlCQUFZLEdBQVosWUFBWSxDQUFjO0lBQ2pDLENBQUM7SUFFSixhQUFhLENBQUMsSUFBSTtRQUNoQixJQUFJLENBQUMsT0FBTyxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRTtZQUM5QixJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FDdEIsSUFBSSxFQUNKLElBQUksQ0FBQyxZQUFZLENBQUMsOEJBQThCLENBQUMsSUFBSSxDQUFDLENBQ3ZELENBQUM7UUFDSixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7d0dBYlUsaUJBQWlCOzRHQUFqQixpQkFBaUI7OzRGQUFqQixpQkFBaUI7a0JBRDdCLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgTWF0SWNvblJlZ2lzdHJ5IH0gZnJvbSBcIkBhbmd1bGFyL21hdGVyaWFsL2ljb25cIjtcclxuaW1wb3J0IHsgRG9tU2FuaXRpemVyIH0gZnJvbSBcIkBhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXJcIjtcclxuXHJcbkBJbmplY3RhYmxlKClcclxuZXhwb3J0IGNsYXNzIEljb25Mb2FkZXJTZXJ2aWNlIHtcclxuICBjb25zdHJ1Y3RvcihcclxuICAgIHByaXZhdGUgcmVnaXN0cnk6IE1hdEljb25SZWdpc3RyeSxcclxuICAgIHByaXZhdGUgZG9tU2FuaXRpemVyOiBEb21TYW5pdGl6ZXJcclxuICApIHt9XHJcblxyXG4gIHJlZ2lzdGVySWNvbnMobGlzdCkge1xyXG4gICAgbGlzdC5mb3JFYWNoKCh7IG5hbWUsIHBhdGggfSkgPT4ge1xyXG4gICAgICB0aGlzLnJlZ2lzdHJ5LmFkZFN2Z0ljb24oXHJcbiAgICAgICAgbmFtZSxcclxuICAgICAgICB0aGlzLmRvbVNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0UmVzb3VyY2VVcmwocGF0aClcclxuICAgICAgKTtcclxuICAgIH0pO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/service/keep-alive.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+const storedRoutes = new Map();
+let toBeDeleteUrl;
+let excludeRoutes = []; // 不需要缓存的url
+export class KeepAliveService {
+    setExcludeRoutes(routes) {
+        excludeRoutes = routes; // 设置不缓存的路由
+    }
+    shouldDetach(route) {
+        let config = route.routeConfig;
+        // console.log("shouldDetach", toBeDeleteUrl, this.getRoutePath(route));
+        if (toBeDeleteUrl === this.getRoutePath(route)) {
+            // 对于新开的又即将关闭的tab，不缓存
+            if (route.children.length === 0) {
+                toBeDeleteUrl = "";
+            }
+            return false;
+        }
+        if (config && excludeRoutes.includes(this.getRoutePath(route))) {
+            return false;
+        }
+        //Don't store lazy loaded routes
+        return config && !config.loadChildren;
+    }
+    store(route, handle) {
+        // console.log("store", this.getRoutePath(route));
+        // console.log("store", storedRoutes);
+        const key = this.getRoutePath(route);
+        storedRoutes.set(key, handle);
+    }
+    shouldAttach(route) {
+        const key = this.getRoutePath(route);
+        return !!route.routeConfig && storedRoutes.has(key);
+    }
+    retrieve(route) {
+        let config = route.routeConfig;
+        const key = this.getRoutePath(route);
+        //We don't store lazy loaded routes, so don't even bother trying to retrieve them
+        if (!config || config.loadChildren) {
+            return false;
+        }
+        return storedRoutes.get(key) || null;
+    }
+    shouldReuseRoute(future, curr) {
+        // console.log("shouldReuseRoute", future, curr);
+        // return future.routeConfig === curr.routeConfig;
+        if (future.routeConfig === curr.routeConfig) {
+            if (future.children.length === 0 && curr.children.length === 0) {
+                // 无子路由时, 通过params和queryParams判断是否复用路由
+                return (JSON.stringify(future.params) === JSON.stringify(curr.params));
+            }
+            return true;
+        }
+        return false;
+    }
+    getRoutePath(route) {
+        if (route.routeConfig) {
+            // const pathParams = JSON.stringify(route.params);
+            // const queryParams = new URLSearchParams(route.queryParams).toString();
+            const url = route.url.map((v) => v.path).join("/");
+            return "/" + url;
+        }
+        return "";
+    }
+    clearCache(path) {
+        // console.log("clearCache", storedRoutes, path);
+        toBeDeleteUrl = path;
+        storedRoutes.delete(path);
+    }
+    clearAllCache() {
+        storedRoutes.clear();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KeepAliveService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KeepAliveService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KeepAliveService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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