@abp/ng.core 7.2.2 → 7.3.0-rc.1

package/esm2022/lib/services/config-state.service.mjs

@@ -0,0 +1,182 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { map, switchMap, take, tap } from 'rxjs/operators';
+import { AbpApplicationConfigurationService } from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-configuration.service';
+import { AbpApplicationLocalizationService } from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-localization.service';
+import { INCUDE_LOCALIZATION_RESOURCES_TOKEN } from '../tokens/include-localization-resources.token';
+import { InternalStore } from '../utils/internal-store-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-configuration.service";
+import * as i2 from "../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-localization.service";
+class ConfigStateService {
+    setState(config) {
+        this.store.set(config);
+    }
+    get createOnUpdateStream() {
+        return this.store.sliceUpdate;
+    }
+    constructor(abpConfigService, abpApplicationLocalizationService, includeLocalizationResources) {
+        this.abpConfigService = abpConfigService;
+        this.abpApplicationLocalizationService = abpApplicationLocalizationService;
+        this.includeLocalizationResources = includeLocalizationResources;
+        this.updateSubject = new Subject();
+        this.store = new InternalStore({});
+        this.initUpdateStream();
+    }
+    initUpdateStream() {
+        this.updateSubject
+            .pipe(switchMap(() => this.abpConfigService.get({
+            includeLocalizationResources: !!this.includeLocalizationResources,
+        })))
+            .pipe(switchMap(appState => this.getLocalizationAndCombineWithAppState(appState)))
+            .subscribe(res => this.store.set(res));
+    }
+    getLocalizationAndCombineWithAppState(appState) {
+        if (!appState.localization.currentCulture.cultureName) {
+            throw new Error('culture name should defined');
+        }
+        return this.getlocalizationResource(appState.localization.currentCulture.cultureName).pipe(map(result => ({ ...appState, localization: { ...appState.localization, ...result } })));
+    }
+    getlocalizationResource(cultureName) {
+        return this.abpApplicationLocalizationService.get({
+            cultureName: cultureName,
+            onlyDynamics: false,
+        });
+    }
+    refreshAppState() {
+        this.updateSubject.next();
+        return this.createOnUpdateStream(state => state).pipe(take(1));
+    }
+    refreshLocalization(lang) {
+        if (this.includeLocalizationResources) {
+            return this.refreshAppState().pipe(map(() => null));
+        }
+        else {
+            return this.getlocalizationResource(lang)
+                .pipe(tap(result => this.store.patch({ localization: { ...this.store.state.localization, ...result } })))
+                .pipe(map(() => null));
+        }
+    }
+    getOne$(key) {
+        return this.store.sliceState(state => state[key]);
+    }
+    getOne(key) {
+        return this.store.state[key];
+    }
+    getAll$() {
+        return this.store.sliceState(state => state);
+    }
+    getAll() {
+        return this.store.state;
+    }
+    getDeep$(keys) {
+        keys = splitKeys(keys);
+        return this.store
+            .sliceState(state => state)
+            .pipe(map(state => {
+            return keys.reduce((acc, val) => {
+                if (acc) {
+                    return acc[val];
+                }
+                return undefined;
+            }, state);
+        }));
+    }
+    getDeep(keys) {
+        keys = splitKeys(keys);
+        return keys.reduce((acc, val) => {
+            if (acc) {
+                return acc[val];
+            }
+            return undefined;
+        }, this.store.state);
+    }
+    getFeature(key) {
+        return this.store.state.features?.values?.[key];
+    }
+    getFeature$(key) {
+        return this.store.sliceState(state => state.features?.values?.[key]);
+    }
+    getFeatures(keys) {
+        const { features } = this.store.state;
+        if (!features)
+            return;
+        return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
+    }
+    getFeatures$(keys) {
+        return this.store.sliceState(({ features }) => {
+            if (!features?.values)
+                return;
+            return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});
+        });
+    }
+    getSetting(key) {
+        return this.store.state.setting?.values?.[key];
+    }
+    getSetting$(key) {
+        return this.store.sliceState(state => state.setting?.values?.[key]);
+    }
+    getSettings(keyword) {
+        const settings = this.store.state.setting?.values || {};
+        if (!keyword)
+            return settings;
+        const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+        return keysFound.reduce((acc, key) => {
+            acc[key] = settings[key];
+            return acc;
+        }, {});
+    }
+    getSettings$(keyword) {
+        return this.store
+            .sliceState(state => state.setting?.values)
+            .pipe(map((settings = {}) => {
+            if (!keyword)
+                return settings;
+            const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);
+            return keysFound.reduce((acc, key) => {
+                acc[key] = settings[key];
+                return acc;
+            }, {});
+        }));
+    }
+    getGlobalFeatures() {
+        return this.store.state.globalFeatures;
+    }
+    getGlobalFeatures$() {
+        return this.store.sliceState(state => state.globalFeatures);
+    }
+    isGlobalFeatureEnabled(key, globalFeatures) {
+        const features = globalFeatures.enabledFeatures || [];
+        return features.some(f => key === f);
+    }
+    getGlobalFeatureIsEnabled(key) {
+        return this.isGlobalFeatureEnabled(key, this.store.state.globalFeatures);
+    }
+    getGlobalFeatureIsEnabled$(key) {
+        return this.store.sliceState(state => this.isGlobalFeatureEnabled(key, state.globalFeatures));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ConfigStateService, deps: [{ token: i1.AbpApplicationConfigurationService }, { token: i2.AbpApplicationLocalizationService }, { token: INCUDE_LOCALIZATION_RESOURCES_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ConfigStateService, providedIn: 'root' }); }
+}
+export { ConfigStateService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ConfigStateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AbpApplicationConfigurationService }, { type: i2.AbpApplicationLocalizationService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [INCUDE_LOCALIZATION_RESOURCES_TOKEN]
+                }] }]; } });
+function splitKeys(keys) {
+    if (typeof keys === 'string') {
+        keys = keys.split('.');
+    }
+    if (!Array.isArray(keys)) {
+        throw new Error('The argument must be a dot string or an string array.');
+    }
+    return keys;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-state.service.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/services/config-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\r\nimport { Observable, Subject } from 'rxjs';\r\nimport { map, switchMap, take, tap } from 'rxjs/operators';\r\nimport { AbpApplicationConfigurationService } from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-configuration.service';\r\nimport { AbpApplicationLocalizationService } from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/abp-application-localization.service';\r\nimport {\r\n  ApplicationConfigurationDto,\r\n  ApplicationGlobalFeatureConfigurationDto,\r\n} from '../proxy/volo/abp/asp-net-core/mvc/application-configurations/models';\r\nimport { INCUDE_LOCALIZATION_RESOURCES_TOKEN } from '../tokens/include-localization-resources.token';\r\nimport { InternalStore } from '../utils/internal-store-utils';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ConfigStateService {\r\n  private updateSubject = new Subject<void>();\r\n  private readonly store = new InternalStore({} as ApplicationConfigurationDto);\r\n\r\n  setState(config: ApplicationConfigurationDto) {\r\n    this.store.set(config);\r\n  }\r\n\r\n  get createOnUpdateStream() {\r\n    return this.store.sliceUpdate;\r\n  }\r\n  constructor(\r\n    private abpConfigService: AbpApplicationConfigurationService,\r\n    private abpApplicationLocalizationService: AbpApplicationLocalizationService,\r\n    @Optional()\r\n    @Inject(INCUDE_LOCALIZATION_RESOURCES_TOKEN)\r\n    private readonly includeLocalizationResources: boolean | null,\r\n  ) {\r\n    this.initUpdateStream();\r\n  }\r\n\r\n  private initUpdateStream() {\r\n    this.updateSubject\r\n      .pipe(\r\n        switchMap(() =>\r\n          this.abpConfigService.get({\r\n            includeLocalizationResources: !!this.includeLocalizationResources,\r\n          }),\r\n        ),\r\n      )\r\n      .pipe(switchMap(appState => this.getLocalizationAndCombineWithAppState(appState)))\r\n      .subscribe(res => this.store.set(res));\r\n  }\r\n\r\n  private getLocalizationAndCombineWithAppState(\r\n    appState: ApplicationConfigurationDto,\r\n  ): Observable<ApplicationConfigurationDto> {\r\n    if (!appState.localization.currentCulture.cultureName) {\r\n      throw new Error('culture name should defined');\r\n    }\r\n    return this.getlocalizationResource(appState.localization.currentCulture.cultureName).pipe(\r\n      map(result => ({ ...appState, localization: { ...appState.localization, ...result } })),\r\n    );\r\n  }\r\n\r\n  private getlocalizationResource(cultureName: string) {\r\n    return this.abpApplicationLocalizationService.get({\r\n      cultureName: cultureName,\r\n      onlyDynamics: false,\r\n    });\r\n  }\r\n\r\n  refreshAppState() {\r\n    this.updateSubject.next();\r\n    return this.createOnUpdateStream(state => state).pipe(take(1));\r\n  }\r\n\r\n  refreshLocalization(lang: string): Observable<null> {\r\n    if (this.includeLocalizationResources) {\r\n      return this.refreshAppState().pipe(map(() => null));\r\n    } else {\r\n      return this.getlocalizationResource(lang)\r\n        .pipe(\r\n          tap(result =>\r\n            this.store.patch({ localization: { ...this.store.state.localization, ...result } }),\r\n          ),\r\n        )\r\n        .pipe(map(() => null));\r\n    }\r\n  }\r\n\r\n  getOne$<K extends keyof ApplicationConfigurationDto>(key: K) {\r\n    return this.store.sliceState(state => state[key]);\r\n  }\r\n\r\n  getOne<K extends keyof ApplicationConfigurationDto>(key: K) {\r\n    return this.store.state[key];\r\n  }\r\n\r\n  getAll$(): Observable<ApplicationConfigurationDto> {\r\n    return this.store.sliceState(state => state);\r\n  }\r\n\r\n  getAll(): ApplicationConfigurationDto {\r\n    return this.store.state;\r\n  }\r\n\r\n  getDeep$(keys: string[] | string): Observable<any> {\r\n    keys = splitKeys(keys);\r\n\r\n    return this.store\r\n      .sliceState(state => state)\r\n      .pipe(\r\n        map(state => {\r\n          return (keys as string[]).reduce((acc: any, val) => {\r\n            if (acc) {\r\n              return acc[val];\r\n            }\r\n\r\n            return undefined;\r\n          }, state);\r\n        }),\r\n      );\r\n  }\r\n\r\n  getDeep(keys: string[] | string): any {\r\n    keys = splitKeys(keys);\r\n\r\n    return (keys as string[]).reduce((acc: any, val) => {\r\n      if (acc) {\r\n        return acc[val];\r\n      }\r\n\r\n      return undefined;\r\n    }, this.store.state);\r\n  }\r\n\r\n  getFeature(key: string) {\r\n    return this.store.state.features?.values?.[key];\r\n  }\r\n\r\n  getFeature$(key: string) {\r\n    return this.store.sliceState(state => state.features?.values?.[key]);\r\n  }\r\n\r\n  getFeatures(keys: string[]) {\r\n    const { features } = this.store.state;\r\n    if (!features) return;\r\n\r\n    return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});\r\n  }\r\n\r\n  getFeatures$(keys: string[]): Observable<{ [key: string]: string } | undefined> {\r\n    return this.store.sliceState(({ features }) => {\r\n      if (!features?.values) return;\r\n\r\n      return keys.reduce((acc, key) => ({ ...acc, [key]: features.values[key] }), {});\r\n    });\r\n  }\r\n\r\n  getSetting(key: string) {\r\n    return this.store.state.setting?.values?.[key];\r\n  }\r\n\r\n  getSetting$(key: string) {\r\n    return this.store.sliceState(state => state.setting?.values?.[key]);\r\n  }\r\n\r\n  getSettings(keyword?: string) {\r\n    const settings = this.store.state.setting?.values || {};\r\n\r\n    if (!keyword) return settings;\r\n\r\n    const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);\r\n\r\n    return keysFound.reduce((acc, key) => {\r\n      acc[key] = settings[key];\r\n      return acc;\r\n    }, {} as Record<string, string>);\r\n  }\r\n\r\n  getSettings$(keyword?: string) {\r\n    return this.store\r\n      .sliceState(state => state.setting?.values)\r\n      .pipe(\r\n        map((settings = {}) => {\r\n          if (!keyword) return settings;\r\n\r\n          const keysFound = Object.keys(settings).filter(key => key.indexOf(keyword) > -1);\r\n\r\n          return keysFound.reduce((acc, key) => {\r\n            acc[key] = settings[key];\r\n            return acc;\r\n          }, {} as Record<string, string>);\r\n        }),\r\n      );\r\n  }\r\n\r\n  getGlobalFeatures() {\r\n    return this.store.state.globalFeatures;\r\n  }\r\n\r\n  getGlobalFeatures$() {\r\n    return this.store.sliceState(state => state.globalFeatures);\r\n  }\r\n\r\n  private isGlobalFeatureEnabled(\r\n    key: string,\r\n    globalFeatures: ApplicationGlobalFeatureConfigurationDto,\r\n  ) {\r\n    const features = globalFeatures.enabledFeatures || [];\r\n    return features.some(f => key === f);\r\n  }\r\n\r\n  getGlobalFeatureIsEnabled(key: string) {\r\n    return this.isGlobalFeatureEnabled(key, this.store.state.globalFeatures);\r\n  }\r\n\r\n  getGlobalFeatureIsEnabled$(key: string) {\r\n    return this.store.sliceState(state => this.isGlobalFeatureEnabled(key, state.globalFeatures));\r\n  }\r\n}\r\n\r\nfunction splitKeys(keys: string[] | string): string[] {\r\n  if (typeof keys === 'string') {\r\n    keys = keys.split('.');\r\n  }\r\n\r\n  if (!Array.isArray(keys)) {\r\n    throw new Error('The argument must be a dot string or an string array.');\r\n  }\r\n\r\n  return keys;\r\n}\r\n"]}

