@delon/theme 12.4.2 → 13.1.0

package/esm2020/src/services/http/http.client.mjs

@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { delay, finalize, switchMap, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@delon/util/config";
+/**
+ * 封装HttpClient，主要解决：
+ * + 优化HttpClient在参数上便利性
+ * + 统一实现 loading
+ * + 统一处理时间格式问题
+ */
+export class _HttpClient {
+    constructor(http, cogSrv) {
+        this.http = http;
+        this.lc = 0;
+        this.cog = cogSrv.merge('themeHttp', {
+            nullValueHandling: 'include',
+            dateValueHandling: 'timestamp'
+        });
+    }
+    /**
+     * Get whether it's loading
+     *
+     * 获取是否正在加载中
+     */
+    get loading() {
+        return this.lc > 0;
+    }
+    /**
+     * Get the currently loading count
+     *
+     * 获取当前加载中的数量
+     */
+    get loadingCount() {
+        return this.lc;
+    }
+    parseParams(params) {
+        const newParams = {};
+        if (params instanceof HttpParams) {
+            return params;
+        }
+        Object.keys(params).forEach(key => {
+            let _data = params[key];
+            // 忽略空值
+            if (this.cog.nullValueHandling === 'ignore' && _data == null)
+                return;
+            // 将时间转化为：时间戳 (秒)
+            if (this.cog.dateValueHandling === 'timestamp' && _data instanceof Date) {
+                _data = _data.valueOf();
+            }
+            newParams[key] = _data;
+        });
+        return new HttpParams({ fromObject: newParams });
+    }
+    appliedUrl(url, params) {
+        if (!params)
+            return url;
+        url += ~url.indexOf('?') ? '' : '?';
+        const arr = [];
+        Object.keys(params).forEach(key => {
+            arr.push(`${key}=${params[key]}`);
+        });
+        return url + arr.join('&');
+    }
+    setCount(count) {
+        Promise.resolve(null).then(() => (this.lc = count <= 0 ? 0 : count));
+    }
+    push() {
+        this.setCount(++this.lc);
+    }
+    pop() {
+        this.setCount(--this.lc);
+    }
+    /**
+     * Clean loading count
+     *
+     * 清空加载中
+     */
+    cleanLoading() {
+        this.setCount(0);
+    }
+    get(url, params, options = {}) {
+        return this.request('GET', url, {
+            params,
+            ...options
+        });
+    }
+    post(url, body, params, options = {}) {
+        return this.request('POST', url, {
+            body,
+            params,
+            ...options
+        });
+    }
+    delete(url, params, options = {}) {
+        return this.request('DELETE', url, {
+            params,
+            ...options
+        });
+    }
+    // #endregion
+    // #region jsonp
+    /**
+     * **JSONP Request**
+     *
+     * @param callbackParam CALLBACK值，默认：JSONP_CALLBACK
+     */
+    jsonp(url, params, callbackParam = 'JSONP_CALLBACK') {
+        return of(null).pipe(
+        // Make sure to always be asynchronous, see issues: https://github.com/ng-alain/ng-alain/issues/1954
+        delay(0), tap(() => this.push()), switchMap(() => this.http.jsonp(this.appliedUrl(url, params), callbackParam)), finalize(() => this.pop()));
+    }
+    patch(url, body, params, options = {}) {
+        return this.request('PATCH', url, {
+            body,
+            params,
+            ...options
+        });
+    }
+    put(url, body, params, options = {}) {
+        return this.request('PUT', url, {
+            body,
+            params,
+            ...options
+        });
+    }
+    form(url, body, params, options = {}) {
+        return this.request('POST', url, {
+            body,
+            params,
+            ...options,
+            headers: {
+                'content-type': `application/x-www-form-urlencoded`
+            }
+        });
+    }
+    request(method, url, options = {}) {
+        if (options.params)
+            options.params = this.parseParams(options.params);
+        return of(null).pipe(
+        // Make sure to always be asynchronous, see issues: https://github.com/ng-alain/ng-alain/issues/1954
+        delay(0), tap(() => this.push()), switchMap(() => this.http.request(method, url, options)), finalize(() => this.pop()));
+    }
+}
+_HttpClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: _HttpClient, deps: [{ token: i1.HttpClient }, { token: i2.AlainConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+_HttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: _HttpClient, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: _HttpClient, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.AlainConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.client.js","sourceRoot":"","sources":["../../../../../../../packages/theme/src/services/http/http.client.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpClient, HttpContext, HttpEvent, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport { delay, finalize, switchMap, tap } from 'rxjs/operators';\n\nimport { AlainConfigService, AlainThemeHttpClientConfig } from '@delon/util/config';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nexport type _HttpHeaders = HttpHeaders | { [header: string]: string | string[] };\nexport type HttpObserve = 'body' | 'events' | 'response';\n\n/**\n * 封装HttpClient，主要解决：\n * + 优化HttpClient在参数上便利性\n * + 统一实现 loading\n * + 统一处理时间格式问题\n */\n@Injectable({ providedIn: 'root' })\nexport class _HttpClient {\n  private cog: AlainThemeHttpClientConfig;\n  constructor(private http: HttpClient, cogSrv: AlainConfigService) {\n    this.cog = cogSrv.merge('themeHttp', {\n      nullValueHandling: 'include',\n      dateValueHandling: 'timestamp'\n    })!;\n  }\n\n  private lc = 0;\n\n  /**\n   * Get whether it's loading\n   *\n   * 获取是否正在加载中\n   */\n  get loading(): boolean {\n    return this.lc > 0;\n  }\n\n  /**\n   * Get the currently loading count\n   *\n   * 获取当前加载中的数量\n   */\n  get loadingCount(): number {\n    return this.lc;\n  }\n\n  parseParams(params: NzSafeAny): HttpParams {\n    const newParams: NzSafeAny = {};\n    if (params instanceof HttpParams) {\n      return params;\n    }\n\n    Object.keys(params).forEach(key => {\n      let _data = params[key];\n      // 忽略空值\n      if (this.cog.nullValueHandling === 'ignore' && _data == null) return;\n      // 将时间转化为：时间戳 (秒)\n      if (this.cog.dateValueHandling === 'timestamp' && _data instanceof Date) {\n        _data = _data.valueOf();\n      }\n      newParams[key] = _data;\n    });\n    return new HttpParams({ fromObject: newParams });\n  }\n\n  appliedUrl(url: string, params?: NzSafeAny): string {\n    if (!params) return url;\n    url += ~url.indexOf('?') ? '' : '?';\n    const arr: string[] = [];\n    Object.keys(params).forEach(key => {\n      arr.push(`${key}=${params[key]}`);\n    });\n    return url + arr.join('&');\n  }\n\n  private setCount(count: number): void {\n    Promise.resolve(null).then(() => (this.lc = count <= 0 ? 0 : count));\n  }\n\n  private push(): void {\n    this.setCount(++this.lc);\n  }\n\n  private pop(): void {\n    this.setCount(--this.lc);\n  }\n\n  /**\n   * Clean loading count\n   *\n   * 清空加载中\n   */\n  cleanLoading(): void {\n    this.setCount(0);\n  }\n\n  // #region get\n\n  /**\n   * **GET Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  get(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **GET Request** Return a `HttpEvent<T>` type / 返回一个 `HttpEvent<T>` 类型\n   */\n  get<T>(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  /**\n   * **GET Request** Return a `HttpResponse<any>` type / 返回一个 `HttpResponse<any>` 类型\n   */\n  get(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<any>>;\n\n  /**\n   * **GET Request** Return a `HttpResponse<T>` type / 返回一个 `HttpResponse<T>` 类型\n   */\n  get<T>(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<T>>;\n\n  /**\n   * **GET Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  get(\n    url: string,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * **GET Request** Return a generic type / 返回一个泛类型\n   */\n  get<T>(\n    url: string,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe: 'body';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  get(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('GET', url, {\n      params,\n      ...options\n    });\n  }\n\n  // #endregion\n\n  // #region post\n\n  /**\n   * **POST Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  post(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **POST Request** Return a `HttpEvent<T>` type / 返回一个 `HttpEvent<T>` 类型\n   */\n  post<T>(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  /**\n   * **POST Request** Return a `HttpResponse<any>` type / 返回一个 `HttpResponse<any>` 类型\n   */\n  post(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<any>>;\n\n  /**\n   * **POST Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  post(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * **POST Request** Return a JSON type / 返回一个 `JSON` 类型\n   */\n  post<T>(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  post(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('POST', url, {\n      body,\n      params,\n      ...options\n    });\n  }\n\n  // #endregion\n\n  // #region delete\n\n  /**\n   * **DELETE Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  delete(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **DELETE Request** Return a `JSON` type / 返回一个 `JSON` 类型\n   */\n  delete(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<NzSafeAny>>;\n\n  /**\n   * **DELETE Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  delete(\n    url: string,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * c返回一个泛类型\n   */\n  delete<T>(\n    url: string,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  delete(\n    url: string,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('DELETE', url, {\n      params,\n      ...options\n    });\n  }\n\n  // #endregion\n\n  // #region jsonp\n\n  /**\n   * **JSONP Request**\n   *\n   * @param callbackParam CALLBACK值，默认：JSONP_CALLBACK\n   */\n  jsonp(url: string, params?: any, callbackParam: string = 'JSONP_CALLBACK'): Observable<any> {\n    return of(null).pipe(\n      // Make sure to always be asynchronous, see issues: https://github.com/ng-alain/ng-alain/issues/1954\n      delay(0),\n      tap(() => this.push()),\n      switchMap(() => this.http.jsonp(this.appliedUrl(url, params), callbackParam)),\n      finalize(() => this.pop())\n    );\n  }\n\n  // #endregion\n\n  // #region patch\n\n  /**\n   * **PATCH Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  patch(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **PATCH Request** Return a `HttpResponse<JSON>` type / 返回一个 `HttpResponse<JSON>` 类型\n   */\n  patch(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<NzSafeAny>>;\n\n  /**\n   * **PATCH Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  patch(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * **PATCH Request** Return a `JSON` type / 返回一个 `JSON` 类型\n   */\n  patch<T>(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  patch(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('PATCH', url, {\n      body,\n      params,\n      ...options\n    });\n  }\n\n  // #endregion\n\n  // #region put\n\n  /**\n   * **PUT Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  put(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **PUT Request** Return a `HttpResponse<JSON>` type / 返回一个 `HttpResponse<JSON>` 类型\n   */\n  put(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<NzSafeAny>>;\n\n  /**\n   * **PUT Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  put(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * **PUT Request** Return a `JSON` type / 返回一个 `JSON` 类型\n   */\n  put<T>(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  put(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('PUT', url, {\n      body,\n      params,\n      ...options\n    });\n  }\n\n  // #endregion\n\n  // #region form\n\n  /**\n   * **Form Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  form(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **Form Request** Return a `HttpEvent<T>` type / 返回一个 `HttpEvent<T>` 类型\n   */\n  form<T>(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<T>>;\n\n  /**\n   * **Form Request** Return a `HttpResponse<JSON>` type / 返回一个 `HttpResponse<JSON>` 类型\n   */\n  form(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<any>>;\n\n  /**\n   * **Form Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  form(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  /**\n   * **Form Request** Return a `JSON` type / 返回一个 `JSON` 类型\n   */\n  form<T>(\n    url: string,\n    body?: any,\n    params?: any,\n    options?: {\n      headers?: _HttpHeaders;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<T>;\n\n  form(\n    url: string,\n    body: any,\n    params: any,\n    options: {\n      headers?: _HttpHeaders;\n      observe?: 'body' | 'events' | 'response';\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    return this.request('POST', url, {\n      body,\n      params,\n      ...options,\n      headers: {\n        'content-type': `application/x-www-form-urlencoded`\n      }\n    });\n  }\n\n  // #endregion\n\n  // #region request\n\n  /**\n   * **Request** Return a `ArrayBuffer` type / 返回一个 `ArrayBuffer` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<ArrayBuffer>;\n\n  /**\n   * **Request** Return a `Blob` type / 返回一个 `Blob` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<Blob>;\n\n  /**\n   * **Request** Return a `string` type / 返回一个 `string` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: 'body';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<string>;\n\n  /**\n   * **Request** Return a `HttpEvent<ArrayBuffer>` type / 返回一个 `HttpEvent<ArrayBuffer>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<ArrayBuffer>>;\n\n  /**\n   * **Request** Return a `HttpEvent<Blob>` type / 返回一个 `HttpEvent<Blob>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<Blob>>;\n\n  /**\n   * **Request** Return a `HttpEvent<string>` type / 返回一个 `HttpEvent<string>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'events';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<string>>;\n\n  /**\n   * **Request** Return a `HttpEvent<any>` type / 返回一个 `HttpEvent<any>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      reportProgress?: boolean;\n      observe: 'events';\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<any>>;\n\n  /**\n   * **Request** Return a `HttpEvent<R>` type / 返回一个 `HttpEvent<R>` 类型\n   */\n  request<R>(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      reportProgress?: boolean;\n      observe: 'events';\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpEvent<R>>;\n\n  /**\n   * **Request** Return a `HttpResponse<ArrayBuffer>` type / 返回一个 `HttpResponse<ArrayBuffer>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType: 'arraybuffer';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<ArrayBuffer>>;\n\n  /**\n   * **Request** Return a `HttpResponse<Blob>` type / 返回一个 `HttpResponse<Blob>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType: 'blob';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<Blob>>;\n\n  /**\n   * **Request** Return a `HttpResponse<string>` type / 返回一个 `HttpResponse<string>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe: 'response';\n      reportProgress?: boolean;\n      responseType: 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<string>>;\n\n  /**\n   * **Request** Return a `HttpResponse<Object>` type / 返回一个 `HttpResponse<Object>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      reportProgress?: boolean;\n      observe: 'response';\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<NzSafeAny>>;\n\n  /**\n   * **Request** Return a `HttpResponse<R>` type / 返回一个 `HttpResponse<R>` 类型\n   */\n  request<R>(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      reportProgress?: boolean;\n      observe: 'response';\n      responseType?: 'json';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<HttpResponse<R>>;\n\n  /**\n   * **Request** Return a `HttpResponse<Object>` type / 返回一个 `HttpResponse<Object>` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options?: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: 'body';\n      responseType?: 'json';\n      reportProgress?: boolean;\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<Record<string, unknown>>;\n\n  /**\n   * **Request** Return a `R` type / 返回一个 `R` 类型\n   */\n  request<R>(\n    method: string,\n    url: string,\n    options?: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: 'body';\n      responseType?: 'json';\n      reportProgress?: boolean;\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<R>;\n\n  /**\n   * **Request** Return a `any` type / 返回一个 `any` 类型\n   */\n  request(\n    method: string,\n    url: string,\n    options?: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: HttpObserve;\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    }\n  ): Observable<any>;\n\n  request(\n    method: string,\n    url: string,\n    options: {\n      body?: any;\n      headers?: _HttpHeaders;\n      params?: any;\n      observe?: HttpObserve;\n      reportProgress?: boolean;\n      responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n      withCredentials?: boolean;\n      context?: HttpContext;\n    } = {}\n  ): Observable<any> {\n    if (options.params) options.params = this.parseParams(options.params);\n    return of(null).pipe(\n      // Make sure to always be asynchronous, see issues: https://github.com/ng-alain/ng-alain/issues/1954\n      delay(0),\n      tap(() => this.push()),\n      switchMap(() => this.http.request(method, url, options)),\n      finalize(() => this.pop())\n    );\n  }\n\n  // #endregion\n}\n"]}

package/esm2020/src/services/http/http.decorator.mjs

@@ -0,0 +1,215 @@
+import { Inject, Injectable, Injector } from '@angular/core';
+import { throwError } from 'rxjs';
+import { ACLService } from '@delon/acl';
+import { _HttpClient } from './http.client';
+import * as i0 from "@angular/core";
+/**
+ * Every http decorator must be based on `BaseAPI`, Like this:
+ * ```ts
+ * \@Injectable()
+ * class DataService extends BaseApi {}
+ * ```
+ */
+export class BaseApi {
+    constructor(injector) {
+        this.injector = injector;
+    }
+}
+BaseApi.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseApi, deps: [{ token: Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseApi.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseApi });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: BaseApi, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [Injector]
+                }] }]; } });
+const paramKey = `__api_params`;
+function setParam(target, key = paramKey) {
+    let params = target[key];
+    if (typeof params === 'undefined') {
+        params = target[key] = {};
+    }
+    return params;
+}
+/**
+ * 默认基准URL
+ * - 有效范围：类
+ */
+export function BaseUrl(url) {
+    return function (target) {
+        const params = setParam(target.prototype);
+        params.baseUrl = url;
+        return target;
+    };
+}
+/**
+ * 默认 `headers`
+ * - 有效范围：类
+ */
+export function BaseHeaders(headers) {
+    return function (target) {
+        const params = setParam(target.prototype);
+        params.baseHeaders = headers;
+        return target;
+    };
+}
+function makeParam(paramName) {
+    return function (key) {
+        return function (target, propertyKey, index) {
+            const params = setParam(setParam(target), propertyKey);
+            let tParams = params[paramName];
+            if (typeof tParams === 'undefined') {
+                tParams = params[paramName] = [];
+            }
+            tParams.push({
+                key,
+                index
+            });
+        };
+    };
+}
+/**
+ * URL路由参数
+ * - 有效范围：方法参数
+ */
+export const Path = makeParam('path');
+/**
+ * URL 参数 `QueryString`
+ * - 有效范围：方法参数
+ */
+export const Query = makeParam('query');
+/**
+ * 参数 `Body`
+ * - 有效范围：方法参数
+ */
+export const Body = makeParam('body')();
+/**
+ * 参数 `headers`
+ * - 有效范围：方法参数
+ * - 合并 `BaseHeaders`
+ */
+export const Headers = makeParam('headers');
+/**
+ * Request Payload
+ * - Supported body (like`POST`, `PUT`) as a body data, equivalent to `@Body`
+ * - Not supported body (like `GET`, `DELETE` etc) as a `QueryString`
+ */
+export const Payload = makeParam('payload')();
+function getValidArgs(data, key, args) {
+    if (!data[key] || !Array.isArray(data[key]) || data[key].length <= 0) {
+        return undefined;
+    }
+    return args[data[key][0].index];
+}
+function genBody(data, payload) {
+    if (Array.isArray(data) || Array.isArray(payload)) {
+        return Object.assign([], data, payload);
+    }
+    return { ...data, ...payload };
+}
+function makeMethod(method) {
+    return function (url = '', options) {
+        return (_target, targetKey, descriptor) => {
+            descriptor.value = function (...args) {
+                options = options || {};
+                const injector = this.injector;
+                const http = injector.get(_HttpClient, null);
+                if (http == null) {
+                    throw new TypeError(`Not found '_HttpClient', You can import 'AlainThemeModule' && 'HttpClientModule' in your root module.`);
+                }
+                const baseData = setParam(this);
+                const data = setParam(baseData, targetKey);
+                let requestUrl = url || '';
+                requestUrl = [baseData.baseUrl || '', requestUrl.startsWith('/') ? requestUrl.substring(1) : requestUrl].join('/');
+                // fix last split
+                if (requestUrl.length > 1 && requestUrl.endsWith('/')) {
+                    requestUrl = requestUrl.substring(0, requestUrl.length - 1);
+                }
+                if (options.acl) {
+                    const aclSrv = injector.get(ACLService, null);
+                    if (aclSrv && !aclSrv.can(options.acl)) {
+                        return throwError(() => ({
+                            url: requestUrl,
+                            status: 401,
+                            statusText: `From Http Decorator`
+                        }));
+                    }
+                    delete options.acl;
+                }
+                requestUrl = requestUrl.replace(/::/g, '^^');
+                (data.path || [])
+                    .filter(w => typeof args[w.index] !== 'undefined')
+                    .forEach((i) => {
+                    requestUrl = requestUrl.replace(new RegExp(`:${i.key}`, 'g'), encodeURIComponent(args[i.index]));
+                });
+                requestUrl = requestUrl.replace(/\^\^/g, `:`);
+                const params = (data.query || []).reduce((p, i) => {
+                    p[i.key] = args[i.index];
+                    return p;
+                }, {});
+                const headers = (data.headers || []).reduce((p, i) => {
+                    p[i.key] = args[i.index];
+                    return p;
+                }, {});
+                if (method === 'FORM') {
+                    headers['content-type'] = 'application/x-www-form-urlencoded';
+                }
+                const payload = getValidArgs(data, 'payload', args);
+                const supportedBody = method === 'POST' || method === 'PUT';
+                return http.request(method, requestUrl, {
+                    body: supportedBody ? genBody(getValidArgs(data, 'body', args), payload) : null,
+                    params: !supportedBody ? { ...params, ...payload } : params,
+                    headers: { ...baseData.baseHeaders, ...headers },
+                    ...options
+                });
+            };
+            return descriptor;
+        };
+    };
+}
+/**
+ * `OPTIONS` 请求
+ * - 有效范围：方法
+ */
+export const OPTIONS = makeMethod('OPTIONS');
+/**
+ * `GET` 请求
+ * - 有效范围：方法
+ */
+export const GET = makeMethod('GET');
+/**
+ * `POST` 请求
+ * - 有效范围：方法
+ */
+export const POST = makeMethod('POST');
+/**
+ * `DELETE` 请求
+ * - 有效范围：方法
+ */
+export const DELETE = makeMethod('DELETE');
+/**
+ * `PUT` 请求
+ * - 有效范围：方法
+ */
+export const PUT = makeMethod('PUT');
+/**
+ * `HEAD` 请求
+ * - 有效范围：方法
+ */
+export const HEAD = makeMethod('HEAD');
+/**
+ * `PATCH` 请求
+ * - 有效范围：方法
+ */
+export const PATCH = makeMethod('PATCH');
+/**
+ * `JSONP` 请求
+ * - 有效范围：方法
+ */
+export const JSONP = makeMethod('JSONP');
+/**
+ * `FORM` 请求
+ * - 有效范围：方法
+ */
+export const FORM = makeMethod('FORM');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.decorator.js","sourceRoot":"","sources":["../../../../../../../packages/theme/src/services/http/http.decorator.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpHeaders } from '@angular/common/http';\nimport { Inject, Injectable, Injector } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\n\nimport { ACLService } from '@delon/acl';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { _HttpClient } from './http.client';\n\n/**\n * Every http decorator must be based on `BaseAPI`, Like this:\n * ```ts\n * \\@Injectable()\n * class DataService extends BaseApi {}\n * ```\n */\n@Injectable()\nexport abstract class BaseApi {\n  constructor(@Inject(Injector) protected injector: Injector) {}\n}\n\nexport interface HttpOptions {\n  /** ACL配置，若导入 `@delon/acl` 时自动有效，等同于 `ACLService.can(roleOrAbility: ACLCanType)` 参数值 */\n  acl?: any;\n  observe?: 'body' | 'events' | 'response';\n  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';\n  reportProgress?: boolean;\n  withCredentials?: boolean;\n}\n\ninterface ParamType {\n  key: string;\n  index: number;\n  [key: string]: any;\n  [key: number]: any;\n}\n\nconst paramKey = `__api_params`;\n\nfunction setParam(target: any, key: string = paramKey): any {\n  let params = target[key];\n  if (typeof params === 'undefined') {\n    params = target[key] = {};\n  }\n  return params;\n}\n\n/**\n * 默认基准URL\n * - 有效范围：类\n */\nexport function BaseUrl(url: string) {\n  return function <TClass extends new (...args: any[]) => BaseApi>(target: TClass): TClass {\n    const params = setParam(target.prototype);\n    params.baseUrl = url;\n    return target;\n  };\n}\n\n/**\n * 默认 `headers`\n * - 有效范围：类\n */\nexport function BaseHeaders(\n  headers:\n    | HttpHeaders\n    | {\n        [header: string]: string | string[];\n      }\n) {\n  return function <TClass extends new (...args: any[]) => BaseApi>(target: TClass): TClass {\n    const params = setParam(target.prototype);\n    params.baseHeaders = headers;\n    return target;\n  };\n}\n\nfunction makeParam(paramName: string) {\n  return function (key?: string) {\n    return function (target: BaseApi, propertyKey: string, index: number) {\n      const params = setParam(setParam(target), propertyKey);\n      let tParams = params[paramName];\n      if (typeof tParams === 'undefined') {\n        tParams = params[paramName] = [];\n      }\n      tParams.push({\n        key,\n        index\n      });\n    };\n  };\n}\n\n/**\n * URL路由参数\n * - 有效范围：方法参数\n */\nexport const Path = makeParam('path');\n\n/**\n * URL 参数 `QueryString`\n * - 有效范围：方法参数\n */\nexport const Query = makeParam('query');\n\n/**\n * 参数 `Body`\n * - 有效范围：方法参数\n */\nexport const Body = makeParam('body')();\n\n/**\n * 参数 `headers`\n * - 有效范围：方法参数\n * - 合并 `BaseHeaders`\n */\nexport const Headers = makeParam('headers');\n\n/**\n * Request Payload\n * - Supported body (like`POST`, `PUT`) as a body data, equivalent to `@Body`\n * - Not supported body (like `GET`, `DELETE` etc) as a `QueryString`\n */\nexport const Payload = makeParam('payload')();\n\nfunction getValidArgs(data: any, key: string, args: any[]): NzSafeAny {\n  if (!data[key] || !Array.isArray(data[key]) || data[key].length <= 0) {\n    return undefined;\n  }\n  return args[data[key][0].index];\n}\n\nfunction genBody(data?: any, payload?: any): any {\n  if (Array.isArray(data) || Array.isArray(payload)) {\n    return Object.assign([], data, payload);\n  }\n  return { ...data, ...payload };\n}\n\nexport type METHOD_TYPE = 'OPTIONS' | 'GET' | 'POST' | 'DELETE' | 'PUT' | 'HEAD' | 'PATCH' | 'JSONP' | 'FORM';\n\nfunction makeMethod(method: METHOD_TYPE) {\n  return function (url: string = '', options?: HttpOptions) {\n    return (_target: BaseApi, targetKey?: string, descriptor?: PropertyDescriptor) => {\n      descriptor!.value = function (...args: any[]): Observable<any> {\n        options = options || {};\n\n        const injector = (this as NzSafeAny).injector as Injector;\n        const http = injector.get(_HttpClient, null) as _HttpClient;\n        if (http == null) {\n          throw new TypeError(\n            `Not found '_HttpClient', You can import 'AlainThemeModule' && 'HttpClientModule' in your root module.`\n          );\n        }\n\n        const baseData = setParam(this);\n        const data = setParam(baseData, targetKey);\n\n        let requestUrl = url || '';\n        requestUrl = [baseData.baseUrl || '', requestUrl.startsWith('/') ? requestUrl.substring(1) : requestUrl].join(\n          '/'\n        );\n        // fix last split\n        if (requestUrl.length > 1 && requestUrl.endsWith('/')) {\n          requestUrl = requestUrl.substring(0, requestUrl.length - 1);\n        }\n\n        if (options.acl) {\n          const aclSrv = injector.get(ACLService, null);\n          if (aclSrv && !aclSrv.can(options.acl)) {\n            return throwError(() => ({\n              url: requestUrl,\n              status: 401,\n              statusText: `From Http Decorator`\n            }));\n          }\n          delete options.acl;\n        }\n\n        requestUrl = requestUrl.replace(/::/g, '^^');\n        ((data.path as ParamType[]) || [])\n          .filter(w => typeof args[w.index] !== 'undefined')\n          .forEach((i: ParamType) => {\n            requestUrl = requestUrl.replace(new RegExp(`:${i.key}`, 'g'), encodeURIComponent(args[i.index]));\n          });\n        requestUrl = requestUrl.replace(/\\^\\^/g, `:`);\n\n        const params = (data.query || []).reduce((p: NzSafeAny, i: ParamType) => {\n          p[i.key] = args[i.index];\n          return p;\n        }, {});\n\n        const headers = (data.headers || []).reduce((p: NzSafeAny, i: ParamType) => {\n          p[i.key] = args[i.index];\n          return p;\n        }, {});\n\n        if (method === 'FORM') {\n          headers['content-type'] = 'application/x-www-form-urlencoded';\n        }\n\n        const payload = getValidArgs(data, 'payload', args);\n        const supportedBody = method === 'POST' || method === 'PUT';\n\n        return http.request(method, requestUrl, {\n          body: supportedBody ? genBody(getValidArgs(data, 'body', args), payload) : null,\n          params: !supportedBody ? { ...params, ...payload } : params,\n          headers: { ...baseData.baseHeaders, ...headers },\n          ...options\n        });\n      };\n\n      return descriptor;\n    };\n  };\n}\n\n/**\n * `OPTIONS` 请求\n * - 有效范围：方法\n */\nexport const OPTIONS = makeMethod('OPTIONS');\n\n/**\n * `GET` 请求\n * - 有效范围：方法\n */\nexport const GET = makeMethod('GET');\n\n/**\n * `POST` 请求\n * - 有效范围：方法\n */\nexport const POST = makeMethod('POST');\n\n/**\n * `DELETE` 请求\n * - 有效范围：方法\n */\nexport const DELETE = makeMethod('DELETE');\n\n/**\n * `PUT` 请求\n * - 有效范围：方法\n */\nexport const PUT = makeMethod('PUT');\n\n/**\n * `HEAD` 请求\n * - 有效范围：方法\n */\nexport const HEAD = makeMethod('HEAD');\n\n/**\n * `PATCH` 请求\n * - 有效范围：方法\n */\nexport const PATCH = makeMethod('PATCH');\n\n/**\n * `JSONP` 请求\n * - 有效范围：方法\n */\nexport const JSONP = makeMethod('JSONP');\n\n/**\n * `FORM` 请求\n * - 有效范围：方法\n */\nexport const FORM = makeMethod('FORM');\n"]}

package/esm2020/src/services/i18n/i18n.mjs

@@ -0,0 +1,97 @@
+import { inject, Injectable, InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { AlainConfigService } from '@delon/util/config';
+import * as i0 from "@angular/core";
+import * as i1 from "@delon/util/config";
+export const ALAIN_I18N_TOKEN = new InjectionToken('alainI18nToken', {
+    providedIn: 'root',
+    factory: () => new AlainI18NServiceFake(inject(AlainConfigService))
+});
+export class AlainI18nBaseService {
+    constructor(cogSrv) {
+        this._change$ = new BehaviorSubject(null);
+        this._currentLang = '';
+        this._defaultLang = '';
+        this._data = {};
+        this.cog = cogSrv.merge('themeI18n', {
+            interpolation: ['{{', '}}']
+        });
+    }
+    get change() {
+        return this._change$.asObservable().pipe(filter(w => w != null));
+    }
+    get defaultLang() {
+        return this._defaultLang;
+    }
+    get currentLang() {
+        return this._currentLang;
+    }
+    get data() {
+        return this._data;
+    }
+    /**
+     * Flattened data source
+     *
+     * @example
+     * {
+     *   "name": "Name",
+     *   "sys": {
+     *     "": "System",
+     *     "title": "Title"
+     *   }
+     * }
+     * =>
+     * {
+     *   "name": "Name",
+     *   "sys": "System",
+     *   "sys.title": "Title"
+     * }
+     */
+    flatData(data, parentKey) {
+        const res = {};
+        for (const key of Object.keys(data)) {
+            const value = data[key];
+            if (typeof value === 'object') {
+                const child = this.flatData(value, parentKey.concat(key));
+                Object.keys(child).forEach(childKey => (res[childKey] = child[childKey]));
+            }
+            else {
+                res[(key ? parentKey.concat(key) : parentKey).join('.')] = `${value}`;
+            }
+        }
+        return res;
+    }
+    fanyi(path, params) {
+        let content = this._data[path] || '';
+        if (!content)
+            return path;
+        if (params) {
+            const interpolation = this.cog.interpolation;
+            Object.keys(params).forEach(key => (content = content.replace(new RegExp(`${interpolation[0]}\s?${key}\s?${interpolation[1]}`, 'g'), `${params[key]}`)));
+        }
+        return content;
+    }
+}
+AlainI18nBaseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18nBaseService, deps: [{ token: i1.AlainConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+AlainI18nBaseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18nBaseService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18nBaseService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AlainConfigService }]; } });
+export class AlainI18NServiceFake extends AlainI18nBaseService {
+    use(lang, data) {
+        this._data = this.flatData(data, []);
+        this._currentLang = lang;
+        this._change$.next(lang);
+    }
+    getLangs() {
+        return [];
+    }
+}
+AlainI18NServiceFake.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18NServiceFake, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+AlainI18NServiceFake.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18NServiceFake, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: AlainI18NServiceFake, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../../../../../../../packages/theme/src/services/i18n/i18n.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, InjectionToken } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { filter } from 'rxjs/operators';\n\nimport { AlainConfigService, AlainThemeI18nConfig } from '@delon/util/config';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { _HttpClient } from '../http/http.client';\n\nexport interface AlainI18NService {\n  [key: string]: NzSafeAny;\n\n  /**\n   * Call `use` to trigger change notification\n   *\n   * 调用 `use` 触发变更通知\n   */\n  readonly change: Observable<string>;\n\n  /**\n   * Get the default language\n   *\n   * 获取默认语言\n   */\n  readonly defaultLang: string;\n\n  /**\n   * Get current language\n   *\n   * 获取当前语言\n   */\n  readonly currentLang: string;\n\n  /**\n   * Change language\n   *\n   * 变更语言\n   *\n   * @param emit 是否触发 `change`，默认：true ; Should be removed, please use `change` event instead.\n   */\n  use(lang: string, data?: Record<string, unknown>): void;\n\n  /**\n   * Return to the current language list\n   *\n   * 返回当前语言列表\n   */\n  getLangs(): NzSafeAny[];\n\n  /**\n   * Translate 翻译\n   *\n   * @param params 模板所需要的参数对象\n   * @param isSafe 是否返回安全字符，自动调用 `bypassSecurityTrustHtml`; Should be removed, If you need SafeHtml support, please use `| html` pipe instead.\n   */\n  fanyi(path: string, params?: unknown): string;\n}\n\nexport const ALAIN_I18N_TOKEN = new InjectionToken<AlainI18NService>('alainI18nToken', {\n  providedIn: 'root',\n  factory: () => new AlainI18NServiceFake(inject(AlainConfigService))\n});\n\n@Injectable()\nexport abstract class AlainI18nBaseService implements AlainI18NService {\n  private cog: AlainThemeI18nConfig;\n  protected _change$ = new BehaviorSubject<string | null>(null);\n  protected _currentLang: string = '';\n  protected _defaultLang: string = '';\n  protected _data: Record<string, string> = {};\n  get change(): Observable<string> {\n    return this._change$.asObservable().pipe(filter(w => w != null)) as Observable<string>;\n  }\n  get defaultLang(): string {\n    return this._defaultLang;\n  }\n  get currentLang(): string {\n    return this._currentLang;\n  }\n  get data(): Record<string, string> {\n    return this._data;\n  }\n\n  constructor(cogSrv: AlainConfigService) {\n    this.cog = cogSrv.merge('themeI18n', {\n      interpolation: ['{{', '}}']\n    })!;\n  }\n\n  /**\n   * Flattened data source\n   *\n   * @example\n   * {\n   *   \"name\": \"Name\",\n   *   \"sys\": {\n   *     \"\": \"System\",\n   *     \"title\": \"Title\"\n   *   }\n   * }\n   * =>\n   * {\n   *   \"name\": \"Name\",\n   *   \"sys\": \"System\",\n   *   \"sys.title\": \"Title\"\n   * }\n   */\n  flatData(data: Record<string, unknown>, parentKey: string[]): Record<string, string> {\n    const res: Record<string, string> = {};\n    for (const key of Object.keys(data)) {\n      const value = data[key];\n      if (typeof value === 'object') {\n        const child = this.flatData(value as Record<string, unknown>, parentKey.concat(key));\n        Object.keys(child).forEach(childKey => (res[childKey] = child[childKey]));\n      } else {\n        res[(key ? parentKey.concat(key) : parentKey).join('.')] = `${value}`;\n      }\n    }\n    return res;\n  }\n\n  abstract use(lang: string, data?: Record<string, unknown>): void;\n\n  abstract getLangs(): NzSafeAny[];\n\n  fanyi(path: string, params?: Record<string, unknown>): string {\n    let content = this._data[path] || '';\n    if (!content) return path;\n\n    if (params) {\n      const interpolation = this.cog.interpolation!!;\n      Object.keys(params).forEach(\n        key =>\n          (content = content.replace(\n            new RegExp(`${interpolation[0]}\\s?${key}\\s?${interpolation[1]}`, 'g'),\n            `${params[key]}`\n          ))\n      );\n    }\n    return content;\n  }\n}\n\n@Injectable({ providedIn: 'root' })\nexport class AlainI18NServiceFake extends AlainI18nBaseService {\n  use(lang: string, data: Record<string, unknown>): void {\n    this._data = this.flatData(data, []);\n    this._currentLang = lang;\n    this._change$.next(lang);\n  }\n\n  getLangs(): NzSafeAny[] {\n    return [];\n  }\n}\n"]}

