@entake/particle 17.0.0

package/esm2022/app/modules/week-picker/week-picker.module.mjs

@@ -0,0 +1,40 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { ParticleOrdinalNumberPipeModule } from '../ordinal-number-pipe/ordinal-number-pipe.module';
+import { ParticlePopoverModule } from '../popover/popover.module';
+import { WeekPickerComponent } from './week-picker.component';
+import { ParticleTooltipModule } from '../tooltip/tooltip.module';
+import * as i0 from "@angular/core";
+export class ParticleWeekPickerModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleWeekPickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ParticleWeekPickerModule, declarations: [WeekPickerComponent], imports: [CommonModule,
+            ParticleOrdinalNumberPipeModule,
+            FormsModule,
+            A11yModule,
+            ParticlePopoverModule,
+            ParticleTooltipModule], exports: [WeekPickerComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleWeekPickerModule, imports: [CommonModule,
+            ParticleOrdinalNumberPipeModule,
+            FormsModule,
+            A11yModule,
+            ParticlePopoverModule,
+            ParticleTooltipModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleWeekPickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [WeekPickerComponent],
+                    imports: [
+                        CommonModule,
+                        ParticleOrdinalNumberPipeModule,
+                        FormsModule,
+                        A11yModule,
+                        ParticlePopoverModule,
+                        ParticleTooltipModule
+                    ],
+                    exports: [WeekPickerComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/shared/enums/endpoint-status.enum.mjs

@@ -0,0 +1,11 @@
+/**
+ * Use this enumeration to set the status of a call to an Endpoint
+ */
+export var EndpointStatus;
+(function (EndpointStatus) {
+    EndpointStatus[EndpointStatus["LOADING"] = 0] = "LOADING";
+    EndpointStatus[EndpointStatus["SUCCESS"] = 1] = "SUCCESS";
+    EndpointStatus[EndpointStatus["NORESULTS"] = 2] = "NORESULTS";
+    EndpointStatus[EndpointStatus["ERROR"] = 3] = "ERROR";
+})(EndpointStatus || (EndpointStatus = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5kcG9pbnQtc3RhdHVzLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9lbnVtcy9lbmRwb2ludC1zdGF0dXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGNBS1g7QUFMRCxXQUFZLGNBQWM7SUFDeEIseURBQU8sQ0FBQTtJQUNQLHlEQUFPLENBQUE7SUFDUCw2REFBUyxDQUFBO0lBQ1QscURBQUssQ0FBQTtBQUNQLENBQUMsRUFMVyxjQUFjLEtBQWQsY0FBYyxRQUt6QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVXNlIHRoaXMgZW51bWVyYXRpb24gdG8gc2V0IHRoZSBzdGF0dXMgb2YgYSBjYWxsIHRvIGFuIEVuZHBvaW50XG4gKi9cbmV4cG9ydCBlbnVtIEVuZHBvaW50U3RhdHVzIHtcbiAgTE9BRElORyxcbiAgU1VDQ0VTUyxcbiAgTk9SRVNVTFRTLFxuICBFUlJPUlxufVxuIl19

package/esm2022/app/shared/interceptors/json.interceptor.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This interceptor will force the Content-Type header to application/json so that each http call doesn't have to.
+ */
+export class JsonInterceptor {
+    /**
+     * Intercept method to set the content type header.
+     *
+     * @param req
+     * @param next
+     */
+    intercept(req, next) {
+        const clone = req.clone({ setHeaders: { 'Content-Type': 'application/json' } });
+        return next.handle(clone);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: JsonInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: JsonInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: JsonInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi5pbnRlcmNlcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2ludGVyY2VwdG9ycy9qc29uLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxlQUFlLENBQUM7O0FBSXpDOztHQUVHO0FBRUgsTUFBTSxPQUFPLGVBQWU7SUFFMUI7Ozs7O09BS0c7SUFDSCxTQUFTLENBQUMsR0FBcUIsRUFBRSxJQUFpQjtRQUNoRCxNQUFNLEtBQUssR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUMsVUFBVSxFQUFFLEVBQUMsY0FBYyxFQUFFLGtCQUFrQixFQUFDLEVBQUMsQ0FBQyxDQUFDO1FBQzVFLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1QixDQUFDO3VHQVhVLGVBQWU7MkdBQWYsZUFBZTs7MkZBQWYsZUFBZTtrQkFEM0IsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0h0dHBFdmVudCwgSHR0cEhhbmRsZXIsIEh0dHBJbnRlcmNlcHRvciwgSHR0cFJlcXVlc3R9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7T2JzZXJ2YWJsZX0gZnJvbSAncnhqcyc7XG5cbi8qKlxuICogVGhpcyBpbnRlcmNlcHRvciB3aWxsIGZvcmNlIHRoZSBDb250ZW50LVR5cGUgaGVhZGVyIHRvIGFwcGxpY2F0aW9uL2pzb24gc28gdGhhdCBlYWNoIGh0dHAgY2FsbCBkb2Vzbid0IGhhdmUgdG8uXG4gKi9cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBKc29uSW50ZXJjZXB0b3IgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3Ige1xuXG4gIC8qKlxuICAgKiBJbnRlcmNlcHQgbWV0aG9kIHRvIHNldCB0aGUgY29udGVudCB0eXBlIGhlYWRlci5cbiAgICpcbiAgICogQHBhcmFtIHJlcVxuICAgKiBAcGFyYW0gbmV4dFxuICAgKi9cbiAgaW50ZXJjZXB0KHJlcTogSHR0cFJlcXVlc3Q8YW55PiwgbmV4dDogSHR0cEhhbmRsZXIpOiBPYnNlcnZhYmxlPEh0dHBFdmVudDxhbnk+PiB7XG4gICAgY29uc3QgY2xvbmUgPSByZXEuY2xvbmUoe3NldEhlYWRlcnM6IHsnQ29udGVudC1UeXBlJzogJ2FwcGxpY2F0aW9uL2pzb24nfX0pO1xuICAgIHJldHVybiBuZXh0LmhhbmRsZShjbG9uZSk7XG4gIH1cblxufVxuIl19

package/esm2022/app/shared/models/auditable.model.mjs

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

package/esm2022/app/shared/models/data-list.model.mjs

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

package/esm2022/app/shared/models/id.model.mjs

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

package/esm2022/app/shared/models/observable-container.mjs

@@ -0,0 +1,15 @@
+import { BehaviorSubject, mergeMap } from 'rxjs';
+export class ObservableContainer {
+    _subject = new BehaviorSubject(true);
+    _obs;
+    constructor(obs) {
+        this._obs = this._subject.pipe(mergeMap(() => obs));
+    }
+    refresh() {
+        this._subject.next(true);
+    }
+    get observable() {
+        return this._obs;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JzZXJ2YWJsZS1jb250YWluZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9tb2RlbHMvb2JzZXJ2YWJsZS1jb250YWluZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLGVBQWUsRUFBYyxRQUFRLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFFM0QsTUFBTSxPQUFPLG1CQUFtQjtJQUV0QixRQUFRLEdBQUcsSUFBSSxlQUFlLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDNUIsSUFBSSxDQUFnQjtJQUVyQyxZQUFZLEdBQWtCO1FBQzVCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQzVCLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FDcEIsQ0FBQztJQUNKLENBQUM7SUFFRCxPQUFPO1FBQ0wsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELElBQUksVUFBVTtRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0NBRUYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0JlaGF2aW9yU3ViamVjdCwgT2JzZXJ2YWJsZSwgbWVyZ2VNYXB9IGZyb20gJ3J4anMnO1xyXG5cclxuZXhwb3J0IGNsYXNzIE9ic2VydmFibGVDb250YWluZXI8VD4ge1xyXG5cclxuICBwcml2YXRlIF9zdWJqZWN0ID0gbmV3IEJlaGF2aW9yU3ViamVjdCh0cnVlKTtcclxuICBwcml2YXRlIHJlYWRvbmx5IF9vYnM6IE9ic2VydmFibGU8VD47XHJcblxyXG4gIGNvbnN0cnVjdG9yKG9iczogT2JzZXJ2YWJsZTxUPikge1xyXG4gICAgdGhpcy5fb2JzID0gdGhpcy5fc3ViamVjdC5waXBlKFxyXG4gICAgICBtZXJnZU1hcCgoKSA9PiBvYnMpXHJcbiAgICApO1xyXG4gIH1cclxuXHJcbiAgcmVmcmVzaCgpOiB2b2lkIHtcclxuICAgIHRoaXMuX3N1YmplY3QubmV4dCh0cnVlKTtcclxuICB9XHJcblxyXG4gIGdldCBvYnNlcnZhYmxlKCk6IE9ic2VydmFibGU8VD4ge1xyXG4gICAgcmV0dXJuIHRoaXMuX29icztcclxuICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2022/app/shared/models/particle-component-text.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/shared/services/base-data.service.mjs

@@ -0,0 +1,190 @@
+import { catchError, map } from 'rxjs';
+import { of, throwError } from 'rxjs';
+/**
+ * This class provides some foundational REST endpoint call capabilities. It will do things like unpack lists into native objects and
+ * return Observables so that you don't have to deal with mapping each and every response. It'll also log errors to the console and pass
+ * along the error text for you.
+ */
+export class BaseDataService {
+    http;
+    /**
+     * Extensions of this class can provide the Base URL so that they don't need to write out the full URL for every call made.
+     */
+    getBaseUrl() {
+        return '';
+    }
+    /**
+     * If you receive a 404 from an endpoint, you can choose to treat it like a successful empty response
+     * by overriding this and returning true.
+     *
+     * @protected
+     */
+    ignoreNoResultsError() {
+        return false;
+    }
+    /**
+     * Takes an HTTPClient object so that it can make REST calls.
+     *
+     * @param http
+     */
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Gets a result from an endpoint. Executes an HTTP GET.
+     *
+     * @param url
+     * @param params
+     */
+    handleGet(url, params) {
+        return this.handleGetDetailed(url, false, params);
+    }
+    /**
+     * Will get a single result from an endpoint. Executes an HTTP GET.
+     *
+     * @param url
+     */
+    handleGetOne(url) {
+        return this.handleGet(url).pipe(map(d => d), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Gets a List of Values. Will unpack the data object automatically. Executes an HTTP GET.
+     *
+     * @param url
+     */
+    handleGetList(url) {
+        return this.handleGet(url).pipe(map(d => d.data), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Gets a file from an ednpoint. Executes an HTTP GET.
+     *
+     * @param url
+     * @param params
+     */
+    handleFileGet(url, params) {
+        return this.handleGetDetailed(url, true, params);
+    }
+    /**
+     * The handleFileGet will use this to get a file.
+     *
+     * @param url
+     * @param isFileResponse
+     * @param params
+     */
+    handleGetDetailed(url, isFileResponse, params) {
+        const options = this.getOptions(isFileResponse);
+        options.params = params;
+        return this.http.get(this.getBaseUrl() + url, options)
+            .pipe(map(res => res), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Posts data to an endpoint. HTTP POST.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePost(url, payload) {
+        return this.handlePostDetailed(url, payload, true, false);
+    }
+    /**
+     * Posts data to an endpoint with an expected return of a File.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePostWithFileResponse(url, payload) {
+        return this.handlePostDetailed(url, payload, true, true);
+    }
+    /**
+     * The handlePost methods will use this to make Post calls easier.
+     *
+     * @param url
+     * @param payload
+     * @param isJson
+     * @param isFileResponse
+     */
+    handlePostDetailed(url, payload, isJson, isFileResponse) {
+        let payloadFinal = payload;
+        if (isJson) {
+            payloadFinal = JSON.stringify(payload);
+        }
+        return this.http.post(this.getBaseUrl() + url, payloadFinal, this.getOptions(isFileResponse)).pipe(map(res => res), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Update data with a REST call. HTTP PUT.
+     *
+     * @param url
+     * @param payload
+     */
+    handlePut(url, payload) {
+        return this.handlePutDetailed(url, payload, true);
+    }
+    /**
+     * Used by the handlePut method to make it simpler and the guts more reusable.
+     *
+     * @param url
+     * @param payload
+     * @param isJson
+     */
+    handlePutDetailed(url, payload, isJson) {
+        let payloadFinal = payload;
+        if (isJson) {
+            payloadFinal = JSON.stringify(payload);
+        }
+        return this.http.put(this.getBaseUrl() + url, payloadFinal, this.getOptions())
+            .pipe(map(res => res), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Executes an HTTP DELETE to remove data.
+     *
+     * @param url
+     */
+    handleDelete(url) {
+        return this.http.delete(this.getBaseUrl() + url)
+            .pipe(map(res => res), catchError(error => this.handleError(error, this.ignoreNoResultsError())));
+    }
+    /**
+     * Handles an Observable error
+     *
+     * @param error
+     */
+    handleObservableError(error) {
+        this.handleError(error, this.ignoreNoResultsError());
+        return of(null);
+    }
+    /**
+     * Logs an error and rethrows it
+     *
+     * @param error
+     * @param ignoreNoResultsError
+     */
+    handleError(error, ignoreNoResultsError) {
+        if (ignoreNoResultsError && error.status === 404) {
+            return of({});
+        }
+        console.error(error);
+        return throwError(() => error);
+    }
+    /**
+     * Performs a deep copy of a JS object.
+     *
+     * @param o
+     */
+    deepCopy(o) {
+        return JSON.parse(JSON.stringify(o));
+    }
+    /**
+     * Gets the expected response type from an endpoint
+     *
+     * @param isFileResponse
+     */
+    getOptions(isFileResponse) {
+        const options = {};
+        options.responseType = 'json';
+        if (isFileResponse) {
+            options.responseType = 'arraybuffer';
+        }
+        return options;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-data.service.js","sourceRoot":"","sources":["../../../../../src/app/shared/services/base-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {catchError, map} from 'rxjs';\nimport {HttpClient, HttpErrorResponse, HttpParams} from '@angular/common/http';\nimport {Observable, of, throwError} from 'rxjs';\n\n/**\n * This class provides some foundational REST endpoint call capabilities. It will do things like unpack lists into native objects and\n * return Observables so that you don't have to deal with mapping each and every response. It'll also log errors to the console and pass\n * along the error text for you.\n */\nexport class BaseDataService {\n\n  /**\n   * Extensions of this class can provide the Base URL so that they don't need to write out the full URL for every call made.\n   */\n  protected getBaseUrl(): string {\n    return '';\n  }\n\n  /**\n   * If you receive a 404 from an endpoint, you can choose to treat it like a successful empty response\n   * by overriding this and returning true.\n   *\n   * @protected\n   */\n  protected ignoreNoResultsError(): boolean {\n    return false;\n  }\n\n  /**\n   * Takes an HTTPClient object so that it can make REST calls.\n   *\n   * @param http\n   */\n  constructor(protected http: HttpClient) {\n  }\n\n  /**\n   * Gets a result from an endpoint. Executes an HTTP GET.\n   *\n   * @param url\n   * @param params\n   */\n  handleGet(url: string, params?: HttpParams): Observable<any> {\n    return this.handleGetDetailed(url, false, params);\n  }\n\n  /**\n   * Will get a single result from an endpoint. Executes an HTTP GET.\n   *\n   * @param url\n   */\n  handleGetOne(url: string): Observable<any> {\n    return this.handleGet(url).pipe(\n      map(d => d),\n      catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n    );\n  }\n\n  /**\n   * Gets a List of Values. Will unpack the data object automatically. Executes an HTTP GET.\n   *\n   * @param url\n   */\n  handleGetList(url: string): Observable<any> {\n    return this.handleGet(url).pipe(\n      map(d => d.data),\n      catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n    );\n  }\n\n  /**\n   * Gets a file from an ednpoint. Executes an HTTP GET.\n   *\n   * @param url\n   * @param params\n   */\n  handleFileGet(url: string, params?: HttpParams): Observable<any> {\n    return this.handleGetDetailed(url, true, params);\n  }\n\n  /**\n   * The handleFileGet will use this to get a file.\n   *\n   * @param url\n   * @param isFileResponse\n   * @param params\n   */\n  private handleGetDetailed(url: string, isFileResponse: boolean, params?: HttpParams): Observable<any> {\n    const options = this.getOptions(isFileResponse);\n    options.params = params;\n\n    return this.http.get(this.getBaseUrl() + url, options)\n      .pipe(\n        map(res => res),\n        catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n      );\n  }\n\n  /**\n   * Posts data to an endpoint. HTTP POST.\n   *\n   * @param url\n   * @param payload\n   */\n  handlePost(url: string, payload: any): Observable<any> {\n    return this.handlePostDetailed(url, payload, true, false);\n  }\n\n  /**\n   * Posts data to an endpoint with an expected return of a File.\n   *\n   * @param url\n   * @param payload\n   */\n  handlePostWithFileResponse(url: string, payload: any): Observable<any> {\n    return this.handlePostDetailed(url, payload, true, true);\n  }\n\n  /**\n   * The handlePost methods will use this to make Post calls easier.\n   *\n   * @param url\n   * @param payload\n   * @param isJson\n   * @param isFileResponse\n   */\n  private handlePostDetailed(url: string, payload: any, isJson: boolean, isFileResponse: boolean): Observable<any> {\n    let payloadFinal = payload;\n    if (isJson) {\n      payloadFinal = JSON.stringify(payload);\n    }\n\n    return this.http.post(\n      this.getBaseUrl() + url,\n      payloadFinal,\n      this.getOptions(isFileResponse)).pipe(\n        map(res => res),\n        catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n      );\n  }\n\n  /**\n   * Update data with a REST call. HTTP PUT.\n   *\n   * @param url\n   * @param payload\n   */\n  handlePut(url: string, payload: any): Observable<any> {\n    return this.handlePutDetailed(url, payload, true);\n  }\n\n  /**\n   * Used by the handlePut method to make it simpler and the guts more reusable.\n   *\n   * @param url\n   * @param payload\n   * @param isJson\n   */\n  private handlePutDetailed(url: string, payload: any, isJson: boolean): Observable<any> {\n    let payloadFinal = payload;\n    if (isJson) {\n      payloadFinal = JSON.stringify(payload);\n    }\n\n    return this.http.put(this.getBaseUrl() + url, payloadFinal, this.getOptions())\n      .pipe(\n        map(res => res),\n        catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n      );\n  }\n\n  /**\n   * Executes an HTTP DELETE to remove data.\n   *\n   * @param url\n   */\n  handleDelete(url: string): Observable<any> {\n    return this.http.delete(this.getBaseUrl() + url)\n      .pipe(\n        map(res => res),\n        catchError(error => this.handleError(error, this.ignoreNoResultsError()))\n      );\n  }\n\n  /**\n   * Handles an Observable error\n   *\n   * @param error\n   */\n  handleObservableError(error: HttpErrorResponse): Observable<any> {\n    this.handleError(error, this.ignoreNoResultsError());\n    return of(null);\n  }\n\n  /**\n   * Logs an error and rethrows it\n   *\n   * @param error\n   * @param ignoreNoResultsError\n   */\n  handleError(error: HttpErrorResponse, ignoreNoResultsError: boolean): Observable<any> {\n    if (ignoreNoResultsError && error.status === 404) {\n      return of({});\n    }\n\n    console.error(error);\n    return throwError(() => error);\n  }\n\n  /**\n   * Performs a deep copy of a JS object.\n   *\n   * @param o\n   */\n  deepCopy<T>(o: T): T {\n    return <T> JSON.parse(JSON.stringify(o));\n  }\n\n  /**\n   * Gets the expected response type from an endpoint\n   *\n   * @param isFileResponse\n   */\n  private getOptions(isFileResponse?: boolean): any {\n    const options: any = {};\n    options.responseType = 'json';\n\n    if (isFileResponse) {\n      options.responseType = 'arraybuffer';\n    }\n\n    return options;\n  }\n\n}\n"]}

package/esm2022/app/shared/services/dialog.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DialogService {
+    dialogs = [];
+    escapeListener = event => {
+        if (event.key === 'Esc' || event.key === 'Escape') {
+            if (this.dialogs && this.dialogs.length) {
+                let closeOverride = null;
+                if ('getAttribute' in event.target) {
+                    closeOverride = event.target.getAttribute('data-dialog-close-override');
+                }
+                if (closeOverride === null || closeOverride === '') {
+                    const topDialog = this.dialogs[this.dialogs.length - 1];
+                    if (topDialog.allowClose) {
+                        this.dialogs.pop();
+                        topDialog.close();
+                        event.stopPropagation();
+                    }
+                }
+            }
+        }
+    };
+    registerDialog(dialog) {
+        if (dialog) {
+            if (this.dialogs.length === 0) {
+                window.addEventListener('keyup', this.escapeListener);
+                document.body.classList.add('scroll_none');
+            }
+            this.dialogs.push(dialog);
+        }
+    }
+    unregisterDialog(dialog) {
+        if (this.dialogs.includes(dialog)) {
+            this.dialogs = this.dialogs.filter(d => d !== dialog);
+        }
+        if (this.dialogs.length === 0) {
+            window.removeEventListener('keyup', this.escapeListener);
+            document.body.classList.remove('scroll_none');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: DialogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: DialogService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/shared/services/local-storage.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Wrapper around interactions with Local Storage. Handles serializing things to JSON to make it easier to push more complex data into
+ * local storage.
+ */
+export class LocalStorageService {
+    /**
+     * Retrieve an object from LocalStorage
+     *
+     * @param key
+     */
+    getObject(key) {
+        const obj = localStorage.getItem(key);
+        if (obj) {
+            return JSON.parse(obj);
+        }
+        return null;
+    }
+    /**
+     * Get straight text out of local storage. Don't use this if the data is a JSON Object.
+     *
+     * @param key
+     */
+    getText(key) {
+        return localStorage.getItem(key) + '';
+    }
+    /**
+     * Puts an object into Local Storage. Handles stringifying the JS Object.
+     *
+     * @param key
+     * @param object
+     */
+    putObject(key, object) {
+        localStorage.setItem(key, JSON.stringify(object));
+    }
+    /**
+     * Puts text into Local Storage.
+     *
+     * @param key
+     * @param value
+     */
+    putText(key, value) {
+        localStorage.setItem(key, value);
+    }
+    /**
+     * Removes an item from local storage based on the key.
+     *
+     * @param key
+     */
+    remove(key) {
+        localStorage.removeItem(key);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: LocalStorageService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/entake-particle.mjs

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

package/esm2022/public_api.mjs

@@ -0,0 +1,98 @@
+/** MODULES */
+export * from './app/modules/background-carousel/particle-background-carousel.module';
+export * from './app/modules/paginator/particle-paginator.module';
+export * from './app/modules/profile-pic/particle-profile-pic.module';
+export * from './app/modules/push-container/particle-push-container.module';
+export * from './app/modules/rich-text/particle-rich-text.module';
+export * from './app/modules/icons/particle-icons.module';
+export * from './app/modules/endpoint-state/endpoint-state.module';
+export * from './app/modules/dialog/dialog.module';
+export * from './app/modules/idle-timeout/particle-idle-timeout.module';
+export * from './app/modules/date-picker/date-picker.module';
+export * from './app/modules/dropdown/dropdown.module';
+export * from './app/modules/multi-select/multi-select.module';
+export * from './app/modules/ordinal-number-pipe/ordinal-number-pipe.module';
+export * from './app/modules/popover/popover.module';
+export * from './app/modules/tooltip/tooltip.module';
+export * from './app/modules/keyfilter/keyfilter.module';
+export * from './app/modules/notification/notification.module';
+export * from './app/modules/week-picker/week-picker.module';
+export * from './app/modules/color-picker/color-picker.module';
+export * from './app/modules/slider/slider.module';
+export * from './app/modules/accordion/accordion.module';
+export * from './app/modules/theming/theming.module';
+export * from './app/modules/slideover/particle-slideover.module';
+export * from './app/modules/scroll-to-top/particle-scroll-to-top.module';
+export * from './app/modules/layout/layout.module';
+export * from './app/modules/toggle-switch/toggle-switch.module';
+export * from './app/modules/checkbox/checkbox.module';
+export * from './app/modules/input-mask/input-mask.module';
+export * from './app/modules/progress-bar/progress-bar.module';
+export * from './app/modules/loader/loader.module';
+/** DIRECTIVES */
+export * from './app/modules/tooltip/tooltip.directive';
+export * from './app/modules/keyfilter/keyfilter.directive';
+export * from './app/modules/accordion/directives/accordion-content.directive';
+export * from './app/modules/accordion/directives/accordion-item.directive';
+export * from './app/modules/accordion/directives/accordion-header.directive';
+export * from './app/modules/background-carousel/background-carousel.directive';
+/** COMPONENTS */
+export * from './app/modules/icons/components/icon-select.component';
+export * from './app/modules/paginator/paginator.component';
+export * from './app/modules/profile-pic/profile-pic.component';
+export * from './app/modules/push-container/push-container.component';
+export * from './app/modules/rich-text/rich-text.component';
+export * from './app/modules/rich-text/render-rich-text.component';
+export * from './app/modules/endpoint-state/components/endpoint-state.component';
+export * from './app/modules/dialog/dialog.component';
+export * from './app/modules/date-picker/date-picker.component';
+export * from './app/modules/date-picker/components/calendar/calendar.component';
+export * from './app/modules/date-picker/components/date-range-picker/date-range-picker.component';
+export * from './app/modules/dropdown/dropdown.component';
+export * from './app/modules/multi-select/multi-select.component';
+export * from './app/modules/popover/popover.component';
+export * from './app/modules/notification/notification.component';
+export * from './app/modules/week-picker/week-picker.component';
+export * from './app/modules/color-picker/color-picker.component';
+export * from './app/modules/slider/slider.component';
+export * from './app/modules/theming/components/theming.component';
+export * from './app/modules/accordion/accordion.component';
+export * from './app/modules/slideover/slideover.component';
+export * from './app/modules/idle-timeout/idle-timeout.component';
+export * from './app/modules/scroll-to-top/scroll-to-top.component';
+export * from './app/modules/layout/components/layout-fullwidth-sidebar/layout-fullwidth-sidebar.component';
+export * from './app/modules/layout/components/layout-full-framing/layout-full-framing.component';
+export * from './app/modules/toggle-switch/toggle-switch.component';
+export * from './app/modules/checkbox/checkbox.component';
+export * from './app/modules/input-mask/input-mask.component';
+export * from './app/modules/progress-bar/progress-bar.component';
+export * from './app/modules/loader/components/loader.component';
+/** INTERCEPTORS */
+export * from './app/shared/interceptors/json.interceptor';
+/** SERVICES */
+export * from './app/shared/services/base-data.service';
+export * from './app/shared/services/local-storage.service';
+export * from './app/shared/services/dialog.service';
+export * from './app/modules/notification/services/notification.service';
+export * from './app/modules/theming/services/theming.service';
+export * from './app/modules/theming/services/theme-change-detection.service';
+/** PIPES */
+export * from './app/modules/ordinal-number-pipe/ordinal-number.pipe';
+/** MODELS */
+export * from './app/shared/models/auditable.model';
+export * from './app/shared/models/data-list.model';
+export * from './app/shared/models/id.model';
+export * from './app/shared/models/observable-container';
+export * from './app/modules/paginator/pagination-event.model';
+export * from './app/modules/background-carousel/carousel-options.model';
+export * from './app/modules/dropdown/models/dropdown-option.model';
+export * from './app/modules/dropdown/models/dropdown-option-group.model';
+export * from './app/modules/multi-select/models/multi-select-option.model';
+export * from './app/modules/multi-select/models/multi-select-option-group.model';
+export * from './app/modules/notification/models/notification.model';
+export * from './app/modules/theming/models/theme.model';
+export * from './app/modules/toggle-switch/models/toggle-options.model';
+export * from './app/modules/rich-text/rich-text-capabilities.model';
+/** ENUMS */
+export * from './app/shared/enums/endpoint-status.enum';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../src/public_api.ts"],"names":[],"mappings":"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","sourcesContent":["/** MODULES */\r\nexport * from './app/modules/background-carousel/particle-background-carousel.module';\r\nexport * from './app/modules/paginator/particle-paginator.module';\r\nexport * from './app/modules/profile-pic/particle-profile-pic.module';\r\nexport * from './app/modules/push-container/particle-push-container.module';\r\nexport * from './app/modules/rich-text/particle-rich-text.module';\r\nexport * from './app/modules/icons/particle-icons.module';\r\nexport * from './app/modules/endpoint-state/endpoint-state.module';\r\nexport * from './app/modules/dialog/dialog.module';\r\nexport * from './app/modules/idle-timeout/particle-idle-timeout.module';\r\nexport * from './app/modules/date-picker/date-picker.module';\r\nexport * from './app/modules/dropdown/dropdown.module';\r\nexport * from './app/modules/multi-select/multi-select.module';\r\nexport * from './app/modules/ordinal-number-pipe/ordinal-number-pipe.module';\r\nexport * from './app/modules/popover/popover.module';\r\nexport * from './app/modules/tooltip/tooltip.module';\r\nexport * from './app/modules/keyfilter/keyfilter.module';\r\nexport * from './app/modules/notification/notification.module';\r\nexport * from './app/modules/week-picker/week-picker.module';\r\nexport * from './app/modules/color-picker/color-picker.module';\r\nexport * from './app/modules/slider/slider.module';\r\nexport * from './app/modules/accordion/accordion.module';\r\nexport * from './app/modules/theming/theming.module';\r\nexport * from './app/modules/slideover/particle-slideover.module';\r\nexport * from './app/modules/scroll-to-top/particle-scroll-to-top.module';\r\nexport * from './app/modules/layout/layout.module';\r\nexport * from './app/modules/toggle-switch/toggle-switch.module';\r\nexport * from './app/modules/checkbox/checkbox.module';\r\nexport * from './app/modules/input-mask/input-mask.module';\r\nexport * from './app/modules/progress-bar/progress-bar.module';\r\nexport * from './app/modules/loader/loader.module';\r\n\r\n/** DIRECTIVES */\r\nexport * from './app/modules/tooltip/tooltip.directive';\r\nexport * from './app/modules/keyfilter/keyfilter.directive';\r\nexport * from './app/modules/accordion/directives/accordion-content.directive';\r\nexport * from './app/modules/accordion/directives/accordion-item.directive';\r\nexport * from './app/modules/accordion/directives/accordion-header.directive';\r\nexport * from './app/modules/background-carousel/background-carousel.directive';\r\n\r\n/** COMPONENTS */\r\nexport * from './app/modules/icons/components/icon-select.component';\r\nexport * from './app/modules/paginator/paginator.component';\r\nexport * from './app/modules/profile-pic/profile-pic.component';\r\nexport * from './app/modules/push-container/push-container.component';\r\nexport * from './app/modules/rich-text/rich-text.component';\r\nexport * from './app/modules/rich-text/render-rich-text.component';\r\nexport * from './app/modules/endpoint-state/components/endpoint-state.component';\r\nexport * from './app/modules/dialog/dialog.component';\r\nexport * from './app/modules/date-picker/date-picker.component';\r\nexport * from './app/modules/date-picker/components/calendar/calendar.component';\r\nexport * from './app/modules/date-picker/components/date-range-picker/date-range-picker.component';\r\nexport * from './app/modules/dropdown/dropdown.component';\r\nexport * from './app/modules/multi-select/multi-select.component';\r\nexport * from './app/modules/popover/popover.component';\r\nexport * from './app/modules/notification/notification.component';\r\nexport * from './app/modules/week-picker/week-picker.component';\r\nexport * from './app/modules/color-picker/color-picker.component';\r\nexport * from './app/modules/slider/slider.component';\r\nexport * from './app/modules/theming/components/theming.component';\r\nexport * from './app/modules/accordion/accordion.component';\r\nexport * from './app/modules/slideover/slideover.component';\r\nexport * from './app/modules/idle-timeout/idle-timeout.component';\r\nexport * from './app/modules/scroll-to-top/scroll-to-top.component';\r\nexport * from './app/modules/layout/components/layout-fullwidth-sidebar/layout-fullwidth-sidebar.component';\r\nexport * from './app/modules/layout/components/layout-full-framing/layout-full-framing.component';\r\nexport * from './app/modules/toggle-switch/toggle-switch.component';\r\nexport * from './app/modules/checkbox/checkbox.component';\r\nexport * from './app/modules/input-mask/input-mask.component';\r\nexport * from './app/modules/progress-bar/progress-bar.component';\r\nexport * from './app/modules/loader/components/loader.component';\r\n\r\n/** INTERCEPTORS */\r\nexport * from './app/shared/interceptors/json.interceptor';\r\n\r\n/** SERVICES */\r\nexport * from './app/shared/services/base-data.service';\r\nexport * from './app/shared/services/local-storage.service';\r\nexport * from './app/shared/services/dialog.service';\r\nexport * from './app/modules/notification/services/notification.service';\r\nexport * from './app/modules/theming/services/theming.service';\r\nexport * from './app/modules/theming/services/theme-change-detection.service';\r\n\r\n/** PIPES */\r\nexport * from './app/modules/ordinal-number-pipe/ordinal-number.pipe';\r\n\r\n/** MODELS */\r\nexport * from './app/shared/models/auditable.model';\r\nexport * from './app/shared/models/data-list.model';\r\nexport * from './app/shared/models/id.model';\r\nexport * from './app/shared/models/observable-container';\r\n\r\nexport * from './app/modules/paginator/pagination-event.model';\r\nexport * from './app/modules/background-carousel/carousel-options.model';\r\nexport * from './app/modules/dropdown/models/dropdown-option.model';\r\nexport * from './app/modules/dropdown/models/dropdown-option-group.model';\r\nexport * from './app/modules/multi-select/models/multi-select-option.model';\r\nexport * from './app/modules/multi-select/models/multi-select-option-group.model';\r\nexport * from './app/modules/notification/models/notification.model';\r\nexport * from './app/modules/theming/models/theme.model';\r\nexport * from './app/modules/toggle-switch/models/toggle-options.model';\r\nexport * from './app/modules/rich-text/rich-text-capabilities.model';\r\n\r\n/** ENUMS */\r\nexport * from './app/shared/enums/endpoint-status.enum';\r\n"]}