package/esm2022/lib/services/content-projection.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable, Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+class ContentProjectionService {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    projectContent(projectionStrategy, injector = this.injector) {
+        return projectionStrategy.injectContent(injector);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ContentProjectionService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ContentProjectionService, providedIn: 'root' }); }
+}
+export { ContentProjectionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ContentProjectionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudC1wcm9qZWN0aW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saWIvc2VydmljZXMvY29udGVudC1wcm9qZWN0aW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQXFCLE1BQU0sZUFBZSxDQUFDOztBQUd4RSxNQUNhLHdCQUF3QjtJQUNuQyxZQUFvQixRQUFrQjtRQUFsQixhQUFRLEdBQVIsUUFBUSxDQUFVO0lBQUcsQ0FBQztJQUUxQyxjQUFjLENBQ1osa0JBQXlDLEVBQ3pDLFFBQVEsR0FBRyxJQUFJLENBQUMsUUFBUTtRQUV4QixPQUFPLGtCQUFrQixDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNwRCxDQUFDOzhHQVJVLHdCQUF3QjtrSEFBeEIsd0JBQXdCLGNBRFgsTUFBTTs7U0FDbkIsd0JBQXdCOzJGQUF4Qix3QkFBd0I7a0JBRHBDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0b3IsIFRlbXBsYXRlUmVmLCBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFByb2plY3Rpb25TdHJhdGVneSB9IGZyb20gJy4uL3N0cmF0ZWdpZXMvcHJvamVjdGlvbi5zdHJhdGVneSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxyXG5leHBvcnQgY2xhc3MgQ29udGVudFByb2plY3Rpb25TZXJ2aWNlIHtcclxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGluamVjdG9yOiBJbmplY3Rvcikge31cclxuXHJcbiAgcHJvamVjdENvbnRlbnQ8VCBleHRlbmRzIFR5cGU8YW55PiB8IFRlbXBsYXRlUmVmPGFueT4+KFxyXG4gICAgcHJvamVjdGlvblN0cmF0ZWd5OiBQcm9qZWN0aW9uU3RyYXRlZ3k8VD4sXHJcbiAgICBpbmplY3RvciA9IHRoaXMuaW5qZWN0b3IsXHJcbiAgKSB7XHJcbiAgICByZXR1cm4gcHJvamVjdGlvblN0cmF0ZWd5LmluamVjdENvbnRlbnQoaW5qZWN0b3IpO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/services/dom-insertion.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { generateHash } from '../utils';
+import * as i0 from "@angular/core";
+class DomInsertionService {
+    constructor() {
+        this.inserted = new Set();
+    }
+    insertContent(contentStrategy) {
+        const hash = generateHash(contentStrategy.content);
+        if (this.inserted.has(hash))
+            return;
+        const element = contentStrategy.insertElement();
+        this.inserted.add(hash);
+        return element;
+    }
+    removeContent(element) {
+        if (element.textContent) {
+            const hash = generateHash(element.textContent);
+            this.inserted.delete(hash);
+            element.parentNode?.removeChild(element);
+        }
+    }
+    has(content) {
+        const hash = generateHash(content);
+        return this.inserted.has(hash);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DomInsertionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DomInsertionService, providedIn: 'root' }); }
+}
+export { DomInsertionService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: DomInsertionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/environment.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { InternalStore } from '../utils/internal-store-utils';
+import * as i0 from "@angular/core";
+const mapToApiUrl = (key) => (apis) => ((key && apis[key]) || apis.default).url || apis.default.url;
+const mapToIssuer = (issuer) => {
+    if (!issuer) {
+        return issuer;
+    }
+    return issuer.endsWith('/') ? issuer : issuer + '/';
+};
+class EnvironmentService {
+    constructor() {
+        this.store = new InternalStore({});
+    }
+    get createOnUpdateStream() {
+        return this.store.sliceUpdate;
+    }
+    getEnvironment$() {
+        return this.store.sliceState(state => state);
+    }
+    getEnvironment() {
+        return this.store.state;
+    }
+    getApiUrl(key) {
+        return mapToApiUrl(key)(this.store.state?.apis);
+    }
+    getApiUrl$(key) {
+        return this.store.sliceState(state => state.apis).pipe(map(mapToApiUrl(key)));
+    }
+    setState(environment) {
+        this.store.set(environment);
+    }
+    getIssuer() {
+        const issuer = this.store.state?.oAuthConfig?.issuer;
+        return mapToIssuer(issuer);
+    }
+    getIssuer$() {
+        return this.store.sliceState(state => state?.oAuthConfig?.issuer).pipe(map(mapToIssuer));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: EnvironmentService, providedIn: 'root' }); }
+}
+export { EnvironmentService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http-error-reporter.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+class HttpErrorReporterService {
+    constructor() {
+        this._reporter$ = new Subject();
+        this._errors$ = new BehaviorSubject([]);
+        this.reportError = (error) => {
+            this._reporter$.next(error);
+            this._errors$.next([...this.errors, error]);
+        };
+    }
+    get reporter$() {
+        return this._reporter$.asObservable();
+    }
+    get errors$() {
+        return this._errors$.asObservable();
+    }
+    get errors() {
+        return this._errors$.value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpErrorReporterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpErrorReporterService, providedIn: 'root' }); }
+}
+export { HttpErrorReporterService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpErrorReporterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/http-wait.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable, Injector } from '@angular/core';
+import { InternalStore } from '../utils/internal-store-utils';
+import { getPathName } from '../utils/http-utils';
+import { map, mapTo, switchMap, takeUntil, tap } from 'rxjs/operators';
+import { of, Subject, timer } from 'rxjs';
+import { LOADER_DELAY } from '../tokens/lodaer-delay.token';
+import * as i0 from "@angular/core";
+class HttpWaitService {
+    constructor(injector) {
+        this.store = new InternalStore({
+            requests: [],
+            filteredRequests: [],
+        });
+        this.destroy$ = new Subject();
+        this.delay = injector.get(LOADER_DELAY, 500);
+    }
+    getLoading() {
+        return !!this.applyFilter(this.store.state.requests).length;
+    }
+    getLoading$() {
+        return this.store
+            .sliceState(({ requests }) => requests)
+            .pipe(map(requests => !!this.applyFilter(requests).length), switchMap(condition => condition
+            ? this.delay === 0
+                ? of(true)
+                : timer(this.delay).pipe(mapTo(true), takeUntil(this.destroy$))
+            : of(false)), tap(() => this.destroy$.next()));
+    }
+    updateLoading$() {
+        return this.store.sliceUpdate(({ requests }) => !!this.applyFilter(requests).length);
+    }
+    clearLoading() {
+        this.store.patch({ requests: [] });
+    }
+    addRequest(request) {
+        this.store.patch({ requests: [...this.store.state.requests, request] });
+    }
+    deleteRequest(request) {
+        const requests = this.store.state.requests.filter(r => r !== request);
+        this.store.patch({ requests });
+    }
+    addFilter(request) {
+        const requests = Array.isArray(request) ? request : [request];
+        const filteredRequests = [
+            ...this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r))),
+            ...requests,
+        ];
+        this.store.patch({ filteredRequests });
+    }
+    removeFilter(request) {
+        const requests = Array.isArray(request) ? request : [request];
+        const filteredRequests = this.store.state.filteredRequests.filter(f => !requests.some(r => this.isSameRequest(f, r)));
+        this.store.patch({ filteredRequests });
+    }
+    applyFilter(requests) {
+        if (!requests) {
+            return [];
+        }
+        const { filteredRequests } = this.store.state;
+        return requests.filter(({ method, url }) => !filteredRequests.find(filteredRequest => this.isSameRequest(filteredRequest, { method, endpoint: getPathName(url) })));
+    }
+    isSameRequest(filteredRequest, request) {
+        const { method, endpoint } = filteredRequest;
+        return endpoint === request.endpoint && method === request.method;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpWaitService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpWaitService, providedIn: 'root' }); }
+}
+export { HttpWaitService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: HttpWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-wait.service.js","sourceRoot":"","sources":["../../../../../../packages/core/src/lib/services/http-wait.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\r\nimport { HttpRequest } from '@angular/common/http';\r\nimport { InternalStore } from '../utils/internal-store-utils';\r\nimport { getPathName } from '../utils/http-utils';\r\nimport { map, mapTo, switchMap, takeUntil, tap } from 'rxjs/operators';\r\nimport { of, Subject, timer } from 'rxjs';\r\nimport { LOADER_DELAY } from '../tokens/lodaer-delay.token';\r\n\r\nexport interface HttpWaitState {\r\n  requests: HttpRequest<any>[];\r\n  filteredRequests: Array<HttpRequestInfo>;\r\n}\r\nexport interface HttpRequestInfo {\r\n  method: string;\r\n  endpoint: string;\r\n}\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class HttpWaitService {\r\n  protected store = new InternalStore<HttpWaitState>({\r\n    requests: [],\r\n    filteredRequests: [],\r\n  });\r\n\r\n  private delay: number;\r\n  private destroy$ = new Subject<void>();\r\n\r\n  constructor(injector: Injector) {\r\n    this.delay = injector.get(LOADER_DELAY, 500);\r\n  }\r\n\r\n  getLoading() {\r\n    return !!this.applyFilter(this.store.state.requests).length;\r\n  }\r\n\r\n  getLoading$() {\r\n    return this.store\r\n      .sliceState(({ requests }) => requests)\r\n      .pipe(\r\n        map(requests => !!this.applyFilter(requests).length),\r\n        switchMap(condition =>\r\n          condition\r\n            ? this.delay === 0\r\n              ? of(true)\r\n              : timer(this.delay).pipe(mapTo(true), takeUntil(this.destroy$))\r\n            : of(false),\r\n        ),\r\n        tap(() => this.destroy$.next()),\r\n      );\r\n  }\r\n\r\n  updateLoading$() {\r\n    return this.store.sliceUpdate(({ requests }) => !!this.applyFilter(requests).length);\r\n  }\r\n\r\n  clearLoading() {\r\n    this.store.patch({ requests: [] });\r\n  }\r\n\r\n  addRequest(request: HttpRequest<any>) {\r\n    this.store.patch({ requests: [...this.store.state.requests, request] });\r\n  }\r\n\r\n  deleteRequest(request: HttpRequest<any>) {\r\n    const requests = this.store.state.requests.filter(r => r !== request);\r\n    this.store.patch({ requests });\r\n  }\r\n\r\n  addFilter(request: HttpRequestInfo | HttpRequestInfo[]) {\r\n    const requests = Array.isArray(request) ? request : [request];\r\n    const filteredRequests = [\r\n      ...this.store.state.filteredRequests.filter(\r\n        f => !requests.some(r => this.isSameRequest(f, r)),\r\n      ),\r\n      ...requests,\r\n    ];\r\n    this.store.patch({ filteredRequests });\r\n  }\r\n\r\n  removeFilter(request: HttpRequestInfo | HttpRequestInfo[]) {\r\n    const requests = Array.isArray(request) ? request : [request];\r\n    const filteredRequests = this.store.state.filteredRequests.filter(\r\n      f => !requests.some(r => this.isSameRequest(f, r)),\r\n    );\r\n    this.store.patch({ filteredRequests });\r\n  }\r\n\r\n  private applyFilter(requests: HttpRequest<any>[] | undefined) {\r\n    if (!requests) {\r\n      return [];\r\n    }\r\n    const { filteredRequests } = this.store.state;\r\n    return requests.filter(\r\n      ({ method, url }) =>\r\n        !filteredRequests.find(filteredRequest =>\r\n          this.isSameRequest(filteredRequest, { method, endpoint: getPathName(url) }),\r\n        ),\r\n    );\r\n  }\r\n\r\n  private isSameRequest(filteredRequest: HttpRequestInfo, request: HttpRequestInfo) {\r\n    const { method, endpoint } = filteredRequest;\r\n    return endpoint === request.endpoint && method === request.method;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/services/index.mjs

@@ -1,22 +1,22 @@
-export * from './config-state.service';
-export * from './content-projection.service';
-export * from './dom-insertion.service';
-export * from './environment.service';
-export * from './http-error-reporter.service';
-export * from './http-wait.service';
-export * from './lazy-load.service';
-export * from './list.service';
-export * from './localization.service';
-export * from './multi-tenancy.service';
-export * from './permission.service';
-export * from './replaceable-components.service';
-export * from './resource-wait.service';
-export * from './rest.service';
-export * from './router-events.service';
-export * from './router-wait.service';
-export * from './routes.service';
-export * from './session-state.service';
-export * from './subscription.service';
-export * from './track-by.service';
-export * from './local-storage.service';
+export * from './config-state.service';
+export * from './content-projection.service';
+export * from './dom-insertion.service';
+export * from './environment.service';
+export * from './http-error-reporter.service';
+export * from './http-wait.service';
+export * from './lazy-load.service';
+export * from './list.service';
+export * from './localization.service';
+export * from './multi-tenancy.service';
+export * from './permission.service';
+export * from './replaceable-components.service';
+export * from './resource-wait.service';
+export * from './rest.service';
+export * from './router-events.service';
+export * from './router-wait.service';
+export * from './routes.service';
+export * from './session-state.service';
+export * from './subscription.service';
+export * from './track-by.service';
+export * from './local-storage.service';
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/lazy-load.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { concat, of, pipe, throwError } from 'rxjs';
+import { delay, retryWhen, shareReplay, take, tap } from 'rxjs/operators';
+import { ResourceWaitService } from './resource-wait.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./resource-wait.service";
+class LazyLoadService {
+    constructor(resourceWaitService) {
+        this.resourceWaitService = resourceWaitService;
+        this.loaded = new Map();
+    }
+    load(strategy, retryTimes, retryDelay) {
+        if (this.loaded.has(strategy.path))
+            return of(new CustomEvent('load'));
+        this.resourceWaitService.addResource(strategy.path);
+        const delayOperator = retryDelay ? pipe(delay(retryDelay)) : pipe();
+        const takeOp = retryTimes ? pipe(take(retryTimes)) : pipe();
+        return strategy.createStream().pipe(retryWhen(error$ => concat(error$.pipe(delayOperator, takeOp), throwError(() => new CustomEvent('error')))), tap(() => {
+            this.loaded.set(strategy.path, strategy.element);
+            this.resourceWaitService.deleteResource(strategy.path);
+        }), delay(100), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    remove(path) {
+        const element = this.loaded.get(path);
+        if (!element)
+            return false;
+        element.parentNode?.removeChild(element);
+        this.loaded.delete(path);
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LazyLoadService, deps: [{ token: i1.ResourceWaitService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LazyLoadService, providedIn: 'root' }); }
+}
+export { LazyLoadService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: LazyLoadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ResourceWaitService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF6eS1sb2FkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9saWIvc2VydmljZXMvbGF6eS1sb2FkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsTUFBTSxFQUFjLEVBQUUsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ2hFLE9BQU8sRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFMUUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7OztBQUU5RCxNQUdhLGVBQWU7SUFHMUIsWUFBb0IsbUJBQXdDO1FBQXhDLHdCQUFtQixHQUFuQixtQkFBbUIsQ0FBcUI7UUFGbkQsV0FBTSxHQUFHLElBQUksR0FBRyxFQUFzRCxDQUFDO0lBRWpCLENBQUM7SUFFaEUsSUFBSSxDQUFDLFFBQXlCLEVBQUUsVUFBbUIsRUFBRSxVQUFtQjtRQUN0RSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUM7WUFBRSxPQUFPLEVBQUUsQ0FBQyxJQUFJLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQ3ZFLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3BELE1BQU0sYUFBYSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNwRSxNQUFNLE1BQU0sR0FBRyxVQUFVLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDNUQsT0FBTyxRQUFRLENBQUMsWUFBWSxFQUFFLENBQUMsSUFBSSxDQUNqQyxTQUFTLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FDakIsTUFBTSxDQUNKLE1BQU0sQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQyxFQUNsQyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxXQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FDM0MsQ0FDRixFQUNELEdBQUcsQ0FBQyxHQUFHLEVBQUU7WUFDUCxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNqRCxJQUFJLENBQUMsbUJBQW1CLENBQUMsY0FBYyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN6RCxDQUFDLENBQUMsRUFDRixLQUFLLENBQUMsR0FBRyxDQUFDLEVBQ1YsV0FBVyxDQUFDLEVBQUUsVUFBVSxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FDL0MsQ0FBQztJQUNKLENBQUM7SUFFRCxNQUFNLENBQUMsSUFBWTtRQUNqQixNQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUV0QyxJQUFJLENBQUMsT0FBTztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBRTNCLE9BQU8sQ0FBQyxVQUFVLEVBQUUsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3pDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3pCLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQzs4R0FsQ1UsZUFBZTtrSEFBZixlQUFlLGNBRmQsTUFBTTs7U0FFUCxlQUFlOzJGQUFmLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBjb25jYXQsIE9ic2VydmFibGUsIG9mLCBwaXBlLCB0aHJvd0Vycm9yIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IGRlbGF5LCByZXRyeVdoZW4sIHNoYXJlUmVwbGF5LCB0YWtlLCB0YXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XHJcbmltcG9ydCB7IExvYWRpbmdTdHJhdGVneSB9IGZyb20gJy4uL3N0cmF0ZWdpZXMnO1xyXG5pbXBvcnQgeyBSZXNvdXJjZVdhaXRTZXJ2aWNlIH0gZnJvbSAnLi9yZXNvdXJjZS13YWl0LnNlcnZpY2UnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290JyxcclxufSlcclxuZXhwb3J0IGNsYXNzIExhenlMb2FkU2VydmljZSB7XHJcbiAgcmVhZG9ubHkgbG9hZGVkID0gbmV3IE1hcDxzdHJpbmcsIEhUTUxTY3JpcHRFbGVtZW50IHwgSFRNTExpbmtFbGVtZW50IHwgbnVsbD4oKTtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZXNvdXJjZVdhaXRTZXJ2aWNlOiBSZXNvdXJjZVdhaXRTZXJ2aWNlKSB7fVxyXG5cclxuICBsb2FkKHN0cmF0ZWd5OiBMb2FkaW5nU3RyYXRlZ3ksIHJldHJ5VGltZXM/OiBudW1iZXIsIHJldHJ5RGVsYXk/OiBudW1iZXIpOiBPYnNlcnZhYmxlPEV2ZW50PiB7XHJcbiAgICBpZiAodGhpcy5sb2FkZWQuaGFzKHN0cmF0ZWd5LnBhdGgpKSByZXR1cm4gb2YobmV3IEN1c3RvbUV2ZW50KCdsb2FkJykpO1xyXG4gICAgdGhpcy5yZXNvdXJjZVdhaXRTZXJ2aWNlLmFkZFJlc291cmNlKHN0cmF0ZWd5LnBhdGgpO1xyXG4gICAgY29uc3QgZGVsYXlPcGVyYXRvciA9IHJldHJ5RGVsYXkgPyBwaXBlKGRlbGF5KHJldHJ5RGVsYXkpKSA6IHBpcGUoKTtcclxuICAgIGNvbnN0IHRha2VPcCA9IHJldHJ5VGltZXMgPyBwaXBlKHRha2UocmV0cnlUaW1lcykpIDogcGlwZSgpO1xyXG4gICAgcmV0dXJuIHN0cmF0ZWd5LmNyZWF0ZVN0cmVhbSgpLnBpcGUoXHJcbiAgICAgIHJldHJ5V2hlbihlcnJvciQgPT5cclxuICAgICAgICBjb25jYXQoXHJcbiAgICAgICAgICBlcnJvciQucGlwZShkZWxheU9wZXJhdG9yLCB0YWtlT3ApLFxyXG4gICAgICAgICAgdGhyb3dFcnJvcigoKSA9PiBuZXcgQ3VzdG9tRXZlbnQoJ2Vycm9yJykpLFxyXG4gICAgICAgICksXHJcbiAgICAgICksXHJcbiAgICAgIHRhcCgoKSA9PiB7XHJcbiAgICAgICAgdGhpcy5sb2FkZWQuc2V0KHN0cmF0ZWd5LnBhdGgsIHN0cmF0ZWd5LmVsZW1lbnQpO1xyXG4gICAgICAgIHRoaXMucmVzb3VyY2VXYWl0U2VydmljZS5kZWxldGVSZXNvdXJjZShzdHJhdGVneS5wYXRoKTtcclxuICAgICAgfSksXHJcbiAgICAgIGRlbGF5KDEwMCksXHJcbiAgICAgIHNoYXJlUmVwbGF5KHsgYnVmZmVyU2l6ZTogMSwgcmVmQ291bnQ6IHRydWUgfSksXHJcbiAgICApO1xyXG4gIH1cclxuXHJcbiAgcmVtb3ZlKHBhdGg6IHN0cmluZyk6IGJvb2xlYW4ge1xyXG4gICAgY29uc3QgZWxlbWVudCA9IHRoaXMubG9hZGVkLmdldChwYXRoKTtcclxuXHJcbiAgICBpZiAoIWVsZW1lbnQpIHJldHVybiBmYWxzZTtcclxuXHJcbiAgICBlbGVtZW50LnBhcmVudE5vZGU/LnJlbW92ZUNoaWxkKGVsZW1lbnQpO1xyXG4gICAgdGhpcy5sb2FkZWQuZGVsZXRlKHBhdGgpO1xyXG4gICAgcmV0dXJuIHRydWU7XHJcbiAgfVxyXG59XHJcbiJdfQ==