package/esm2020/src/services/i18n/i18n.pipe.mjs

@@ -0,0 +1,21 @@
+import { Inject, Pipe } from '@angular/core';
+import { ALAIN_I18N_TOKEN } from './i18n';
+import * as i0 from "@angular/core";
+export class I18nPipe {
+    constructor(i18n) {
+        this.i18n = i18n;
+    }
+    transform(key, params) {
+        return this.i18n.fanyi(key, params);
+    }
+}
+I18nPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: I18nPipe, deps: [{ token: ALAIN_I18N_TOKEN }], target: i0.ɵɵFactoryTarget.Pipe });
+I18nPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: I18nPipe, name: "i18n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.2", ngImport: i0, type: I18nPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'i18n' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ALAIN_I18N_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaTE4bi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvdGhlbWUvc3JjL3NlcnZpY2VzL2kxOG4vaTE4bi5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUU1RCxPQUFPLEVBQW9CLGdCQUFnQixFQUFFLE1BQU0sUUFBUSxDQUFDOztBQUc1RCxNQUFNLE9BQU8sUUFBUTtJQUNuQixZQUE4QyxJQUFzQjtRQUF0QixTQUFJLEdBQUosSUFBSSxDQUFrQjtJQUFHLENBQUM7SUFFeEUsU0FBUyxDQUFDLEdBQVcsRUFBRSxNQUFnQztRQUNyRCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUN0QyxDQUFDOztxR0FMVSxRQUFRLGtCQUNDLGdCQUFnQjttR0FEekIsUUFBUTsyRkFBUixRQUFRO2tCQURwQixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRTs7MEJBRVAsTUFBTTsyQkFBQyxnQkFBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3QsIFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQWxhaW5JMThOU2VydmljZSwgQUxBSU5fSTE4Tl9UT0tFTiB9IGZyb20gJy4vaTE4bic7XG5cbkBQaXBlKHsgbmFtZTogJ2kxOG4nIH0pXG5leHBvcnQgY2xhc3MgSTE4blBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgY29uc3RydWN0b3IoQEluamVjdChBTEFJTl9JMThOX1RPS0VOKSBwcml2YXRlIGkxOG46IEFsYWluSTE4TlNlcnZpY2UpIHt9XG5cbiAgdHJhbnNmb3JtKGtleTogc3RyaW5nLCBwYXJhbXM/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPik6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuaTE4bi5mYW55aShrZXksIHBhcmFtcyk7XG4gIH1cbn1cbiJdfQ==