ets-fe-ng-sdk 18.0.67 → 18.0.69

package/esm2022/lib/Services/api.service.mjs

@@ -76,7 +76,7 @@ export class ApiService {
                     .toPromise()
                     .then((r) => {
                     res.next(r);
-                    this.cacheS.setItem(query, r);
+                    // this.cacheS.setItem(query, r);
                     res.complete();
                 })
                     .catch((err) => res.error(err));
@@ -140,6 +140,25 @@ export class ApiService {
                 });
             });
         };
+        this.getFromMemory = (route, parameters, extras) => new Observable((res) => {
+            const query = route + this.getRequestParse(parameters);
+            if (this.cacheS.has(query)) {
+                res.next(this.cacheS.getItem(query));
+                res.complete();
+            }
+            else {
+                lastValueFrom(this.get(query, null, extras))
+                    .then((r) => {
+                    res.next(r);
+                    this.cacheS.setItem(query, r);
+                    res.complete();
+                })
+                    .catch((e) => {
+                    res.error(e);
+                    res.complete();
+                });
+            }
+        });
         //#endregion
         //#region DELETE
         this.delete = (route, extras) => {
@@ -339,4 +358,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../projects/ets-fe-ng-sdk/src/lib/Services/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest } from '@angular/common/http';\nimport { iif, lastValueFrom, Observable, throwError } from 'rxjs';\nimport { catchError, map, retry, tap } from 'rxjs/operators';\nimport { ICodeDescription, ICodeTitle, IObjectLiteral } from '../Shared/models/index.model';\nimport { environment } from '../../environments/environment';\nimport { CacheService } from './cache/cache.service';\nimport { LocalCacheService } from './cache/local-cache.service';\nimport { partial } from 'lodash-es';\nexport interface IResponse {\n  message: string;\n  result: any;\n  status: 'success' | 'error' | 'failure';\n  statusCode: 'SM000' | 'SM001' | 'SM002' | 'SM003';\n}\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApiService {\n  private showRoutes = 0;\n  private get headers() {\n    return {\n      'Content-Type': 'application/json',\n    };\n  }\n  protected get fileHeaders() {\n    return {\n      enctype: 'multipart/form-data',\n    };\n  }\n\n  baseURL = '';\n  private retryCount = 0;\n  public http = inject(HttpClient);\n  public cacheS = inject(CacheService);\n  public lCacheS = inject(LocalCacheService);\n\n  constructor() {}\n\n  private logRoutes(method: 'get' | 'post' | 'put' | 'delete', route, ...extras) {\n    if (this.showRoutes) {\n      console.log(method, route, ...extras);\n    }\n  }\n  protected handleRequestError = (err: HttpErrorResponse) => {\n    let message;\n    if (err?.error instanceof ArrayBuffer)\n      message = String.fromCharCode.apply(null, new Uint8Array(err?.error));\n    return throwError(message || err?.error?.message);\n  };\n  protected concatenateHeaders = (headers1: HttpHeaders, headers2: HttpHeaders): HttpHeaders => {\n    if (!headers1) return headers2;\n    else if (!headers2) return headers1;\n\n    let headers = new HttpHeaders();\n    for (const item of headers1.keys()) headers = headers.set(item, headers1.get(item));\n    for (const item of headers2.keys()) {\n      if (headers.has(item)) headers.delete(item);\n      headers = headers.set(item, headers2.get(item));\n    }\n    return headers;\n  };\n\n  //#region PATCH\n  patch<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .patch(encodeURI(this.baseURL + route), body, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  //#endregion\n  //#region POST\n  // post<TBody = any>(route: string, body?: TBody, extras?: IExtras): Observable<TBody>;\n  // post<T = any>(route: string, body?: any, extras?: IExtras): Observable<T>;\n  post<T = any>(route: string, body?: any, extras?: IExtras): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n\n    return this.http\n      .post(encodeURI(this.baseURL + route), body, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  postFile<T = any>(route: string, body: FormData, extras?: any) {\n    // return this.post<T>(route, body, {\n    //   options: {\n    //     responseType: 'json',\n    //     ...extras?.options,\n    //     headers: this.concatenateHeaders(\n    //       new HttpHeaders({\n    //         enctype: 'multipart/form-data',\n    //       }),\n    //       extras?.options?.headers\n    //     ),\n    //   },\n    // });\n\n    return this.http\n      .post(encodeURI(this.baseURL + route), body, {\n        // responseType: 'json',\n        ...extras?.options,\n        // headers: this.concatenateHeaders(\n        //   new HttpHeaders({\n        //     enctype: 'multipart/form-data',\n        //   }),\n        //   extras?.options?.headers\n        // ),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<T>;\n  }\n  postFileWithEndorsement<T = any>(route: string, body: FormData) {\n    return this.post<T>(route, body, {\n      options: {\n        headers: new HttpHeaders().set('useEndorsement', 'true'),\n      },\n    });\n  }\n  postString(route: string, body?, extras?: IExtras) {\n    // console.log('requestCount', ++ETSenvironment.requestCount);\n    let headers = new HttpHeaders({\n      'Content-Type': 'text/plain',\n    });\n    headers = extras?.useEndorsement ? headers.set('useEndorsement', 'true') : headers;\n    return this.post<string>(route, body, {\n      options: {\n        ...extras?.options,\n        responseType: 'text',\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      },\n    });\n  }\n  postStringWithLocalCache(route: string, body: string) {\n    return new Observable<string>((res) => {\n      const bdy = body?.trim();\n      // debugger\n      if (this.lCacheS.has(route + '_' + bdy)) {\n        res.next(this.lCacheS.getItem<string>(route + '_' + bdy));\n      }\n\n      this.postString(route, bdy)\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          this.lCacheS.setItem(route + '_' + bdy, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n        });\n    });\n  }\n  //#endregion\n\n  //#region GET\n  /**\n   * Perform a GET request\n   * @param route API endpoint\n   * @param parameters Object to convert into queryparams\n   * @param extras Extra configurations for the request\n   * @returns\n   */\n  get = <T = any>(route: string, parameters?: IObjectLiteral, extras?: IExtras): Observable<T> => {\n    this.logRoutes('get', route, parameters);\n    return new Observable<T>((res) => {\n      const query = this.baseURL + route + this.getRequestParse(parameters);\n      this.http\n        .get(query, {\n          headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n          responseType: 'json',\n          ...extras?.options,\n        })\n        .pipe(\n          retry(this.retryCount),\n          tap((x) => (this.showRoutes ? console.log(x) : null)),\n          map((res: any) => {\n            if (Array.isArray(res))\n              if (res[0]?.code) return res.sort().sort2('code', true);\n              else if (res[0]?.columnName) return res.sort().sort2('columnName', true);\n              else return res.sort();\n            return res;\n          }),\n          catchError(this.handleRequestError),\n        )\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          this.cacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((err) => res.error(err));\n    });\n  };\n\n  getCodes = <T extends ICodeTitle | ICodeDescription = ICodeTitle & ICodeDescription>(\n    route: string,\n  ) => this.get<T[]>(route).pipe(map((res) => this.sortCodes(res)));\n\n  getText = <T = string>(\n    route: string,\n    parameters?: { [field: string]: string | number | boolean },\n    extras?: IExtras,\n  ) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n        responseType: 'text',\n      },\n    });\n\n  getFile = <T = string>(\n    route: string,\n    parameters?: { [field: string]: string | number | boolean },\n    extras?: IExtras,\n  ) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n        responseType: 'arrayBuffer',\n      },\n    });\n\n  getWithBody = <T = any>(route: string, body?: any, extras?: IExtras) => {\n    this.logRoutes('get', route);\n    // debugger\n    const req = new HttpRequest('GET', this.baseURL + route, body, {\n      ...extras?.options,\n      headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      responseType: 'json',\n    });\n    return this.http.request<T>(req).pipe(catchError(this.handleRequestError)) as Observable<T>;\n  };\n\n  getFromlocal = <T = any>(route: string, parameters?: Object, extras?: IExtras) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n        res.complete();\n      } else\n        lastValueFrom(this.get(query, null, extras)).then((r) => {\n          // if (!this.cS.has(route))\n          res.next(r);\n          this.lCacheS.setItem(query, r);\n          res.complete();\n        });\n    });\n  };\n  getWithLocalCache = <T = any>(route: string, parameters?: Object, extras?: IExtras) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n      }\n      lastValueFrom(this.get(query, null, extras))\n        .then((r) => {\n          // if (!this.cS.has(route))\n          res.next(r);\n          this.lCacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n          res.complete();\n        });\n    });\n  };\n  getRequestParse(parameters?: Object) {\n    return !parameters\n      ? ''\n      : '?' +\n          Object.keys(parameters)\n            .filter((key) => parameters[key]?.toString()?.trim() != null)\n            .map((key) => `${key}=${parameters[key]?.toString()?.trim()}`)\n            .join('&');\n  }\n  //#endregion\n\n  //#region PUT\n  put<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('put', route, body);\n    let query = this.baseURL + route + '',\n      nbody = body;\n    if (extras?.requestType == 'queryParams') {\n      query += this.getRequestParse(body);\n      nbody = null;\n    }\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .put(query, nbody, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  putFile<T = any>(route: string, body: FormData, extras?: any) {\n    return this.http\n      .put(encodeURI(this.baseURL + route), body, {\n        // responseType: 'json',\n        ...extras?.options,\n        // headers: this.concatenateHeaders(\n        //   new HttpHeaders({\n        //     enctype: 'multipart/form-data',\n        //   }),\n        //   extras?.options?.headers\n        // ),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<T>;\n  }\n  putFileWithEndorsement<T = any>(route: string, body: FormData) {\n    return this.put<T>(route, body, {\n      options: {\n        headers: new HttpHeaders().set('useEndorsement', 'true'),\n      },\n    });\n  }\n  //#endregion\n\n  //#region DELETE\n  delete = <T = any>(route: string, extras?: IExtras) => {\n    this.logRoutes('delete', route);\n\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .delete<T>(this.baseURL + route, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteWithBody = <T = any>(route: string, body?: any, extras?: IExtras) => {\n    this.logRoutes('delete', route);\n    const req = new HttpRequest('DELETE', this.baseURL + route, body, {\n      responseType: 'json',\n      ...extras?.options,\n      headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n    });\n    return this.http.request<T>(req).pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteText = (route: string, extras?: IExtras) =>\n    this.delete<string>(route, {\n      options: {\n        responseType: 'text',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      },\n    });\n  //#endregion\n\n  sortCodes = <T extends { code: string }>(data: T[]) => {\n    return data?.sort2('code', true)?.sort2('code') as any as T[];\n  };\n}\n\ninterface IExtras {\n  /**\n   * Specify whether to use the endorsement header\n   */\n  useEndorsement?: boolean;\n  /**\n   * Report progress of the request\n   */\n  reportProgress?: boolean;\n  /**\n   * Specify the request options. The added options will be appended to the default options\n   */\n  options?: {\n    headers?: HttpHeaders;\n    [x: string]: any;\n  };\n  /**\n   * Specify the request type. If the request type is queryParams, the body will be sent as query parameters\n   */\n  requestType?: 'queryParams';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../projects/ets-fe-ng-sdk/src/lib/Services/api.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAqB,WAAW,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC/F,OAAO,EAAO,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAG7D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;;AAWhE,MAAM,OAAO,UAAU;IAErB,IAAY,OAAO;QACjB,OAAO;YACL,cAAc,EAAE,kBAAkB;SACnC,CAAC;IACJ,CAAC;IACD,IAAc,WAAW;QACvB,OAAO;YACL,OAAO,EAAE,qBAAqB;SAC/B,CAAC;IACJ,CAAC;IAQD;QAlBQ,eAAU,GAAG,CAAC,CAAC;QAYvB,YAAO,GAAG,EAAE,CAAC;QACL,eAAU,GAAG,CAAC,CAAC;QAChB,SAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,WAAM,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAC9B,YAAO,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QASjC,uBAAkB,GAAG,CAAC,GAAsB,EAAE,EAAE;YACxD,IAAI,OAAO,CAAC;YACZ,IAAI,GAAG,EAAE,KAAK,YAAY,WAAW;gBACnC,OAAO,GAAG,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;YACxE,OAAO,UAAU,CAAC,OAAO,IAAI,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QACpD,CAAC,CAAC;QACQ,uBAAkB,GAAG,CAAC,QAAqB,EAAE,QAAqB,EAAe,EAAE;YAC3F,IAAI,CAAC,QAAQ;gBAAE,OAAO,QAAQ,CAAC;iBAC1B,IAAI,CAAC,QAAQ;gBAAE,OAAO,QAAQ,CAAC;YAEpC,IAAI,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;YAChC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE;gBAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YACpF,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;gBACnC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;oBAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC5C,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC;QAwGF,YAAY;QAEZ,aAAa;QACb;;;;;;WAMG;QACH,QAAG,GAAG,CAAU,KAAa,EAAE,UAA2B,EAAE,MAAgB,EAAiB,EAAE;YAC7F,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;YACzC,OAAO,IAAI,UAAU,CAAI,CAAC,GAAG,EAAE,EAAE;gBAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,GAAG,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;gBACtE,IAAI,CAAC,IAAI;qBACN,GAAG,CAAC,KAAK,EAAE;oBACV,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;oBACzF,YAAY,EAAE,MAAM;oBACpB,GAAG,MAAM,EAAE,OAAO;iBACnB,CAAC;qBACD,IAAI,CACH,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,EACtB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EACrD,GAAG,CAAC,CAAC,GAAQ,EAAE,EAAE;oBACf,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;wBACpB,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI;4BAAE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;6BACnD,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,UAAU;4BAAE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;;4BACpE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC;oBACzB,OAAO,GAAG,CAAC;gBACb,CAAC,CAAC,EACF,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CACpC;qBACA,SAAS,EAAE;qBACX,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBACV,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACZ,iCAAiC;oBACjC,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;YACpC,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,aAAQ,GAAG,CACT,KAAa,EACb,EAAE,CAAC,IAAI,CAAC,GAAG,CAAM,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAElE,YAAO,GAAG,CACR,KAAa,EACb,UAA2D,EAC3D,MAAgB,EAChB,EAAE,CACF,IAAI,CAAC,GAAG,CAAI,KAAK,EAAE,UAAU,EAAE;YAC7B,OAAO,EAAE;gBACP,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;gBACzF,YAAY,EAAE,MAAM;aACrB;SACF,CAAC,CAAC;QAEL,YAAO,GAAG,CACR,KAAa,EACb,UAA2D,EAC3D,MAAgB,EAChB,EAAE,CACF,IAAI,CAAC,GAAG,CAAI,KAAK,EAAE,UAAU,EAAE;YAC7B,OAAO,EAAE;gBACP,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;gBACzF,YAAY,EAAE,aAAa;aAC5B;SACF,CAAC,CAAC;QAEL,gBAAW,GAAG,CAAU,KAAa,EAAE,IAAU,EAAE,MAAgB,EAAE,EAAE;YACrE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAC7B,WAAW;YACX,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,GAAG,KAAK,EAAE,IAAI,EAAE;gBAC7D,GAAG,MAAM,EAAE,OAAO;gBAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;gBACzF,YAAY,EAAE,MAAM;aACrB,CAAC,CAAC;YACH,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAI,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAkB,CAAC;QAC9F,CAAC,CAAC;QAEF,iBAAY,GAAG,CAAU,KAAa,EAAE,UAAmB,EAAE,MAAgB,EAAE,EAAE;YAC/E,OAAO,IAAI,UAAU,CAAI,CAAC,GAAG,EAAE,EAAE;gBAC/B,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;gBACvD,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAI,KAAK,CAAC,CAAC,CAAC;oBACzC,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC;;oBACC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;wBACtD,2BAA2B;wBAC3B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;wBACZ,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;wBAC/B,GAAG,CAAC,QAAQ,EAAE,CAAC;oBACjB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QACF,sBAAiB,GAAG,CAAU,KAAa,EAAE,UAAmB,EAAE,MAAgB,EAAE,EAAE;YACpF,OAAO,IAAI,UAAU,CAAI,CAAC,GAAG,EAAE,EAAE;gBAC/B,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;gBACvD,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC5B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAI,KAAK,CAAC,CAAC,CAAC;gBAC3C,CAAC;gBACD,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;qBACzC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBACV,2BAA2B;oBAC3B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACZ,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;oBAC/B,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;oBACX,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACb,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QACF,kBAAa,GAAG,CAAI,KAAa,EAAE,UAAmB,EAAE,MAAgB,EAAE,EAAE,CAC1E,IAAI,UAAU,CAAI,CAAC,GAAG,EAAE,EAAE;YACxB,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YACvD,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3B,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAI,KAAK,CAAC,CAAC,CAAC;gBACxC,GAAG,CAAC,QAAQ,EAAE,CAAC;YACjB,CAAC;iBAAM,CAAC;gBACN,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;qBACzC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBACV,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACZ,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;oBAC9B,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC,CAAC;qBACD,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;oBACX,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACb,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,CAAC,CAAC,CAAC;YACP,CAAC;QACH,CAAC,CAAC,CAAC;QAqDL,YAAY;QAEZ,gBAAgB;QAChB,WAAM,GAAG,CAAU,KAAa,EAAE,MAAgB,EAAE,EAAE;YACpD,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAEhC,IAAI,OAAO,GAAG,MAAM,EAAE,cAAc;gBAClC,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAC7D,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAClC,OAAO,IAAI,CAAC,IAAI;iBACb,MAAM,CAAI,IAAI,CAAC,OAAO,GAAG,KAAK,EAAE;gBAC/B,YAAY,EAAE,MAAM;gBACpB,GAAG,MAAM,EAAE,OAAO;gBAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;aAC1F,CAAC;iBACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAoB,CAAC;QAClE,CAAC,CAAC;QACF,mBAAc,GAAG,CAAU,KAAa,EAAE,IAAU,EAAE,MAAgB,EAAE,EAAE;YACxE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YAChC,MAAM,GAAG,GAAG,IAAI,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,GAAG,KAAK,EAAE,IAAI,EAAE;gBAChE,YAAY,EAAE,MAAM;gBACpB,GAAG,MAAM,EAAE,OAAO;gBAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;aAC1F,CAAC,CAAC;YACH,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAI,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAoB,CAAC;QAChG,CAAC,CAAC;QACF,eAAU,GAAG,CAAC,KAAa,EAAE,MAAgB,EAAE,EAAE,CAC/C,IAAI,CAAC,MAAM,CAAS,KAAK,EAAE;YACzB,OAAO,EAAE;gBACP,YAAY,EAAE,MAAM;gBACpB,GAAG,MAAM,EAAE,OAAO;gBAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;aAC1F;SACF,CAAC,CAAC;QACL,YAAY;QAEZ,cAAS,GAAG,CAA6B,IAAS,EAAE,EAAE;YACpD,OAAO,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAe,CAAC;QAChE,CAAC,CAAC;IAhWa,CAAC;IAER,SAAS,CAAC,MAAyC,EAAE,KAAK,EAAE,GAAG,MAAM;QAC3E,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAoBD,eAAe;IACf,KAAK,CAAU,KAAa,EAAE,IAAK,EAAE,MAAgB;QACnD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QACpC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClB,IAAI,OAAO,GAAG,MAAM,EAAE,cAAc;YAClC,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;YAC7D,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC,IAAI;aACb,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE;YAC5C,YAAY,EAAE,MAAM;YACpB,GAAG,MAAM,EAAE,OAAO;YAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;SACpE,CAAC;aACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAoB,CAAC;IAClE,CAAC;IACD,YAAY;IACZ,cAAc;IACd,uFAAuF;IACvF,6EAA6E;IAC7E,IAAI,CAAU,KAAa,EAAE,IAAU,EAAE,MAAgB;QACvD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QACpC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClB,IAAI,OAAO,GAAG,MAAM,EAAE,cAAc;YAClC,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;YAC7D,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAElC,OAAO,IAAI,CAAC,IAAI;aACb,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE;YAC3C,YAAY,EAAE,MAAM;YACpB,GAAG,MAAM,EAAE,OAAO;YAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;SACpE,CAAC;aACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAoB,CAAC;IAClE,CAAC;IACD,QAAQ,CAAU,KAAa,EAAE,IAAc,EAAE,MAAY;QAC3D,qCAAqC;QACrC,eAAe;QACf,4BAA4B;QAC5B,0BAA0B;QAC1B,wCAAwC;QACxC,0BAA0B;QAC1B,0CAA0C;QAC1C,YAAY;QACZ,iCAAiC;QACjC,SAAS;QACT,OAAO;QACP,MAAM;QAEN,OAAO,IAAI,CAAC,IAAI;aACb,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE;YAC3C,wBAAwB;YACxB,GAAG,MAAM,EAAE,OAAO;YAClB,oCAAoC;YACpC,sBAAsB;YACtB,sCAAsC;YACtC,QAAQ;YACR,6BAA6B;YAC7B,KAAK;SACN,CAAC;aACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAkB,CAAC;IAChE,CAAC;IACD,uBAAuB,CAAU,KAAa,EAAE,IAAc;QAC5D,OAAO,IAAI,CAAC,IAAI,CAAI,KAAK,EAAE,IAAI,EAAE;YAC/B,OAAO,EAAE;gBACP,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;aACzD;SACF,CAAC,CAAC;IACL,CAAC;IACD,UAAU,CAAC,KAAa,EAAE,IAAK,EAAE,MAAgB;QAC/C,8DAA8D;QAC9D,IAAI,OAAO,GAAG,IAAI,WAAW,CAAC;YAC5B,cAAc,EAAE,YAAY;SAC7B,CAAC,CAAC;QACH,OAAO,GAAG,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QACnF,OAAO,IAAI,CAAC,IAAI,CAAS,KAAK,EAAE,IAAI,EAAE;YACpC,OAAO,EAAE;gBACP,GAAG,MAAM,EAAE,OAAO;gBAClB,YAAY,EAAE,MAAM;gBACpB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;aACpE;SACF,CAAC,CAAC;IACL,CAAC;IACD,wBAAwB,CAAC,KAAa,EAAE,IAAY;QAClD,OAAO,IAAI,UAAU,CAAS,CAAC,GAAG,EAAE,EAAE;YACpC,MAAM,GAAG,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC;YACzB,WAAW;YACX,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,GAAG,GAAG,CAAC,EAAE,CAAC;gBACxC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAS,KAAK,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;YAC5D,CAAC;YAED,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC;iBACxB,SAAS,EAAE;iBACX,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;gBACV,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBACZ,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC3C,GAAG,CAAC,QAAQ,EAAE,CAAC;YACjB,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBACX,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACf,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAuID,eAAe,CAAC,UAAmB;QACjC,OAAO,CAAC,UAAU;YAChB,CAAC,CAAC,EAAE;YACJ,CAAC,CAAC,GAAG;gBACD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC;qBACpB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC;qBAC5D,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC;qBAC7D,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,YAAY;IAEZ,aAAa;IACb,GAAG,CAAU,KAAa,EAAE,IAAK,EAAE,MAAgB;QACjD,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QACnC,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,GAAG,KAAK,GAAG,EAAE,EACnC,KAAK,GAAG,IAAI,CAAC;QACf,IAAI,MAAM,EAAE,WAAW,IAAI,aAAa,EAAE,CAAC;YACzC,KAAK,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;YACpC,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;QACD,IAAI,OAAO,GAAG,MAAM,EAAE,cAAc;YAClC,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;YAC7D,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC,IAAI;aACb,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE;YACjB,YAAY,EAAE,MAAM;YACpB,GAAG,MAAM,EAAE,OAAO;YAClB,OAAO,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;SAC1F,CAAC;aACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAoB,CAAC;IAClE,CAAC;IACD,OAAO,CAAU,KAAa,EAAE,IAAc,EAAE,MAAY;QAC1D,OAAO,IAAI,CAAC,IAAI;aACb,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE;YAC1C,wBAAwB;YACxB,GAAG,MAAM,EAAE,OAAO;YAClB,oCAAoC;YACpC,sBAAsB;YACtB,sCAAsC;YACtC,QAAQ;YACR,6BAA6B;YAC7B,KAAK;SACN,CAAC;aACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAkB,CAAC;IAChE,CAAC;IACD,sBAAsB,CAAU,KAAa,EAAE,IAAc;QAC3D,OAAO,IAAI,CAAC,GAAG,CAAI,KAAK,EAAE,IAAI,EAAE;YAC9B,OAAO,EAAE;gBACP,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC,GAAG,CAAC,gBAAgB,EAAE,MAAM,CAAC;aACzD;SACF,CAAC,CAAC;IACL,CAAC;8GA5UU,UAAU;kHAAV,UAAU,cAFT,MAAM;;2FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { HttpClient, HttpErrorResponse, HttpHeaders, HttpRequest } from '@angular/common/http';\nimport { iif, lastValueFrom, Observable, throwError } from 'rxjs';\nimport { catchError, map, retry, tap } from 'rxjs/operators';\nimport { ICodeDescription, ICodeTitle, IObjectLiteral } from '../Shared/models/index.model';\nimport { environment } from '../../environments/environment';\nimport { CacheService } from './cache/cache.service';\nimport { LocalCacheService } from './cache/local-cache.service';\nimport { partial } from 'lodash-es';\nexport interface IResponse {\n  message: string;\n  result: any;\n  status: 'success' | 'error' | 'failure';\n  statusCode: 'SM000' | 'SM001' | 'SM002' | 'SM003';\n}\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApiService {\n  private showRoutes = 0;\n  private get headers() {\n    return {\n      'Content-Type': 'application/json',\n    };\n  }\n  protected get fileHeaders() {\n    return {\n      enctype: 'multipart/form-data',\n    };\n  }\n\n  baseURL = '';\n  private retryCount = 0;\n  public http = inject(HttpClient);\n  public cacheS = inject(CacheService);\n  public lCacheS = inject(LocalCacheService);\n\n  constructor() {}\n\n  private logRoutes(method: 'get' | 'post' | 'put' | 'delete', route, ...extras) {\n    if (this.showRoutes) {\n      console.log(method, route, ...extras);\n    }\n  }\n  protected handleRequestError = (err: HttpErrorResponse) => {\n    let message;\n    if (err?.error instanceof ArrayBuffer)\n      message = String.fromCharCode.apply(null, new Uint8Array(err?.error));\n    return throwError(message || err?.error?.message);\n  };\n  protected concatenateHeaders = (headers1: HttpHeaders, headers2: HttpHeaders): HttpHeaders => {\n    if (!headers1) return headers2;\n    else if (!headers2) return headers1;\n\n    let headers = new HttpHeaders();\n    for (const item of headers1.keys()) headers = headers.set(item, headers1.get(item));\n    for (const item of headers2.keys()) {\n      if (headers.has(item)) headers.delete(item);\n      headers = headers.set(item, headers2.get(item));\n    }\n    return headers;\n  };\n\n  //#region PATCH\n  patch<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .patch(encodeURI(this.baseURL + route), body, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  //#endregion\n  //#region POST\n  // post<TBody = any>(route: string, body?: TBody, extras?: IExtras): Observable<TBody>;\n  // post<T = any>(route: string, body?: any, extras?: IExtras): Observable<T>;\n  post<T = any>(route: string, body?: any, extras?: IExtras): Observable<T> {\n    this.logRoutes('post', route, body);\n    console.log(body);\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n\n    return this.http\n      .post(encodeURI(this.baseURL + route), body, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  postFile<T = any>(route: string, body: FormData, extras?: any) {\n    // return this.post<T>(route, body, {\n    //   options: {\n    //     responseType: 'json',\n    //     ...extras?.options,\n    //     headers: this.concatenateHeaders(\n    //       new HttpHeaders({\n    //         enctype: 'multipart/form-data',\n    //       }),\n    //       extras?.options?.headers\n    //     ),\n    //   },\n    // });\n\n    return this.http\n      .post(encodeURI(this.baseURL + route), body, {\n        // responseType: 'json',\n        ...extras?.options,\n        // headers: this.concatenateHeaders(\n        //   new HttpHeaders({\n        //     enctype: 'multipart/form-data',\n        //   }),\n        //   extras?.options?.headers\n        // ),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<T>;\n  }\n  postFileWithEndorsement<T = any>(route: string, body: FormData) {\n    return this.post<T>(route, body, {\n      options: {\n        headers: new HttpHeaders().set('useEndorsement', 'true'),\n      },\n    });\n  }\n  postString(route: string, body?, extras?: IExtras) {\n    // console.log('requestCount', ++ETSenvironment.requestCount);\n    let headers = new HttpHeaders({\n      'Content-Type': 'text/plain',\n    });\n    headers = extras?.useEndorsement ? headers.set('useEndorsement', 'true') : headers;\n    return this.post<string>(route, body, {\n      options: {\n        ...extras?.options,\n        responseType: 'text',\n        headers: this.concatenateHeaders(headers, extras?.options?.headers),\n      },\n    });\n  }\n  postStringWithLocalCache(route: string, body: string) {\n    return new Observable<string>((res) => {\n      const bdy = body?.trim();\n      // debugger\n      if (this.lCacheS.has(route + '_' + bdy)) {\n        res.next(this.lCacheS.getItem<string>(route + '_' + bdy));\n      }\n\n      this.postString(route, bdy)\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          this.lCacheS.setItem(route + '_' + bdy, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n        });\n    });\n  }\n  //#endregion\n\n  //#region GET\n  /**\n   * Perform a GET request\n   * @param route API endpoint\n   * @param parameters Object to convert into queryparams\n   * @param extras Extra configurations for the request\n   * @returns\n   */\n  get = <T = any>(route: string, parameters?: IObjectLiteral, extras?: IExtras): Observable<T> => {\n    this.logRoutes('get', route, parameters);\n    return new Observable<T>((res) => {\n      const query = this.baseURL + route + this.getRequestParse(parameters);\n      this.http\n        .get(query, {\n          headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n          responseType: 'json',\n          ...extras?.options,\n        })\n        .pipe(\n          retry(this.retryCount),\n          tap((x) => (this.showRoutes ? console.log(x) : null)),\n          map((res: any) => {\n            if (Array.isArray(res))\n              if (res[0]?.code) return res.sort().sort2('code', true);\n              else if (res[0]?.columnName) return res.sort().sort2('columnName', true);\n              else return res.sort();\n            return res;\n          }),\n          catchError(this.handleRequestError),\n        )\n        .toPromise()\n        .then((r) => {\n          res.next(r);\n          // this.cacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((err) => res.error(err));\n    });\n  };\n\n  getCodes = <T extends ICodeTitle | ICodeDescription = ICodeTitle & ICodeDescription>(\n    route: string,\n  ) => this.get<T[]>(route).pipe(map((res) => this.sortCodes(res)));\n\n  getText = <T = string>(\n    route: string,\n    parameters?: { [field: string]: string | number | boolean },\n    extras?: IExtras,\n  ) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n        responseType: 'text',\n      },\n    });\n\n  getFile = <T = string>(\n    route: string,\n    parameters?: { [field: string]: string | number | boolean },\n    extras?: IExtras,\n  ) =>\n    this.get<T>(route, parameters, {\n      options: {\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n        responseType: 'arrayBuffer',\n      },\n    });\n\n  getWithBody = <T = any>(route: string, body?: any, extras?: IExtras) => {\n    this.logRoutes('get', route);\n    // debugger\n    const req = new HttpRequest('GET', this.baseURL + route, body, {\n      ...extras?.options,\n      headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      responseType: 'json',\n    });\n    return this.http.request<T>(req).pipe(catchError(this.handleRequestError)) as Observable<T>;\n  };\n\n  getFromlocal = <T = any>(route: string, parameters?: Object, extras?: IExtras) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n        res.complete();\n      } else\n        lastValueFrom(this.get(query, null, extras)).then((r) => {\n          // if (!this.cS.has(route))\n          res.next(r);\n          this.lCacheS.setItem(query, r);\n          res.complete();\n        });\n    });\n  };\n  getWithLocalCache = <T = any>(route: string, parameters?: Object, extras?: IExtras) => {\n    return new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.lCacheS.has(query)) {\n        res.next(this.lCacheS.getItem<T>(query));\n      }\n      lastValueFrom(this.get(query, null, extras))\n        .then((r) => {\n          // if (!this.cS.has(route))\n          res.next(r);\n          this.lCacheS.setItem(query, r);\n          res.complete();\n        })\n        .catch((e) => {\n          res.error(e);\n          res.complete();\n        });\n    });\n  };\n  getFromMemory = <T>(route: string, parameters?: Object, extras?: IExtras) =>\n    new Observable<T>((res) => {\n      const query = route + this.getRequestParse(parameters);\n      if (this.cacheS.has(query)) {\n        res.next(this.cacheS.getItem<T>(query));\n        res.complete();\n      } else {\n        lastValueFrom(this.get(query, null, extras))\n          .then((r) => {\n            res.next(r);\n            this.cacheS.setItem(query, r);\n            res.complete();\n          })\n          .catch((e) => {\n            res.error(e);\n            res.complete();\n          });\n      }\n    });\n  getRequestParse(parameters?: Object) {\n    return !parameters\n      ? ''\n      : '?' +\n          Object.keys(parameters)\n            .filter((key) => parameters[key]?.toString()?.trim() != null)\n            .map((key) => `${key}=${parameters[key]?.toString()?.trim()}`)\n            .join('&');\n  }\n  //#endregion\n\n  //#region PUT\n  put<T = any>(route: string, body?, extras?: IExtras): Observable<T> {\n    this.logRoutes('put', route, body);\n    let query = this.baseURL + route + '',\n      nbody = body;\n    if (extras?.requestType == 'queryParams') {\n      query += this.getRequestParse(body);\n      nbody = null;\n    }\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .put(query, nbody, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  }\n  putFile<T = any>(route: string, body: FormData, extras?: any) {\n    return this.http\n      .put(encodeURI(this.baseURL + route), body, {\n        // responseType: 'json',\n        ...extras?.options,\n        // headers: this.concatenateHeaders(\n        //   new HttpHeaders({\n        //     enctype: 'multipart/form-data',\n        //   }),\n        //   extras?.options?.headers\n        // ),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<T>;\n  }\n  putFileWithEndorsement<T = any>(route: string, body: FormData) {\n    return this.put<T>(route, body, {\n      options: {\n        headers: new HttpHeaders().set('useEndorsement', 'true'),\n      },\n    });\n  }\n  //#endregion\n\n  //#region DELETE\n  delete = <T = any>(route: string, extras?: IExtras) => {\n    this.logRoutes('delete', route);\n\n    let headers = extras?.useEndorsement\n      ? new HttpHeaders(this.headers).set('useEndorsement', 'true')\n      : new HttpHeaders(this.headers);\n    return this.http\n      .delete<T>(this.baseURL + route, {\n        responseType: 'json',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      })\n      .pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteWithBody = <T = any>(route: string, body?: any, extras?: IExtras) => {\n    this.logRoutes('delete', route);\n    const req = new HttpRequest('DELETE', this.baseURL + route, body, {\n      responseType: 'json',\n      ...extras?.options,\n      headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n    });\n    return this.http.request<T>(req).pipe(catchError(this.handleRequestError)) as Observable<any>;\n  };\n  deleteText = (route: string, extras?: IExtras) =>\n    this.delete<string>(route, {\n      options: {\n        responseType: 'text',\n        ...extras?.options,\n        headers: this.concatenateHeaders(new HttpHeaders(this.headers), extras?.options?.headers),\n      },\n    });\n  //#endregion\n\n  sortCodes = <T extends { code: string }>(data: T[]) => {\n    return data?.sort2('code', true)?.sort2('code') as any as T[];\n  };\n}\n\ninterface IExtras {\n  /**\n   * Specify whether to use the endorsement header\n   */\n  useEndorsement?: boolean;\n  /**\n   * Report progress of the request\n   */\n  reportProgress?: boolean;\n  /**\n   * Specify the request options. The added options will be appended to the default options\n   */\n  options?: {\n    headers?: HttpHeaders;\n    [x: string]: any;\n  };\n  /**\n   * Specify the request type. If the request type is queryParams, the body will be sent as query parameters\n   */\n  requestType?: 'queryParams';\n}\n"]}

package/esm2022/lib/Services/cache/cache.service.mjs

@@ -6,7 +6,7 @@ export class CacheService {
     constructor() {
         this._cache = {};
         this.uS = inject(UtilityService);
-        this.has = (key) => !!this._cache[key];
+        this.has = (key) => this._cache[key] != null;
         this.getItem = (key) => this._cache[key];
     }
     get cache() {
@@ -39,4 +39,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/Services/cache/local-cache.service.mjs

@@ -58,4 +58,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/Shared/components/toggle-input-form/toggle-input-form.component.mjs

@@ -20,6 +20,8 @@ export class ToggleInputFormComponent {
         this.uS = inject(UtilityService);
         this.addToFormFunc = input();
         this.defaultToggleAll = input();
+        this.hideSearchMenu = input();
+        this.hideGridMenu = input();
         this.deleteFromFormFunc = input();
         this.gridNo = model(6);
         this.labelField = input();
@@ -137,7 +139,7 @@ export class ToggleInputFormComponent {
         this.selectedMap.set({});
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ToggleInputFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: ToggleInputFormComponent, isStandalone: true, selector: "toggle-input-form", inputs: { addToFormFunc: { classPropertyName: "addToFormFunc", publicName: "addToFormFunc", isSignal: true, isRequired: false, transformFunction: null }, defaultToggleAll: { classPropertyName: "defaultToggleAll", publicName: "defaultToggleAll", isSignal: true, isRequired: false, transformFunction: null }, deleteFromFormFunc: { classPropertyName: "deleteFromFormFunc", publicName: "deleteFromFormFunc", isSignal: true, isRequired: false, transformFunction: null }, gridNo: { classPropertyName: "gridNo", publicName: "gridNo", isSignal: true, isRequired: false, transformFunction: null }, labelField: { classPropertyName: "labelField", publicName: "labelField", isSignal: true, isRequired: false, transformFunction: null }, labelSeparator: { classPropertyName: "labelSeparator", publicName: "labelSeparator", isSignal: true, isRequired: false, transformFunction: null }, searchQuery: { classPropertyName: "searchQuery", publicName: "searchQuery", isSignal: true, isRequired: false, transformFunction: null }, showToggleAll: { classPropertyName: "showToggleAll", publicName: "showToggleAll", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: true, transformFunction: null }, checkedChecker: { classPropertyName: "checkedChecker", publicName: "checkedChecker", isSignal: true, isRequired: true, transformFunction: null }, _list: { classPropertyName: "_list", publicName: "list", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { gridNo: "gridNoChange", searchQuery: "searchQueryChange", selected: "selected" }, ngImport: i0, template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\">\n        <div class=\"col-auto\">\n          <app-btn\n            iconBtn\n            [showHelpIcon]=\"false\"\n            help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n            [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n            (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n        </div>\n        <div class=\"col-auto\" [hidden]=\"true\" #searchBox>\n          <app-input-td-rf\n            type=\"text\"\n            [noFormat]=\"true\"\n            [showLabel]=\"false\"\n            placeholder=\"Type to search\"\n            [(model)]=\"searchQuery\" />\n        </div>\n        <div class=\"col-auto\">\n          <app-btn\n            customIcon=\"fa fa-list\"\n            [showHelpIcon]=\"false\"\n            help=\"Grid Style\"\n            [matMenuTriggerFor]=\"gridMenu\" />\n          <mat-menu #gridMenu=\"matMenu\" class=\"\">\n            @for (item of columnLengths(); track item.value) {\n              <button\n                mat-menu-item\n                (click)=\"gridNo.set(item.value)\"\n                [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                {{ item.label | appTranslate | async }}\n              </button>\n            }\n          </mat-menu>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle\n              [checked]=\"item.checked\"\n              (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i2.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "component", type: BtnComponent, selector: "app-btn", inputs: ["formSchema", "debug", "centerBtn", "danger", "warning", "verbose", "translatorOptions", "loading", "icon", "rightIcon", "leftIcon", "type", "group", "actionType", "animate", "excludeLogging", "loggingValue", "badge", "class", "customIcon", "form", "forms", "help", "iconBtn", "mclass", "showHelpIcon", "rightCustomIcon", "leftCustomIcon", "text", "valid", "mini", "onFormInvalid", "disabled"], outputs: ["loadingChange", "leftCustomIconChange", "mclick", "disabledChange"] }, { kind: "pipe", type: FilterArrayByStringPipe, name: "filterArrayByString" }, { kind: "component", type: InputTD_RFComponent, selector: "app-input-td-rf", inputs: ["validators", "asyncValidators", "model"], outputs: ["modelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i4.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "pipe", type: SDKTranslatePipe, name: "appTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: ToggleInputFormComponent, isStandalone: true, selector: "toggle-input-form", inputs: { addToFormFunc: { classPropertyName: "addToFormFunc", publicName: "addToFormFunc", isSignal: true, isRequired: false, transformFunction: null }, defaultToggleAll: { classPropertyName: "defaultToggleAll", publicName: "defaultToggleAll", isSignal: true, isRequired: false, transformFunction: null }, hideSearchMenu: { classPropertyName: "hideSearchMenu", publicName: "hideSearchMenu", isSignal: true, isRequired: false, transformFunction: null }, hideGridMenu: { classPropertyName: "hideGridMenu", publicName: "hideGridMenu", isSignal: true, isRequired: false, transformFunction: null }, deleteFromFormFunc: { classPropertyName: "deleteFromFormFunc", publicName: "deleteFromFormFunc", isSignal: true, isRequired: false, transformFunction: null }, gridNo: { classPropertyName: "gridNo", publicName: "gridNo", isSignal: true, isRequired: false, transformFunction: null }, labelField: { classPropertyName: "labelField", publicName: "labelField", isSignal: true, isRequired: false, transformFunction: null }, labelSeparator: { classPropertyName: "labelSeparator", publicName: "labelSeparator", isSignal: true, isRequired: false, transformFunction: null }, searchQuery: { classPropertyName: "searchQuery", publicName: "searchQuery", isSignal: true, isRequired: false, transformFunction: null }, showToggleAll: { classPropertyName: "showToggleAll", publicName: "showToggleAll", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: true, transformFunction: null }, checkedChecker: { classPropertyName: "checkedChecker", publicName: "checkedChecker", isSignal: true, isRequired: true, transformFunction: null }, _list: { classPropertyName: "_list", publicName: "list", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { gridNo: "gridNoChange", searchQuery: "searchQueryChange", selected: "selected" }, ngImport: i0, template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\" [hidden]=\"hideSearchMenu() && hideGridMenu()\">\n        @if (!hideSearchMenu()) {\n          <div class=\"col-auto d-flex align-items-center\">\n            <app-btn\n              iconBtn\n              [showHelpIcon]=\"false\"\n              help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n              [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n              (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n            <div class=\"ms-1\" [hidden]=\"true\" #searchBox>\n              <app-input-td-rf\n                type=\"text\"\n                [noFormat]=\"true\"\n                [showLabel]=\"false\"\n                placeholder=\"Type to search\"\n                [(model)]=\"searchQuery\" />\n            </div>\n          </div>\n        }\n        @if (!hideGridMenu()) {\n          <div class=\"col-auto\">\n            <app-btn\n              customIcon=\"fa fa-list\"\n              [showHelpIcon]=\"false\"\n              help=\"Grid Style\"\n              [matMenuTriggerFor]=\"gridMenu\" />\n            <mat-menu #gridMenu=\"matMenu\" class=\"\">\n              @for (item of columnLengths(); track item.value) {\n                <button\n                  mat-menu-item\n                  (click)=\"gridNo.set(item.value)\"\n                  [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                  {{ item.label | appTranslate | async }}\n                </button>\n              }\n            </mat-menu>\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle [checked]=\"item.checked\" (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i2.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "component", type: BtnComponent, selector: "app-btn", inputs: ["formSchema", "debug", "centerBtn", "danger", "warning", "verbose", "translatorOptions", "loading", "icon", "rightIcon", "leftIcon", "type", "group", "actionType", "animate", "excludeLogging", "loggingValue", "badge", "class", "customIcon", "form", "forms", "help", "iconBtn", "mclass", "showHelpIcon", "rightCustomIcon", "leftCustomIcon", "text", "valid", "mini", "onFormInvalid", "disabled"], outputs: ["loadingChange", "leftCustomIconChange", "mclick", "disabledChange"] }, { kind: "pipe", type: FilterArrayByStringPipe, name: "filterArrayByString" }, { kind: "component", type: InputTD_RFComponent, selector: "app-input-td-rf", inputs: ["validators", "asyncValidators", "model"], outputs: ["modelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i4.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "pipe", type: SDKTranslatePipe, name: "appTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ToggleInputFormComponent, decorators: [{
             type: Component,
@@ -151,6 +153,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                         MatTooltipModule,
                         MatMenuModule,
                         SDKTranslatePipe,
-                    ], template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\">\n        <div class=\"col-auto\">\n          <app-btn\n            iconBtn\n            [showHelpIcon]=\"false\"\n            help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n            [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n            (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n        </div>\n        <div class=\"col-auto\" [hidden]=\"true\" #searchBox>\n          <app-input-td-rf\n            type=\"text\"\n            [noFormat]=\"true\"\n            [showLabel]=\"false\"\n            placeholder=\"Type to search\"\n            [(model)]=\"searchQuery\" />\n        </div>\n        <div class=\"col-auto\">\n          <app-btn\n            customIcon=\"fa fa-list\"\n            [showHelpIcon]=\"false\"\n            help=\"Grid Style\"\n            [matMenuTriggerFor]=\"gridMenu\" />\n          <mat-menu #gridMenu=\"matMenu\" class=\"\">\n            @for (item of columnLengths(); track item.value) {\n              <button\n                mat-menu-item\n                (click)=\"gridNo.set(item.value)\"\n                [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                {{ item.label | appTranslate | async }}\n              </button>\n            }\n          </mat-menu>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle\n              [checked]=\"item.checked\"\n              (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"] }]
+                    ], template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\" [hidden]=\"hideSearchMenu() && hideGridMenu()\">\n        @if (!hideSearchMenu()) {\n          <div class=\"col-auto d-flex align-items-center\">\n            <app-btn\n              iconBtn\n              [showHelpIcon]=\"false\"\n              help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n              [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n              (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n            <div class=\"ms-1\" [hidden]=\"true\" #searchBox>\n              <app-input-td-rf\n                type=\"text\"\n                [noFormat]=\"true\"\n                [showLabel]=\"false\"\n                placeholder=\"Type to search\"\n                [(model)]=\"searchQuery\" />\n            </div>\n          </div>\n        }\n        @if (!hideGridMenu()) {\n          <div class=\"col-auto\">\n            <app-btn\n              customIcon=\"fa fa-list\"\n              [showHelpIcon]=\"false\"\n              help=\"Grid Style\"\n              [matMenuTriggerFor]=\"gridMenu\" />\n            <mat-menu #gridMenu=\"matMenu\" class=\"\">\n              @for (item of columnLengths(); track item.value) {\n                <button\n                  mat-menu-item\n                  (click)=\"gridNo.set(item.value)\"\n                  [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                  {{ item.label | appTranslate | async }}\n                </button>\n              }\n            </mat-menu>\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle [checked]=\"item.checked\" (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"] }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggle-input-form.component.js","sourceRoot":"","sources":["../../../../../../../projects/ets-fe-ng-sdk/src/lib/Shared/components/toggle-input-form/toggle-input-form.component.ts","../../../../../../../projects/ets-fe-ng-sdk/src/lib/Shared/components/toggle-input-form/toggle-input-form.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EACL,SAAS,EAAE,QAAQ,EACnB,MAAM,EACN,MAAM,EACN,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,uBAAuB,EACxB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;;;;;;AAqB9D,MAAM,OAAO,wBAAwB;IAlBrC;QAmBqB,OAAE,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAEtC,kBAAa,GAAG,KAAK,EAA2B,CAAC;QACjD,qBAAgB,GAAG,KAAK,EAAW,CAAC;QACpC,uBAAkB,GAAG,KAAK,EAA2B,CAAC;QACtD,WAAM,GAAG,KAAK,CAAW,CAAC,CAAC,CAAC;QAC5B,eAAU,GAAG,KAAK,EAAqC,CAAC;QACxD,mBAAc,GAAG,KAAK,CAAS,KAAK,CAAC,CAAC;QACtC,gBAAW,GAAG,KAAK,EAAU,CAAC;QAC9B,kBAAa,GAAG,KAAK,CAAU,IAAI,CAAC,CAAC;QACrC,eAAU,GAAG,KAAK,CAAC,QAAQ,EAAuC,CAAC;QAC5E;;;;aAIK;QACI,mBAAc,GAAG,KAAK,CAAC,QAAQ,EAAkD,CAAC;QAClF,UAAK,GAAG,KAAK,CAAC,QAAQ,CAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAErD,aAAQ,GAAG,MAAM,EAAa,CAAC;QAExC,kEAAkE;QAC/C,iBAAY,GAAG,QAAQ,CAAgB,GAAG,EAAE;YAC7D,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAChD,OAAO,OAAO,iBAAiB,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,iBAAiB,CAAC;QAC3E,CAAC,CAAC,CAAC;QACgB,qBAAgB,GAAG,QAAQ,CAA+B,GAAG,EAAE;YAChF,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAChD,OAAO,OAAO,iBAAiB,IAAI,UAAU,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3E,CAAC,CAAC,CAAC;QACgB,gBAAW,GAAG,QAAQ,CAA2B,GAAG,EAAE;YACvE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,EAC7B,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,EAC9B,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,EAC9B,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,EACtC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,EAClC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,EAC1C,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAE5F,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBAC3B,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC;gBACzB,KAAK,EAAE,WAAW,CAAC,gBAAgB,CACjC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,UAAU,CAAW,CAAC,EAC/D,cAAc,CACf;gBACD,WAAW,EAAE,MAAM;gBACnB,gBAAgB,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC,MAAM,CAAC;aACrF,CAAC,CAAC,CAAC;QACN,CAAC,CAAC,CAAC;QACgB,gBAAW,GAAG,MAAM,CAA+B,EAAE,CAAC,CAAC;QACvD,SAAI,GAAG,QAAQ,CAA2B,GAAG,EAAE;YAChE,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,EAC1C,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC;YAEzC,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;gBAChC,OAAO;oBACL,GAAG,MAAM;oBACT,OAAO,EACL,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB;iBAC1F,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEgB,4BAAuB,GAAG,MAAM,CAAU,KAAK,CAAC,CAAC;QAEjD,iBAAY,GAAG,MAAM,CAAS,SAAS,CAAC,CAAC;QACnD,gBAAW,GAAG,QAAQ,CAAS,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;QAChD,YAAO,GAAG,QAAQ,CAAS,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAChD,WAAM,GAAG,QAAQ,CAAS,GAAG,EAAE;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QACjC,CAAC,CAAC,CAAC;QACgB,WAAM,GAAG,QAAQ,CAAS,GAAG,EAAE;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,EACvB,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YACzB,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QAChD,CAAC,CAAC,CAAC;QAEgB,2BAAsB,GAAG,MAAM,CAChD,GAAG,EAAE;YACH,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,EACtB,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,EAAE,EAC1C,uBAAuB,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAE3D,IAAI,CAAC,uBAAuB,IAAI,gBAAgB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;gBACjF,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACvC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;YACpC,CAAC;QACH,CAAC,EACD,EAAE,iBAAiB,EAAE,IAAI,EAAE,CAC5B,CAAC;QAEiB,kBAAa,GAAG,QAAQ,CAAuC,GAAG,EAAE,CAAC;YACtF,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE;YAC3B,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE;YAC3B,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE;YAC7B,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE;YAC7B,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE;SAC/B,CAAC,CAAC;KAoDJ;IAlDW,UAAU,CAAC,CAAuB,EAAE,IAA4B,EAAE,IAAI,GAAG,IAAI;QACrF,IAAI,CAAC,CAAC,OAAO;YAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;;YACrC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAES,SAAS,CAAC,IAA4B,EAAE,IAAI,GAAG,IAAI;QAC3D,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrE,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACzC,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAES,WAAW,CAAC,IAA4B,EAAE,IAAI,GAAG,IAAI;QAC7D,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAES,SAAS,CAAC,CAAuB;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QACvC,IAAI,CAAC,CAAC,OAAO;YACX,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC3B,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBAC5B,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC3C,CAAC,CAAC,CAAC;;YAEH,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC3B,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBAC9B,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;QACL,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAES,YAAY;QACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,IAAI,CAAC,IAAI,EAAE;aACR,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;aACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAC7B,CAAC;IACJ,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED,KAAK;QACH,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3B,CAAC;8GAtJU,wBAAwB;kGAAxB,wBAAwB,2rDC1CrC,8+EAuEA,+EDxCI,YAAY,iLACZ,oBAAoB,mWACpB,YAAY,mhBACZ,uBAAuB,4DACvB,mBAAmB,yIACnB,WAAW,8BACX,gBAAgB,4TAChB,aAAa,yvBACb,gBAAgB;;2FAGP,wBAAwB;kBAlBpC,SAAS;+BACE,mBAAmB,cACjB,IAAI,mBAGC,uBAAuB,CAAC,MAAM,WACtC;wBACP,YAAY;wBACZ,oBAAoB;wBACpB,YAAY;wBACZ,uBAAuB;wBACvB,mBAAmB;wBACnB,WAAW;wBACX,gBAAgB;wBAChB,aAAa;wBACb,gBAAgB;qBACjB","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component, computed,\n  effect,\n  inject,\n  input,\n  model,\n  output,\n  signal,\n  ChangeDetectionStrategy\n} from '@angular/core';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { BtnComponent } from '../btn/btn.component';\nimport { InputTD_RFComponent } from '../input/input-td-rf.component';\nimport { FormsModule } from '@angular/forms';\nimport { SDKTranslatePipe } from '../../pipes/translate.pipe';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { FilterArrayByStringPipe } from '../../pipes/utility.pipe';\nimport { IToggleOption } from './toggle-input-form.model';\nimport { UtilityService } from '../../../Services/utility.service';\nimport { EVFunctions } from '../../../configs/base-functions';\nimport { KeyOfType } from '../../models/index.model';\n\n@Component({\n  selector: 'toggle-input-form',\n  standalone: true,\n  templateUrl: './toggle-input-form.component.html',\n  styleUrl: './toggle-input-form.component.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    CommonModule,\n    MatSlideToggleModule,\n    BtnComponent,\n    FilterArrayByStringPipe,\n    InputTD_RFComponent,\n    FormsModule,\n    MatTooltipModule,\n    MatMenuModule,\n    SDKTranslatePipe,\n  ],\n})\nexport class ToggleInputFormComponent<TOption> {\n  protected readonly uS = inject(UtilityService);\n\n  readonly addToFormFunc = input<(data?: TOption) => any>();\n  readonly defaultToggleAll = input<boolean>();\n  readonly deleteFromFormFunc = input<(data?: TOption) => any>();\n  readonly gridNo = model<GridSize>(6);\n  readonly labelField = input<keyof TOption | (keyof TOption)[]>();\n  readonly labelSeparator = input<string>(' - ');\n  readonly searchQuery = model<string>();\n  readonly showToggleAll = input<boolean>(true);\n  readonly valueField = input.required<KeyOfType<TOption, string | number>>();\n  /**\n   * If you pass a field name: Checks if value exists in the specified field. If it is a boolean field, it checks if it is true.\n   *\n   * If you pass a predicate function: Checks each object using the predicate function to evaluate it is checked or not.\n   * */\n  readonly checkedChecker = input.required<keyof TOption | ((option: TOption) => boolean)>();\n  readonly _list = input.required<TOption[]>({ alias: 'list' });\n\n  readonly selected = output<TOption[]>();\n\n  // protected readonly list = signal<IToggleOption<TOption>[]>([]);\n  protected readonly checkedField = computed<keyof TOption>(() => {\n    const _checkedPredicate = this.checkedChecker();\n    return typeof _checkedPredicate == 'function' ? null : _checkedPredicate;\n  });\n  protected readonly checkedPredicate = computed<(option: TOption) => boolean>(() => {\n    const _checkedPredicate = this.checkedChecker();\n    return typeof _checkedPredicate == 'function' ? _checkedPredicate : null;\n  });\n  protected readonly initialList = computed<IToggleOption<TOption>[]>(() => {\n    const list = this._list() || [],\n      valueField = this.valueField(),\n      labelField = this.labelField(),\n      labelSeparator = this.labelSeparator(),\n      checkedField = this.checkedField(),\n      checkedPredicate = this.checkedPredicate(),\n      labelFields = labelField ? (Array.isArray(labelField) ? labelField : [labelField]) : null;\n\n    return list.map((option) => ({\n      value: option[valueField],\n      label: EVFunctions.strConcatenator2(\n        labelFields.map((labelField) => option?.[labelField] as string),\n        labelSeparator,\n      ),\n      originalRow: option,\n      initiallyChecked: checkedField ? !!option[checkedField] : checkedPredicate?.(option),\n    }));\n  });\n  protected readonly selectedMap = signal<{ [value: string]: boolean }>({});\n  protected readonly list = computed<IToggleOption<TOption>[]>(() => {\n    const initialList = this.initialList() || [],\n      selectedMap = this.selectedMap() || {};\n\n    return initialList.map((option) => {\n      return {\n        ...option,\n        checked:\n          selectedMap[option.value] != null ? selectedMap[option.value] : option.initiallyChecked,\n      };\n    });\n  });\n\n  protected readonly hasHandledDefaultToggle = signal<boolean>(false);\n\n  protected readonly _currentGrid = signal<number>(undefined);\n  readonly currentGrid = computed<number>(() => this._currentGrid());\n  protected readonly xxlGrid = computed<number>(() => this.gridNo());\n  protected readonly lgGrid = computed<number>(() => {\n    const num = this.gridNo();\n    return num > 3 ? num - 1 : num;\n  });\n  protected readonly mdGrid = computed<number>(() => {\n    const num = this.gridNo(),\n      lgGrid = this.lgGrid();\n    return num > 3 ? Math.floor(lgGrid / 2) : num;\n  });\n\n  protected readonly defaultToggleAllEffect = effect(\n    () => {\n      const list = this.list(),\n        defaultToggleAll = this.defaultToggleAll(),\n        hasHandledDefaultToggle = this.hasHandledDefaultToggle();\n\n      if (!hasHandledDefaultToggle && defaultToggleAll && !list.some((x) => x.checked)) {\n        this.hasHandledDefaultToggle.set(true);\n        this.toggleAll({ checked: true });\n      }\n    },\n    { allowSignalWrites: true },\n  );\n\n  protected readonly columnLengths = computed<{ label: string; value: GridSize }[]>(() => [\n    { label: `List`, value: 1 },\n    { label: `Dual`, value: 2 },\n    { label: `Triple`, value: 3 },\n    { label: `Medium`, value: 4 },\n    { label: `Maximum`, value: 6 },\n  ]);\n\n  protected toggleItem(e: { checked: boolean }, item: IToggleOption<TOption>, emit = true) {\n    if (e.checked) this.checkItem(item, emit);\n    else this.uncheckItem(item, emit);\n  }\n\n  protected checkItem(item: IToggleOption<TOption>, emit = true) {\n    this.selectedMap.update((mapp) => ({ ...mapp, [item.value]: true }));\n    if (!emit) return;\n    this.addToFormFunc()?.(item.originalRow);\n    this.emitSelected();\n  }\n\n  protected uncheckItem(item: IToggleOption<TOption>, emit = true) {\n    this.selectedMap.update((mapp) => ({ ...mapp, [item.value]: false }));\n    if (!emit) return;\n    this.deleteFromFormFunc()?.(item.originalRow);\n    this.emitSelected();\n  }\n\n  protected toggleAll(e: { checked: boolean }) {\n    const initialList = this.initialList();\n    if (e.checked)\n      initialList.forEach((item) => {\n        this.checkItem(item, false);\n        this.addToFormFunc()?.(item.originalRow);\n      });\n    else\n      initialList.forEach((item) => {\n        this.uncheckItem(item, false);\n        this.deleteFromFormFunc()?.(item.originalRow);\n      });\n    this.emitSelected();\n  }\n\n  protected emitSelected() {\n    this.selected.emit(\n      this.list()\n        .filter((x) => x.checked)\n        .map((x) => x.originalRow),\n    );\n  }\n\n  getState() {\n    return this.list();\n  }\n\n  reset() {\n    this.hasHandledDefaultToggle.set(false);\n    this.selectedMap.set({});\n  }\n}\ntype GridSize = 6 | 4 | 3 | 2 | 1;\n","<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\">\n        <div class=\"col-auto\">\n          <app-btn\n            iconBtn\n            [showHelpIcon]=\"false\"\n            help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n            [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n            (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n        </div>\n        <div class=\"col-auto\" [hidden]=\"true\" #searchBox>\n          <app-input-td-rf\n            type=\"text\"\n            [noFormat]=\"true\"\n            [showLabel]=\"false\"\n            placeholder=\"Type to search\"\n            [(model)]=\"searchQuery\" />\n        </div>\n        <div class=\"col-auto\">\n          <app-btn\n            customIcon=\"fa fa-list\"\n            [showHelpIcon]=\"false\"\n            help=\"Grid Style\"\n            [matMenuTriggerFor]=\"gridMenu\" />\n          <mat-menu #gridMenu=\"matMenu\" class=\"\">\n            @for (item of columnLengths(); track item.value) {\n              <button\n                mat-menu-item\n                (click)=\"gridNo.set(item.value)\"\n                [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                {{ item.label | appTranslate | async }}\n              </button>\n            }\n          </mat-menu>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle\n              [checked]=\"item.checked\"\n              (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggle-input-form.component.js","sourceRoot":"","sources":["../../../../../../../projects/ets-fe-ng-sdk/src/lib/Shared/components/toggle-input-form/toggle-input-form.component.ts","../../../../../../../projects/ets-fe-ng-sdk/src/lib/Shared/components/toggle-input-form/toggle-input-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component, computed,\n  effect,\n  inject,\n  input,\n  model,\n  output,\n  signal,\n  ChangeDetectionStrategy\n} from '@angular/core';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { BtnComponent } from '../btn/btn.component';\nimport { InputTD_RFComponent } from '../input/input-td-rf.component';\nimport { FormsModule } from '@angular/forms';\nimport { SDKTranslatePipe } from '../../pipes/translate.pipe';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { FilterArrayByStringPipe } from '../../pipes/utility.pipe';\nimport { IToggleOption } from './toggle-input-form.model';\nimport { UtilityService } from '../../../Services/utility.service';\nimport { EVFunctions } from '../../../configs/base-functions';\nimport { KeyOfType } from '../../models/index.model';\n\n@Component({\n  selector: 'toggle-input-form',\n  standalone: true,\n  templateUrl: './toggle-input-form.component.html',\n  styleUrl: './toggle-input-form.component.scss',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    CommonModule,\n    MatSlideToggleModule,\n    BtnComponent,\n    FilterArrayByStringPipe,\n    InputTD_RFComponent,\n    FormsModule,\n    MatTooltipModule,\n    MatMenuModule,\n    SDKTranslatePipe,\n  ],\n})\nexport class ToggleInputFormComponent<TOption> {\n  protected readonly uS = inject(UtilityService);\n\n  readonly addToFormFunc = input<(data?: TOption) => any>();\n  readonly defaultToggleAll = input<boolean>();\n  readonly hideSearchMenu = input<boolean>();\n  readonly hideGridMenu = input<boolean>();\n  readonly deleteFromFormFunc = input<(data?: TOption) => any>();\n  readonly gridNo = model<GridSize>(6);\n  readonly labelField = input<keyof TOption | (keyof TOption)[]>();\n  readonly labelSeparator = input<string>(' - ');\n  readonly searchQuery = model<string>();\n  readonly showToggleAll = input<boolean>(true);\n  readonly valueField = input.required<KeyOfType<TOption, string | number>>();\n  /**\n   * If you pass a field name: Checks if value exists in the specified field. If it is a boolean field, it checks if it is true.\n   *\n   * If you pass a predicate function: Checks each object using the predicate function to evaluate it is checked or not.\n   * */\n  readonly checkedChecker = input.required<keyof TOption | ((option: TOption) => boolean)>();\n  readonly _list = input.required<TOption[]>({ alias: 'list' });\n\n  readonly selected = output<TOption[]>();\n\n  // protected readonly list = signal<IToggleOption<TOption>[]>([]);\n  protected readonly checkedField = computed<keyof TOption>(() => {\n    const _checkedPredicate = this.checkedChecker();\n    return typeof _checkedPredicate == 'function' ? null : _checkedPredicate;\n  });\n  protected readonly checkedPredicate = computed<(option: TOption) => boolean>(() => {\n    const _checkedPredicate = this.checkedChecker();\n    return typeof _checkedPredicate == 'function' ? _checkedPredicate : null;\n  });\n  protected readonly initialList = computed<IToggleOption<TOption>[]>(() => {\n    const list = this._list() || [],\n      valueField = this.valueField(),\n      labelField = this.labelField(),\n      labelSeparator = this.labelSeparator(),\n      checkedField = this.checkedField(),\n      checkedPredicate = this.checkedPredicate(),\n      labelFields = labelField ? (Array.isArray(labelField) ? labelField : [labelField]) : null;\n\n    return list.map((option) => ({\n      value: option[valueField],\n      label: EVFunctions.strConcatenator2(\n        labelFields.map((labelField) => option?.[labelField] as string),\n        labelSeparator,\n      ),\n      originalRow: option,\n      initiallyChecked: checkedField ? !!option[checkedField] : checkedPredicate?.(option),\n    }));\n  });\n  protected readonly selectedMap = signal<{ [value: string]: boolean }>({});\n  protected readonly list = computed<IToggleOption<TOption>[]>(() => {\n    const initialList = this.initialList() || [],\n      selectedMap = this.selectedMap() || {};\n\n    return initialList.map((option) => {\n      return {\n        ...option,\n        checked:\n          selectedMap[option.value] != null ? selectedMap[option.value] : option.initiallyChecked,\n      };\n    });\n  });\n\n  protected readonly hasHandledDefaultToggle = signal<boolean>(false);\n\n  protected readonly _currentGrid = signal<number>(undefined);\n  readonly currentGrid = computed<number>(() => this._currentGrid());\n  protected readonly xxlGrid = computed<number>(() => this.gridNo());\n  protected readonly lgGrid = computed<number>(() => {\n    const num = this.gridNo();\n    return num > 3 ? num - 1 : num;\n  });\n  protected readonly mdGrid = computed<number>(() => {\n    const num = this.gridNo(),\n      lgGrid = this.lgGrid();\n    return num > 3 ? Math.floor(lgGrid / 2) : num;\n  });\n\n  protected readonly defaultToggleAllEffect = effect(\n    () => {\n      const list = this.list(),\n        defaultToggleAll = this.defaultToggleAll(),\n        hasHandledDefaultToggle = this.hasHandledDefaultToggle();\n\n      if (!hasHandledDefaultToggle && defaultToggleAll && !list.some((x) => x.checked)) {\n        this.hasHandledDefaultToggle.set(true);\n        this.toggleAll({ checked: true });\n      }\n    },\n    { allowSignalWrites: true },\n  );\n\n  protected readonly columnLengths = computed<{ label: string; value: GridSize }[]>(() => [\n    { label: `List`, value: 1 },\n    { label: `Dual`, value: 2 },\n    { label: `Triple`, value: 3 },\n    { label: `Medium`, value: 4 },\n    { label: `Maximum`, value: 6 },\n  ]);\n\n  protected toggleItem(e: { checked: boolean }, item: IToggleOption<TOption>, emit = true) {\n    if (e.checked) this.checkItem(item, emit);\n    else this.uncheckItem(item, emit);\n  }\n\n  protected checkItem(item: IToggleOption<TOption>, emit = true) {\n    this.selectedMap.update((mapp) => ({ ...mapp, [item.value]: true }));\n    if (!emit) return;\n    this.addToFormFunc()?.(item.originalRow);\n    this.emitSelected();\n  }\n\n  protected uncheckItem(item: IToggleOption<TOption>, emit = true) {\n    this.selectedMap.update((mapp) => ({ ...mapp, [item.value]: false }));\n    if (!emit) return;\n    this.deleteFromFormFunc()?.(item.originalRow);\n    this.emitSelected();\n  }\n\n  protected toggleAll(e: { checked: boolean }) {\n    const initialList = this.initialList();\n    if (e.checked)\n      initialList.forEach((item) => {\n        this.checkItem(item, false);\n        this.addToFormFunc()?.(item.originalRow);\n      });\n    else\n      initialList.forEach((item) => {\n        this.uncheckItem(item, false);\n        this.deleteFromFormFunc()?.(item.originalRow);\n      });\n    this.emitSelected();\n  }\n\n  protected emitSelected() {\n    this.selected.emit(\n      this.list()\n        .filter((x) => x.checked)\n        .map((x) => x.originalRow),\n    );\n  }\n\n  getState() {\n    return this.list();\n  }\n\n  reset() {\n    this.hasHandledDefaultToggle.set(false);\n    this.selectedMap.set({});\n  }\n}\ntype GridSize = 6 | 4 | 3 | 2 | 1;\n","<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\" [hidden]=\"hideSearchMenu() && hideGridMenu()\">\n        @if (!hideSearchMenu()) {\n          <div class=\"col-auto d-flex align-items-center\">\n            <app-btn\n              iconBtn\n              [showHelpIcon]=\"false\"\n              help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n              [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n              (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n            <div class=\"ms-1\" [hidden]=\"true\" #searchBox>\n              <app-input-td-rf\n                type=\"text\"\n                [noFormat]=\"true\"\n                [showLabel]=\"false\"\n                placeholder=\"Type to search\"\n                [(model)]=\"searchQuery\" />\n            </div>\n          </div>\n        }\n        @if (!hideGridMenu()) {\n          <div class=\"col-auto\">\n            <app-btn\n              customIcon=\"fa fa-list\"\n              [showHelpIcon]=\"false\"\n              help=\"Grid Style\"\n              [matMenuTriggerFor]=\"gridMenu\" />\n            <mat-menu #gridMenu=\"matMenu\" class=\"\">\n              @for (item of columnLengths(); track item.value) {\n                <button\n                  mat-menu-item\n                  (click)=\"gridNo.set(item.value)\"\n                  [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                  {{ item.label | appTranslate | async }}\n                </button>\n              }\n            </mat-menu>\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle [checked]=\"item.checked\" (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n"]}

package/fesm2022/ets-fe-ng-sdk.mjs

@@ -2844,7 +2844,7 @@ class CacheService {
     constructor() {
         this._cache = {};
         this.uS = inject(UtilityService);
-        this.has = (key) => !!this._cache[key];
+        this.has = (key) => this._cache[key] != null;
         this.getItem = (key) => this._cache[key];
     }
     get cache() {
@@ -3005,7 +3005,7 @@ class ApiService {
                     .toPromise()
                     .then((r) => {
                     res.next(r);
-                    this.cacheS.setItem(query, r);
+                    // this.cacheS.setItem(query, r);
                     res.complete();
                 })
                     .catch((err) => res.error(err));
@@ -3069,6 +3069,25 @@ class ApiService {
                 });
             });
         };
+        this.getFromMemory = (route, parameters, extras) => new Observable((res) => {
+            const query = route + this.getRequestParse(parameters);
+            if (this.cacheS.has(query)) {
+                res.next(this.cacheS.getItem(query));
+                res.complete();
+            }
+            else {
+                lastValueFrom(this.get(query, null, extras))
+                    .then((r) => {
+                    res.next(r);
+                    this.cacheS.setItem(query, r);
+                    res.complete();
+                })
+                    .catch((e) => {
+                    res.error(e);
+                    res.complete();
+                });
+            }
+        });
         //#endregion
         //#region DELETE
         this.delete = (route, extras) => {
@@ -16040,6 +16059,8 @@ class ToggleInputFormComponent {
         this.uS = inject(UtilityService);
         this.addToFormFunc = input();
         this.defaultToggleAll = input();
+        this.hideSearchMenu = input();
+        this.hideGridMenu = input();
         this.deleteFromFormFunc = input();
         this.gridNo = model(6);
         this.labelField = input();
@@ -16157,7 +16178,7 @@ class ToggleInputFormComponent {
         this.selectedMap.set({});
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ToggleInputFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: ToggleInputFormComponent, isStandalone: true, selector: "toggle-input-form", inputs: { addToFormFunc: { classPropertyName: "addToFormFunc", publicName: "addToFormFunc", isSignal: true, isRequired: false, transformFunction: null }, defaultToggleAll: { classPropertyName: "defaultToggleAll", publicName: "defaultToggleAll", isSignal: true, isRequired: false, transformFunction: null }, deleteFromFormFunc: { classPropertyName: "deleteFromFormFunc", publicName: "deleteFromFormFunc", isSignal: true, isRequired: false, transformFunction: null }, gridNo: { classPropertyName: "gridNo", publicName: "gridNo", isSignal: true, isRequired: false, transformFunction: null }, labelField: { classPropertyName: "labelField", publicName: "labelField", isSignal: true, isRequired: false, transformFunction: null }, labelSeparator: { classPropertyName: "labelSeparator", publicName: "labelSeparator", isSignal: true, isRequired: false, transformFunction: null }, searchQuery: { classPropertyName: "searchQuery", publicName: "searchQuery", isSignal: true, isRequired: false, transformFunction: null }, showToggleAll: { classPropertyName: "showToggleAll", publicName: "showToggleAll", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: true, transformFunction: null }, checkedChecker: { classPropertyName: "checkedChecker", publicName: "checkedChecker", isSignal: true, isRequired: true, transformFunction: null }, _list: { classPropertyName: "_list", publicName: "list", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { gridNo: "gridNoChange", searchQuery: "searchQueryChange", selected: "selected" }, ngImport: i0, template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\">\n        <div class=\"col-auto\">\n          <app-btn\n            iconBtn\n            [showHelpIcon]=\"false\"\n            help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n            [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n            (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n        </div>\n        <div class=\"col-auto\" [hidden]=\"true\" #searchBox>\n          <app-input-td-rf\n            type=\"text\"\n            [noFormat]=\"true\"\n            [showLabel]=\"false\"\n            placeholder=\"Type to search\"\n            [(model)]=\"searchQuery\" />\n        </div>\n        <div class=\"col-auto\">\n          <app-btn\n            customIcon=\"fa fa-list\"\n            [showHelpIcon]=\"false\"\n            help=\"Grid Style\"\n            [matMenuTriggerFor]=\"gridMenu\" />\n          <mat-menu #gridMenu=\"matMenu\" class=\"\">\n            @for (item of columnLengths(); track item.value) {\n              <button\n                mat-menu-item\n                (click)=\"gridNo.set(item.value)\"\n                [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                {{ item.label | appTranslate | async }}\n              </button>\n            }\n          </mat-menu>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle\n              [checked]=\"item.checked\"\n              (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i1$3.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "component", type: BtnComponent, selector: "app-btn", inputs: ["formSchema", "debug", "centerBtn", "danger", "warning", "verbose", "translatorOptions", "loading", "icon", "rightIcon", "leftIcon", "type", "group", "actionType", "animate", "excludeLogging", "loggingValue", "badge", "class", "customIcon", "form", "forms", "help", "iconBtn", "mclass", "showHelpIcon", "rightCustomIcon", "leftCustomIcon", "text", "valid", "mini", "onFormInvalid", "disabled"], outputs: ["loadingChange", "leftCustomIconChange", "mclick", "disabledChange"] }, { kind: "pipe", type: FilterArrayByStringPipe, name: "filterArrayByString" }, { kind: "component", type: InputTD_RFComponent, selector: "app-input-td-rf", inputs: ["validators", "asyncValidators", "model"], outputs: ["modelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i11.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i3$2.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i3$2.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i3$2.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "pipe", type: SDKTranslatePipe, name: "appTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.0.3", type: ToggleInputFormComponent, isStandalone: true, selector: "toggle-input-form", inputs: { addToFormFunc: { classPropertyName: "addToFormFunc", publicName: "addToFormFunc", isSignal: true, isRequired: false, transformFunction: null }, defaultToggleAll: { classPropertyName: "defaultToggleAll", publicName: "defaultToggleAll", isSignal: true, isRequired: false, transformFunction: null }, hideSearchMenu: { classPropertyName: "hideSearchMenu", publicName: "hideSearchMenu", isSignal: true, isRequired: false, transformFunction: null }, hideGridMenu: { classPropertyName: "hideGridMenu", publicName: "hideGridMenu", isSignal: true, isRequired: false, transformFunction: null }, deleteFromFormFunc: { classPropertyName: "deleteFromFormFunc", publicName: "deleteFromFormFunc", isSignal: true, isRequired: false, transformFunction: null }, gridNo: { classPropertyName: "gridNo", publicName: "gridNo", isSignal: true, isRequired: false, transformFunction: null }, labelField: { classPropertyName: "labelField", publicName: "labelField", isSignal: true, isRequired: false, transformFunction: null }, labelSeparator: { classPropertyName: "labelSeparator", publicName: "labelSeparator", isSignal: true, isRequired: false, transformFunction: null }, searchQuery: { classPropertyName: "searchQuery", publicName: "searchQuery", isSignal: true, isRequired: false, transformFunction: null }, showToggleAll: { classPropertyName: "showToggleAll", publicName: "showToggleAll", isSignal: true, isRequired: false, transformFunction: null }, valueField: { classPropertyName: "valueField", publicName: "valueField", isSignal: true, isRequired: true, transformFunction: null }, checkedChecker: { classPropertyName: "checkedChecker", publicName: "checkedChecker", isSignal: true, isRequired: true, transformFunction: null }, _list: { classPropertyName: "_list", publicName: "list", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { gridNo: "gridNoChange", searchQuery: "searchQueryChange", selected: "selected" }, ngImport: i0, template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\" [hidden]=\"hideSearchMenu() && hideGridMenu()\">\n        @if (!hideSearchMenu()) {\n          <div class=\"col-auto d-flex align-items-center\">\n            <app-btn\n              iconBtn\n              [showHelpIcon]=\"false\"\n              help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n              [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n              (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n            <div class=\"ms-1\" [hidden]=\"true\" #searchBox>\n              <app-input-td-rf\n                type=\"text\"\n                [noFormat]=\"true\"\n                [showLabel]=\"false\"\n                placeholder=\"Type to search\"\n                [(model)]=\"searchQuery\" />\n            </div>\n          </div>\n        }\n        @if (!hideGridMenu()) {\n          <div class=\"col-auto\">\n            <app-btn\n              customIcon=\"fa fa-list\"\n              [showHelpIcon]=\"false\"\n              help=\"Grid Style\"\n              [matMenuTriggerFor]=\"gridMenu\" />\n            <mat-menu #gridMenu=\"matMenu\" class=\"\">\n              @for (item of columnLengths(); track item.value) {\n                <button\n                  mat-menu-item\n                  (click)=\"gridNo.set(item.value)\"\n                  [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                  {{ item.label | appTranslate | async }}\n                </button>\n              }\n            </mat-menu>\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle [checked]=\"item.checked\" (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i1$3.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "component", type: BtnComponent, selector: "app-btn", inputs: ["formSchema", "debug", "centerBtn", "danger", "warning", "verbose", "translatorOptions", "loading", "icon", "rightIcon", "leftIcon", "type", "group", "actionType", "animate", "excludeLogging", "loggingValue", "badge", "class", "customIcon", "form", "forms", "help", "iconBtn", "mclass", "showHelpIcon", "rightCustomIcon", "leftCustomIcon", "text", "valid", "mini", "onFormInvalid", "disabled"], outputs: ["loadingChange", "leftCustomIconChange", "mclick", "disabledChange"] }, { kind: "pipe", type: FilterArrayByStringPipe, name: "filterArrayByString" }, { kind: "component", type: InputTD_RFComponent, selector: "app-input-td-rf", inputs: ["validators", "asyncValidators", "model"], outputs: ["modelChange"] }, { kind: "ngmodule", type: FormsModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i11.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i3$2.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i3$2.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i3$2.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "pipe", type: SDKTranslatePipe, name: "appTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ToggleInputFormComponent, decorators: [{
             type: Component,
@@ -16171,7 +16192,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                         MatTooltipModule,
                         MatMenuModule,
                         SDKTranslatePipe,
-                    ], template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\">\n        <div class=\"col-auto\">\n          <app-btn\n            iconBtn\n            [showHelpIcon]=\"false\"\n            help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n            [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n            (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n        </div>\n        <div class=\"col-auto\" [hidden]=\"true\" #searchBox>\n          <app-input-td-rf\n            type=\"text\"\n            [noFormat]=\"true\"\n            [showLabel]=\"false\"\n            placeholder=\"Type to search\"\n            [(model)]=\"searchQuery\" />\n        </div>\n        <div class=\"col-auto\">\n          <app-btn\n            customIcon=\"fa fa-list\"\n            [showHelpIcon]=\"false\"\n            help=\"Grid Style\"\n            [matMenuTriggerFor]=\"gridMenu\" />\n          <mat-menu #gridMenu=\"matMenu\" class=\"\">\n            @for (item of columnLengths(); track item.value) {\n              <button\n                mat-menu-item\n                (click)=\"gridNo.set(item.value)\"\n                [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                {{ item.label | appTranslate | async }}\n              </button>\n            }\n          </mat-menu>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle\n              [checked]=\"item.checked\"\n              (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"] }]
+                    ], template: "<div class=\"pb-3\">\n  <div class=\"row align-items-center justify-content-between g-3\">\n    <div class=\"col-lg-auto\">\n      <mat-slide-toggle (change)=\"toggleAll($event)\" [checked]=\"defaultToggleAll()\">\n        {{ 'Toggle All' | appTranslate | async }}\n      </mat-slide-toggle>\n    </div>\n    <div class=\"col-lg d-flex justify-content-end\">\n      <div class=\"row align-items-center g-3\" [hidden]=\"hideSearchMenu() && hideGridMenu()\">\n        @if (!hideSearchMenu()) {\n          <div class=\"col-auto d-flex align-items-center\">\n            <app-btn\n              iconBtn\n              [showHelpIcon]=\"false\"\n              help=\"{{ searchBox.hidden ? 'Open search' : 'Close search' }}\"\n              [icon]=\"searchBox.hidden ? 'search' : 'close'\"\n              (mclick)=\"searchBox.hidden = !searchBox.hidden\" />\n            <div class=\"ms-1\" [hidden]=\"true\" #searchBox>\n              <app-input-td-rf\n                type=\"text\"\n                [noFormat]=\"true\"\n                [showLabel]=\"false\"\n                placeholder=\"Type to search\"\n                [(model)]=\"searchQuery\" />\n            </div>\n          </div>\n        }\n        @if (!hideGridMenu()) {\n          <div class=\"col-auto\">\n            <app-btn\n              customIcon=\"fa fa-list\"\n              [showHelpIcon]=\"false\"\n              help=\"Grid Style\"\n              [matMenuTriggerFor]=\"gridMenu\" />\n            <mat-menu #gridMenu=\"matMenu\" class=\"\">\n              @for (item of columnLengths(); track item.value) {\n                <button\n                  mat-menu-item\n                  (click)=\"gridNo.set(item.value)\"\n                  [ngClass]=\"{ 'text-primary': item.value == _currentGrid() }\">\n                  {{ item.label | appTranslate | async }}\n                </button>\n              }\n            </mat-menu>\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</div>\n<div\n  class=\"row row-cols-md-{{ mdGrid() }} row-cols-lg-{{ lgGrid() }} row-cols-xxl-{{\n    xxlGrid()\n  }} g-3\">\n  @for (item of list() | filterArrayByString: searchQuery() : ['label']; track item.value) {\n    <div class=\"\">\n      <div class=\"border rounded-10 p-10\">\n        <div class=\"row align-items-center\">\n          <div\n            class=\"col text-ellipsis\"\n            [matTooltip]=\"ele.innerText\"\n            [matTooltipDisabled]=\"ele.scrollWidth <= ele.offsetWidth\"\n            #ele>\n            {{ item.label }}\n          </div>\n          <div class=\"col-auto\">\n            <mat-slide-toggle [checked]=\"item.checked\" (change)=\"toggleItem($event, item)\" />\n          </div>\n        </div>\n      </div>\n    </div>\n  }\n</div>\n", styles: [":host{display:block}\n"] }]
         }] });
 
 class TranslatorCaseComponent {