ngx-cho-common 0.0.1

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

@@ -0,0 +1,33 @@
+import { HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ObjectService {
+    toValueObject(obj) {
+        const result = Object.getOwnPropertyNames(obj).reduce((p, key) => {
+            if (obj[key]) {
+                p[key] = obj[key];
+            }
+            return p;
+        }, new Object());
+        return result;
+    }
+    /**
+     * Convert Object to HttpParams
+     * @param {object} obj
+     * @returns {HttpParams}
+     * see: https://stackoverflow.com/questions/45210406/angular-4-3-httpclient-set-params
+     */
+    toHttpParams(obj) {
+        const temp = Object.getOwnPropertyNames(obj).reduce((p, key) => (obj[key] == null || obj[key].length === 0 ? p : p.set(key, obj[key])), new HttpParams());
+        return temp;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ObjectService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3NlcnZpY2VzL29iamVjdC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sYUFBYTtJQUNmLGFBQWEsQ0FBQyxHQUFXO1FBQzVCLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUU7WUFDN0QsSUFBSSxHQUFHLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztnQkFDWCxDQUFDLENBQUMsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3RCLENBQUM7WUFDRCxPQUFPLENBQUMsQ0FBQztRQUNiLENBQUMsRUFBRSxJQUFJLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFFakIsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0ksWUFBWSxDQUFDLEdBQVc7UUFDM0IsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLG1CQUFtQixDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sQ0FDL0MsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLElBQUksR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLE1BQU0sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFDbEYsSUFBSSxVQUFVLEVBQUUsQ0FDbkIsQ0FBQztRQUVGLE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUM7K0dBekJRLGFBQWE7bUhBQWIsYUFBYSxjQUZWLE1BQU07OzRGQUVULGFBQWE7a0JBSHpCLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cFBhcmFtcyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgT2JqZWN0U2VydmljZSB7XG4gICAgcHVibGljIHRvVmFsdWVPYmplY3Qob2JqOiBvYmplY3QpOiBvYmplY3Qge1xuICAgICAgICBjb25zdCByZXN1bHQgPSBPYmplY3QuZ2V0T3duUHJvcGVydHlOYW1lcyhvYmopLnJlZHVjZSgocCwga2V5KSA9PiB7XG4gICAgICAgICAgICBpZiAob2JqW2tleV0pIHtcbiAgICAgICAgICAgICAgICBwW2tleV0gPSBvYmpba2V5XTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHJldHVybiBwO1xuICAgICAgICB9LCBuZXcgT2JqZWN0KCkpO1xuXG4gICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ29udmVydCBPYmplY3QgdG8gSHR0cFBhcmFtc1xuICAgICAqIEBwYXJhbSB7b2JqZWN0fSBvYmpcbiAgICAgKiBAcmV0dXJucyB7SHR0cFBhcmFtc31cbiAgICAgKiBzZWU6IGh0dHBzOi8vc3RhY2tvdmVyZmxvdy5jb20vcXVlc3Rpb25zLzQ1MjEwNDA2L2FuZ3VsYXItNC0zLWh0dHBjbGllbnQtc2V0LXBhcmFtc1xuICAgICAqL1xuICAgIHB1YmxpYyB0b0h0dHBQYXJhbXMob2JqOiBvYmplY3QpOiBIdHRwUGFyYW1zIHtcbiAgICAgICAgY29uc3QgdGVtcCA9IE9iamVjdC5nZXRPd25Qcm9wZXJ0eU5hbWVzKG9iaikucmVkdWNlKFxuICAgICAgICAgICAgKHAsIGtleSkgPT4gKG9ialtrZXldID09IG51bGwgfHwgb2JqW2tleV0ubGVuZ3RoID09PSAwID8gcCA6IHAuc2V0KGtleSwgb2JqW2tleV0pKSxcbiAgICAgICAgICAgIG5ldyBIdHRwUGFyYW1zKClcbiAgICAgICAgKTtcblxuICAgICAgICByZXR1cm4gdGVtcDtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/services/rest-client.service.mjs

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { lastValueFrom, retry, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class RestClient {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.defaultRetry = { count: 0, delay: 1000 };
+    }
+    /**
+     * Sends a delete request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    delete(url, options) {
+        return lastValueFrom(this.request('DELETE', url, options));
+    }
+    /**
+     * Retrieves data from the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    get(url, options) {
+        return lastValueFrom(this.request('GET', url, options));
+    }
+    /**
+     * Sends a patch request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    patch(url, options) {
+        return lastValueFrom(this.request('PATCH', url, options));
+    }
+    /**
+     * Sends a post request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    post(url, options) {
+        return lastValueFrom(this.request('POST', url, options));
+    }
+    /**
+     * Sends a put request to the specified REST service
+     *
+     * @param url The service endpoint
+     * @param options Additional options
+     */
+    put(url, options) {
+        return lastValueFrom(this.request('PUT', url, options));
+    }
+    request(method, url, options) {
+        return this.httpClient
+            .request(method, url, {
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            headers: this.createRequestHeaders(options),
+            params: this.createRequestParams(options?.queryParameters),
+        })
+            .pipe(take(1), retry(options?.retry || this.defaultRetry));
+    }
+    /**
+     *
+     * @param url
+     * @param options
+     * @returns
+     */
+    getResponse(method, url, options) {
+        return this.httpClient
+            .request(method, url, {
+            observe: 'response',
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            headers: this.createRequestHeaders(options),
+            params: this.createRequestParams(options?.queryParameters),
+        })
+            .pipe(take(1), retry(options?.retry || this.defaultRetry));
+    }
+    /**
+     * Creates request headers based on the provided options.
+     *
+     * @param options
+     * @returns
+     */
+    createRequestHeaders(options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const headers = Object.assign({
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        }, options?.headers);
+        if (options?.apiVersion) {
+            const versionString = `; version=${options.apiVersion}`;
+            headers.Accept += versionString;
+            headers['Content-Type'] += versionString;
+        }
+        if (options?.showSpinner === false) {
+            headers['x-spinner'] = 'false';
+        }
+        if (options?.cacheLifetimeSeconds) {
+            headers['x-cache-ttl'] = options?.cacheLifetimeSeconds;
+        }
+        return new HttpHeaders(headers);
+    }
+    /**
+     * Converts one or more objects to an HttpParams object.
+     *
+     * @param sources The objects to convert
+     * @returns
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    createRequestParams(...sources) {
+        let params = new HttpParams();
+        for (const source of sources) {
+            if (source == null) {
+                continue;
+            }
+            for (const key of Object.keys(source)) {
+                const value = source[key];
+                if (value != null) {
+                    params = params.set(key, value.toString());
+                }
+            }
+        }
+        return params;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RestClient, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-client.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-cho-common/src/lib/services/rest-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/ban-types */\nimport { HttpClient, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { lastValueFrom, Observable, retry, RetryConfig, take } from 'rxjs';\n\ntype RequestParameters = {\n    body?: unknown;\n    queryParameters?: {};\n    apiVersion?: {};\n    headers?: {};\n    cacheLifetimeSeconds?: number;\n    retry?: RetryConfig;\n    showSpinner?: {};\n};\n\ntype DeleteRequestParameters = Omit<RequestParameters, 'body' | 'cacheLifetimeSeconds'>;\ntype GetRequestParameters = Omit<RequestParameters, 'body'>;\n\n@Injectable({ providedIn: 'any' })\nexport class RestClient {\n    private readonly defaultRetry = { count: 0, delay: 1000 };\n\n    constructor(private readonly httpClient: HttpClient) {}\n\n    /**\n     * Sends a delete request to the specified REST service\n     *\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public delete(url: string, options?: DeleteRequestParameters): Promise<void> {\n        return lastValueFrom(this.request('DELETE', url, options));\n    }\n\n    /**\n     * Retrieves data from the specified REST service\n     *\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public get<T>(url: string, options?: GetRequestParameters): Promise<T> {\n        return lastValueFrom(this.request('GET', url, options));\n    }\n\n    /**\n     * Sends a patch request to the specified REST service\n     *\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public patch<T>(url: string, options?: RequestParameters): Promise<T> {\n        return lastValueFrom(this.request('PATCH', url, options));\n    }\n\n    /**\n     * Sends a post request to the specified REST service\n     *\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public post<T>(url: string, options?: RequestParameters): Promise<T> {\n        return lastValueFrom(this.request('POST', url, options));\n    }\n\n    /**\n     * Sends a put request to the specified REST service\n     *\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public put<T>(url: string, options?: RequestParameters): Promise<T> {\n        return lastValueFrom(this.request('PUT', url, options));\n    }\n\n    /**\n     * Sends a request to the specified REST service\n     *\n     * @param method DELETE, GET, POST, PUT, or PATCH\n     * @param url The service endpoint\n     * @param options Additional options\n     */\n    public request<T>(\n        method: 'DELETE',\n        url: string,\n        options?: DeleteRequestParameters\n    ): Observable<T>;\n    public request<T>(method: 'GET', url: string, options?: GetRequestParameters): Observable<T>;\n    public request<T>(\n        method: 'POST' | 'PUT' | 'PATCH',\n        url: string,\n        options?: RequestParameters\n    ): Observable<T>;\n\n    public request<T>(\n        method: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT',\n        url: string,\n        options?: RequestParameters\n    ): Observable<T> {\n        return this.httpClient\n            .request<T>(method, url, {\n                body: options?.body ? JSON.stringify(options.body) : undefined,\n                headers: this.createRequestHeaders(options),\n                params: this.createRequestParams(options?.queryParameters),\n            })\n            .pipe(take(1), retry(options?.retry || this.defaultRetry));\n    }\n\n    /**\n     *\n     * @param url\n     * @param options\n     * @returns\n     */\n    public getResponse<T>(\n        method: 'GET' | 'PATCH' | 'POST' | 'PUT',\n        url: string,\n        options?: RequestParameters\n    ): Observable<HttpResponse<T>> {\n        return this.httpClient\n            .request<T>(method, url, {\n                observe: 'response',\n                body: options?.body ? JSON.stringify(options.body) : undefined,\n                headers: this.createRequestHeaders(options),\n                params: this.createRequestParams(options?.queryParameters),\n            })\n            .pipe(take(1), retry(options?.retry || this.defaultRetry));\n    }\n\n    /**\n     * Creates request headers based on the provided options.\n     *\n     * @param options\n     * @returns\n     */\n    private createRequestHeaders(options?: RequestParameters): HttpHeaders {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const headers: any = Object.assign(\n            {\n                Accept: 'application/json',\n                'Content-Type': 'application/json',\n            },\n            options?.headers\n        );\n\n        if (options?.apiVersion) {\n            const versionString = `; version=${options.apiVersion}`;\n\n            headers.Accept += versionString;\n            headers['Content-Type'] += versionString;\n        }\n\n        if (options?.showSpinner === false) {\n            headers['x-spinner'] = 'false';\n        }\n\n        if (options?.cacheLifetimeSeconds) {\n            headers['x-cache-ttl'] = options?.cacheLifetimeSeconds;\n        }\n\n        return new HttpHeaders(headers);\n    }\n\n    /**\n     * Converts one or more objects to an HttpParams object.\n     *\n     * @param sources The objects to convert\n     * @returns\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private createRequestParams(...sources: any[]): HttpParams {\n        let params = new HttpParams();\n\n        for (const source of sources) {\n            if (source == null) {\n                continue;\n            }\n\n            for (const key of Object.keys(source)) {\n                const value = source[key];\n\n                if (value != null) {\n                    params = params.set(key, value.toString());\n                }\n            }\n        }\n\n        return params;\n    }\n}\n"]}

package/esm2022/lib/services/route-param.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class RouteParamService {
+    constructor(route) {
+        this.route = route;
+    }
+    getParameterBoolean(params, paramKey) {
+        const value = this.getParameterValue(params, paramKey);
+        if (value) {
+            return !!value;
+        }
+        return null;
+    }
+    getParameterNumber(params, paramKey) {
+        const value = this.getParameterValue(params, paramKey);
+        if (value) {
+            return parseInt(value);
+        }
+        return null;
+    }
+    getParameterValue(params, paramKey) {
+        const value = params[paramKey];
+        return value || null;
+    }
+    getQueryParameterBoolean(paramKey) {
+        return this.getParameterBoolean(this.route.snapshot.queryParams, paramKey);
+    }
+    getQueryParameterNumber(paramKey) {
+        return this.getParameterNumber(this.route.snapshot.queryParams, paramKey);
+    }
+    getQueryParameterValue(paramKey) {
+        return this.getParameterValue(this.route.snapshot.queryParams, paramKey);
+    }
+    getRouteParameterBoolean(route, paramKey) {
+        return this.getParameterBoolean(route.snapshot.params, paramKey);
+    }
+    getRouteParameterNumber(route, paramKey) {
+        return this.getParameterNumber(route.snapshot.params, paramKey);
+    }
+    getRouteParameterValue(route, paramKey) {
+        return this.getParameterValue(route.snapshot.params, paramKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, deps: [{ token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteParamService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/session-storage.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorageService {
+    checkIfKeyExists(key) {
+        return globalThis.sessionStorage.getItem(key) !== null;
+    }
+    getItem(key) {
+        const valueString = globalThis.sessionStorage.getItem(key);
+        if (valueString === null) {
+            return undefined;
+        }
+        const value = JSON.parse(valueString);
+        return value;
+    }
+    setItem(key, value) {
+        const valueString = JSON.stringify(value);
+        globalThis.sessionStorage.setItem(key, valueString);
+    }
+    removeItem(key) {
+        globalThis.sessionStorage.removeItem(key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/types/indexable.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhhYmxlLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3R5cGVzL2luZGV4YWJsZS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFR5cGVzIHRoYXQgcHJvdmlkZSBpbmRleGVyc1xuICovXG5leHBvcnQgdHlwZSBJbmRleGFibGUgPSB7IFtrZXk6IHN0cmluZ106IHVua25vd24gfTtcbiJdfQ==

package/esm2022/lib/types/name-value-item.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFtZS12YWx1ZS1pdGVtLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbGliL3R5cGVzL25hbWUtdmFsdWUtaXRlbS50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBOYW1lVmFsdWVJdGVtPFQ+ID0ge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICB2YWx1ZTogVDtcbn07XG5cbmV4cG9ydCB0eXBlIE51bWJlck5hbWVWYWx1ZUl0ZW0gPSBOYW1lVmFsdWVJdGVtPG51bWJlcj47XG4iXX0=

package/esm2022/ngx-cho-common.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWNoby1jb21tb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZ3gtY2hvLWNvbW1vbi9zcmMvbmd4LWNoby1jb21tb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,32 @@
+/*
+ * Public API Surface of ngx-cho-common
+ */
+export { AuthCallbackComponent } from './lib/security/auth-callback/auth-callback.component';
+export { AuthGuardService } from './lib/security/services/auth-guard.service';
+export { AuthService } from './lib/security/services/auth.service';
+export { AuthUser } from './lib/security/models/auth-user.model';
+export { AuthorizationContext } from './lib/security/models/authorization-context.model';
+export { SECURITY_POLICIES } from './lib/security/security-policies';
+export { SecurityPolicy } from './lib/security/models/security-policy.model';
+export { SigninComponent } from './lib/security/signin/signin.component';
+export { SignoutComponent } from './lib/security/signout/signout.component';
+export { SeverityLevel } from './lib/logging/models/severity-level.enum';
+export { ConsoleLoggerSink } from './lib/logging/console-logger.sink';
+export { Logger } from './lib/logging/logger.model';
+export { LoggerService } from './lib/logging/logger.service';
+export { ServerLoggerSink } from './lib/logging/server-logger.sink';
+export { DateService } from './lib/services/date.service';
+export { DownloadService } from './lib/services/download.service';
+export { FeatureGuardService } from './lib/guards/feature-guard.service';
+export { FeatureService } from './lib/services/feature.service';
+export { IntervalService, IntervalTimer } from './lib/services/interval.service';
+export { LocalStorageService } from './lib/services/local-storage.service';
+export { ModalService } from './lib/services/modal.service';
+export { NavigationService } from './lib/services/navigation.service';
+export { ObjectService } from './lib/services/object.service';
+export { RestClient } from './lib/services/rest-client.service';
+export { RouteParamService } from './lib/services/route-param.service';
+export { SessionStorageService } from './lib/services/session-storage.service';
+export { UnsavedChangesGuard } from './lib/guards/unsaved-changes.guard';
+export { Uuid } from './lib/models/uuid.model';
+//# sourceMappingURL=data:application/json;base64,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