@pecb-ui/components 1.1.2

package/esm2022/lib/components/toggle/toggle.component.mjs

@@ -0,0 +1,126 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, forwardRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { generateUniqueId } from '../../shared/utils/dom.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * A professional toggle/switch component with label and description support.
+ * Fully accessible with WCAG 2.1 AA compliance and reactive forms support.
+ *
+ * @example
+ * ```html
+ * <pecb-toggle
+ *   label="Enable notifications"
+ *   description="Receive email notifications"
+ *   [(ngModel)]="notificationsEnabled"
+ * ></pecb-toggle>
+ * ```
+ *
+ * @publicApi
+ */
+export class ToggleComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        /**
+         * Unique ID for the toggle element
+         */
+        this.id = generateUniqueId('toggle');
+        /**
+         * Position of the label relative to the toggle control.
+         * 'right' (default): [toggle] Title Description
+         * 'left': Title Description [toggle]
+         */
+        this.labelPosition = 'right';
+        /**
+         * Whether the toggle is disabled
+         */
+        this.disabled = false;
+        /**
+         * Event emitted when toggle state changes
+         */
+        this.toggleChange = new EventEmitter();
+        // Internal state
+        this.checked = false;
+        // ControlValueAccessor
+        this.onChange = () => { };
+        this.onTouched = () => { };
+    }
+    /**
+     * Get CSS classes for the toggle wrapper
+     */
+    get wrapperClasses() {
+        return [
+            'pecb-toggle',
+            this.disabled ? 'pecb-toggle--disabled' : '',
+            this.checked ? 'pecb-toggle--checked' : '',
+            this.labelPosition === 'left' ? 'pecb-toggle--label-left' : ''
+        ].filter(Boolean);
+    }
+    /**
+     * Handle toggle change
+     */
+    onToggleChange(event) {
+        if (this.disabled)
+            return;
+        const checked = event.target.checked;
+        this.checked = checked;
+        this.onChange(this.checked);
+        this.toggleChange.emit(this.checked);
+        this.cdr.markForCheck();
+    }
+    /**
+     * Handle blur event
+     */
+    onBlur() {
+        this.onTouched();
+    }
+    // ControlValueAccessor implementation
+    writeValue(value) {
+        this.checked = !!value;
+        this.cdr.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToggleComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ToggleComponent, isStandalone: true, selector: "pecb-toggle", inputs: { id: "id", name: "name", label: "label", description: "description", labelPosition: "labelPosition", disabled: "disabled" }, outputs: { toggleChange: "toggleChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ToggleComponent),
+                multi: true
+            }
+        ], ngImport: i0, template: "<div [class]=\"wrapperClasses.join(' ')\">\r\n  <label [attr.for]=\"id\" class=\"pecb-toggle__label\">\r\n    <input\r\n      [id]=\"id\"\r\n      type=\"checkbox\"\r\n      role=\"switch\"\r\n      class=\"pecb-toggle__input\"\r\n      [name]=\"name\"\r\n      [checked]=\"checked\"\r\n      [disabled]=\"disabled\"\r\n      [attr.aria-label]=\"label\"\r\n      [attr.aria-describedby]=\"description ? id + '-description' : null\"\r\n      [attr.aria-checked]=\"checked\"\r\n      (change)=\"onToggleChange($event)\"\r\n      (blur)=\"onBlur()\"\r\n    />\r\n    <span *ngIf=\"labelPosition === 'left' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n    <span class=\"pecb-toggle__control\">\r\n      <span class=\"pecb-toggle__thumb\"></span>\r\n    </span>\r\n    <span *ngIf=\"labelPosition === 'right' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n  </label>\r\n</div>\r\n", styles: [".pecb-toggle{position:relative;display:inline-block}.pecb-toggle__label{display:flex;align-items:flex-start;cursor:pointer;-webkit-user-select:none;user-select:none;gap:12px}.pecb-toggle__input{position:absolute;opacity:0;width:0;height:0;margin:0;padding:0;pointer-events:none}.pecb-toggle__control{position:relative;display:inline-flex;align-items:center;flex-shrink:0;width:44px;height:24px;margin-top:0;border-radius:12px;background-color:#c2c2c2;transition-property:background-color;transition-duration:.25s ease-in-out;transition-timing-function:ease-in-out}.pecb-toggle__thumb{position:absolute;left:2px;width:20px;height:20px;border-radius:50%;background-color:#fff;box-shadow:0 2px 4px #0003;transition-property:transform;transition-duration:.25s ease-in-out;transition-timing-function:ease-in-out}.pecb-toggle__content{display:flex;flex-direction:column;gap:6px;flex:1}.pecb-toggle__text{font-family:Plus Jakarta Sans,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-size:14px;font-weight:500;color:#313131;line-height:1.5}.pecb-toggle__description{font-family:Plus Jakarta Sans,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-size:12px;font-weight:400;color:#919191;line-height:1.5}.pecb-toggle:not(.pecb-toggle--disabled) .pecb-toggle__label:hover .pecb-toggle__control{background-color:#919191}.pecb-toggle__input:focus-visible+.pecb-toggle__control{outline:2px solid #212427;outline-offset:2px}.pecb-toggle--checked .pecb-toggle__control{background-color:#212427}.pecb-toggle--checked .pecb-toggle__thumb{transform:translate(20px)}.pecb-toggle--checked:not(.pecb-toggle--disabled) .pecb-toggle__label:hover .pecb-toggle__control{background-color:#34383d}.pecb-toggle--disabled .pecb-toggle__label{cursor:not-allowed}.pecb-toggle--disabled .pecb-toggle__control{background-color:#f7f5f5}.pecb-toggle--disabled .pecb-toggle__thumb{background-color:#ececec;box-shadow:none}.pecb-toggle--disabled.pecb-toggle--checked .pecb-toggle__control{background-color:#c2c2c2}.pecb-toggle--disabled .pecb-toggle__text{color:#c2c2c2}.pecb-toggle--disabled .pecb-toggle__description{color:#ececec}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pecb-toggle', standalone: true, imports: [CommonModule], changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ToggleComponent),
+                            multi: true
+                        }
+                    ], template: "<div [class]=\"wrapperClasses.join(' ')\">\r\n  <label [attr.for]=\"id\" class=\"pecb-toggle__label\">\r\n    <input\r\n      [id]=\"id\"\r\n      type=\"checkbox\"\r\n      role=\"switch\"\r\n      class=\"pecb-toggle__input\"\r\n      [name]=\"name\"\r\n      [checked]=\"checked\"\r\n      [disabled]=\"disabled\"\r\n      [attr.aria-label]=\"label\"\r\n      [attr.aria-describedby]=\"description ? id + '-description' : null\"\r\n      [attr.aria-checked]=\"checked\"\r\n      (change)=\"onToggleChange($event)\"\r\n      (blur)=\"onBlur()\"\r\n    />\r\n    <span *ngIf=\"labelPosition === 'left' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n    <span class=\"pecb-toggle__control\">\r\n      <span class=\"pecb-toggle__thumb\"></span>\r\n    </span>\r\n    <span *ngIf=\"labelPosition === 'right' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n  </label>\r\n</div>\r\n", styles: [".pecb-toggle{position:relative;display:inline-block}.pecb-toggle__label{display:flex;align-items:flex-start;cursor:pointer;-webkit-user-select:none;user-select:none;gap:12px}.pecb-toggle__input{position:absolute;opacity:0;width:0;height:0;margin:0;padding:0;pointer-events:none}.pecb-toggle__control{position:relative;display:inline-flex;align-items:center;flex-shrink:0;width:44px;height:24px;margin-top:0;border-radius:12px;background-color:#c2c2c2;transition-property:background-color;transition-duration:.25s ease-in-out;transition-timing-function:ease-in-out}.pecb-toggle__thumb{position:absolute;left:2px;width:20px;height:20px;border-radius:50%;background-color:#fff;box-shadow:0 2px 4px #0003;transition-property:transform;transition-duration:.25s ease-in-out;transition-timing-function:ease-in-out}.pecb-toggle__content{display:flex;flex-direction:column;gap:6px;flex:1}.pecb-toggle__text{font-family:Plus Jakarta Sans,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-size:14px;font-weight:500;color:#313131;line-height:1.5}.pecb-toggle__description{font-family:Plus Jakarta Sans,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;font-size:12px;font-weight:400;color:#919191;line-height:1.5}.pecb-toggle:not(.pecb-toggle--disabled) .pecb-toggle__label:hover .pecb-toggle__control{background-color:#919191}.pecb-toggle__input:focus-visible+.pecb-toggle__control{outline:2px solid #212427;outline-offset:2px}.pecb-toggle--checked .pecb-toggle__control{background-color:#212427}.pecb-toggle--checked .pecb-toggle__thumb{transform:translate(20px)}.pecb-toggle--checked:not(.pecb-toggle--disabled) .pecb-toggle__label:hover .pecb-toggle__control{background-color:#34383d}.pecb-toggle--disabled .pecb-toggle__label{cursor:not-allowed}.pecb-toggle--disabled .pecb-toggle__control{background-color:#f7f5f5}.pecb-toggle--disabled .pecb-toggle__thumb{background-color:#ececec;box-shadow:none}.pecb-toggle--disabled.pecb-toggle--checked .pecb-toggle__control{background-color:#c2c2c2}.pecb-toggle--disabled .pecb-toggle__text{color:#c2c2c2}.pecb-toggle--disabled .pecb-toggle__description{color:#ececec}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { id: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], toggleChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toggle.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-components/src/lib/components/toggle/toggle.component.ts","../../../../../../projects/ui-components/src/lib/components/toggle/toggle.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  Output,\r\n  EventEmitter,\r\n  ChangeDetectionStrategy,\r\n  forwardRef,\r\n  ChangeDetectorRef\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { generateUniqueId } from '../../shared/utils/dom.utils';\r\n\r\nexport type ToggleLabelPosition = 'right' | 'left';\r\n\r\n/**\r\n * A professional toggle/switch component with label and description support.\r\n * Fully accessible with WCAG 2.1 AA compliance and reactive forms support.\r\n *\r\n * @example\r\n * ```html\r\n * <pecb-toggle\r\n *   label=\"Enable notifications\"\r\n *   description=\"Receive email notifications\"\r\n *   [(ngModel)]=\"notificationsEnabled\"\r\n * ></pecb-toggle>\r\n * ```\r\n *\r\n * @publicApi\r\n */\r\n@Component({\r\n  selector: 'pecb-toggle',\r\n  standalone: true,\r\n  imports: [CommonModule],\r\n  templateUrl: './toggle.component.html',\r\n  styleUrls: ['./toggle.component.scss'],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => ToggleComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class ToggleComponent implements ControlValueAccessor {\r\n  /**\r\n   * Unique ID for the toggle element\r\n   */\r\n  @Input() id: string = generateUniqueId('toggle');\r\n\r\n  /**\r\n   * Name attribute for the toggle\r\n   */\r\n  @Input() name?: string;\r\n\r\n  /**\r\n   * Label text to display\r\n   */\r\n  @Input() label?: string;\r\n\r\n  /**\r\n   * Description text to display below label\r\n   */\r\n  @Input() description?: string;\r\n\r\n  /**\r\n   * Position of the label relative to the toggle control.\r\n   * 'right' (default): [toggle] Title Description\r\n   * 'left': Title Description [toggle]\r\n   */\r\n  @Input() labelPosition: ToggleLabelPosition = 'right';\r\n\r\n  /**\r\n   * Whether the toggle is disabled\r\n   */\r\n  @Input() disabled = false;\r\n\r\n  /**\r\n   * Event emitted when toggle state changes\r\n   */\r\n  @Output() toggleChange = new EventEmitter<boolean>();\r\n\r\n  // Internal state\r\n  checked = false;\r\n\r\n  // ControlValueAccessor\r\n  private onChange: (value: boolean) => void = () => {};\r\n  private onTouched: () => void = () => {};\r\n\r\n  constructor(private cdr: ChangeDetectorRef) {}\r\n\r\n  /**\r\n   * Get CSS classes for the toggle wrapper\r\n   */\r\n  get wrapperClasses(): string[] {\r\n    return [\r\n      'pecb-toggle',\r\n      this.disabled ? 'pecb-toggle--disabled' : '',\r\n      this.checked ? 'pecb-toggle--checked' : '',\r\n      this.labelPosition === 'left' ? 'pecb-toggle--label-left' : ''\r\n    ].filter(Boolean);\r\n  }\r\n\r\n  /**\r\n   * Handle toggle change\r\n   */\r\n  onToggleChange(event: Event): void {\r\n    if (this.disabled) return;\r\n\r\n    const checked = (event.target as HTMLInputElement).checked;\r\n    this.checked = checked;\r\n    this.onChange(this.checked);\r\n    this.toggleChange.emit(this.checked);\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  /**\r\n   * Handle blur event\r\n   */\r\n  onBlur(): void {\r\n    this.onTouched();\r\n  }\r\n\r\n  // ControlValueAccessor implementation\r\n  writeValue(value: boolean): void {\r\n    this.checked = !!value;\r\n    this.cdr.markForCheck();\r\n  }\r\n\r\n  registerOnChange(fn: (value: boolean) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.disabled = isDisabled;\r\n    this.cdr.markForCheck();\r\n  }\r\n}\r\n","<div [class]=\"wrapperClasses.join(' ')\">\r\n  <label [attr.for]=\"id\" class=\"pecb-toggle__label\">\r\n    <input\r\n      [id]=\"id\"\r\n      type=\"checkbox\"\r\n      role=\"switch\"\r\n      class=\"pecb-toggle__input\"\r\n      [name]=\"name\"\r\n      [checked]=\"checked\"\r\n      [disabled]=\"disabled\"\r\n      [attr.aria-label]=\"label\"\r\n      [attr.aria-describedby]=\"description ? id + '-description' : null\"\r\n      [attr.aria-checked]=\"checked\"\r\n      (change)=\"onToggleChange($event)\"\r\n      (blur)=\"onBlur()\"\r\n    />\r\n    <span *ngIf=\"labelPosition === 'left' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n    <span class=\"pecb-toggle__control\">\r\n      <span class=\"pecb-toggle__thumb\"></span>\r\n    </span>\r\n    <span *ngIf=\"labelPosition === 'right' && (label || description)\" class=\"pecb-toggle__content\">\r\n      <span *ngIf=\"label\" class=\"pecb-toggle__text\">{{ label }}</span>\r\n      <span *ngIf=\"description\" [id]=\"id + '-description'\" class=\"pecb-toggle__description\">{{ description }}</span>\r\n    </span>\r\n  </label>\r\n</div>\r\n"]}

package/esm2022/lib/pecb-components.module.mjs

@@ -0,0 +1,118 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ButtonComponent } from './components/button/button.component';
+import { CardComponent, CardHeaderComponent, CardBodyComponent, CardFooterComponent } from './components/card/card.component';
+import { StatusComponent } from './components/status/status.component';
+import { PaginationComponent } from './components/pagination/pagination.component';
+import { TableComponent } from './components/table/table.component';
+import { TabComponent } from './components/tab/tab.component';
+import { DatepickerComponent } from './components/datepicker/datepicker.component';
+import { InputComponent } from './components/input/input.component';
+import { RadioComponent } from './components/radio/radio.component';
+import { CheckboxComponent } from './components/checkbox/checkbox.component';
+import { ToggleComponent } from './components/toggle/toggle.component';
+import { DropdownComponent } from './components/dropdown/dropdown.component';
+import { RightModalComponent, RightModalHeaderDirective, RightModalContentDirective, RightModalFooterDirective } from './components/right-modal/right-modal.component';
+import { SidebarComponent } from './components/sidebar/sidebar.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    ButtonComponent,
+    CardComponent,
+    CardHeaderComponent,
+    CardBodyComponent,
+    CardFooterComponent,
+    StatusComponent,
+    PaginationComponent,
+    TableComponent,
+    TabComponent,
+    DatepickerComponent,
+    InputComponent,
+    RadioComponent,
+    CheckboxComponent,
+    ToggleComponent,
+    DropdownComponent,
+    RightModalComponent,
+    RightModalHeaderDirective,
+    RightModalContentDirective,
+    RightModalFooterDirective,
+    SidebarComponent
+];
+/**
+ * PECB UI Components Module
+ *
+ * A professional Angular components library with TypeScript and SCSS.
+ * Import this module to use all PECB UI components in your application.
+ *
+ * @example
+ * ```typescript
+ * import { PecbComponentsModule } from '@pecb-ui/components';
+ *
+ * @NgModule({
+ *   imports: [PecbComponentsModule]
+ * })
+ * export class AppModule { }
+ * ```
+ */
+export class PecbComponentsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PecbComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: PecbComponentsModule, imports: [CommonModule, ButtonComponent,
+            CardComponent,
+            CardHeaderComponent,
+            CardBodyComponent,
+            CardFooterComponent,
+            StatusComponent,
+            PaginationComponent,
+            TableComponent,
+            TabComponent,
+            DatepickerComponent,
+            InputComponent,
+            RadioComponent,
+            CheckboxComponent,
+            ToggleComponent,
+            DropdownComponent,
+            RightModalComponent,
+            RightModalHeaderDirective,
+            RightModalContentDirective,
+            RightModalFooterDirective,
+            SidebarComponent], exports: [ButtonComponent,
+            CardComponent,
+            CardHeaderComponent,
+            CardBodyComponent,
+            CardFooterComponent,
+            StatusComponent,
+            PaginationComponent,
+            TableComponent,
+            TabComponent,
+            DatepickerComponent,
+            InputComponent,
+            RadioComponent,
+            CheckboxComponent,
+            ToggleComponent,
+            DropdownComponent,
+            RightModalComponent,
+            RightModalHeaderDirective,
+            RightModalContentDirective,
+            RightModalFooterDirective,
+            SidebarComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PecbComponentsModule, imports: [CommonModule, ButtonComponent,
+            StatusComponent,
+            PaginationComponent,
+            TableComponent,
+            TabComponent,
+            DatepickerComponent,
+            InputComponent,
+            RadioComponent,
+            CheckboxComponent,
+            ToggleComponent,
+            DropdownComponent,
+            RightModalComponent,
+            SidebarComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PecbComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ...COMPONENTS],
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,182 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * A stateless, injectable loading service for managing loading states.
+ *
+ * This service provides a centralized way to track loading states across
+ * the application, supporting multiple concurrent loading operations with
+ * individual tracking capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { LoadingService } from '@pecb-ui/components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   isLoading$ = this.loadingService.isLoading$('my-operation');
+ *
+ *   constructor(private loadingService: LoadingService) {}
+ *
+ *   async loadData(): Promise<void> {
+ *     this.loadingService.start('my-operation', 'Loading data...');
+ *     try {
+ *       await this.fetchData();
+ *     } finally {
+ *       this.loadingService.stop('my-operation');
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+export class LoadingService {
+    constructor() {
+        this.loadingStates = new Map();
+        this.statesSubject = new BehaviorSubject(new Map());
+        /** Default loading operation ID */
+        this.defaultId = 'global';
+    }
+    /**
+     * Observable of all loading states
+     */
+    get states$() {
+        return this.statesSubject.asObservable();
+    }
+    /**
+     * Observable that emits true when any loading operation is active
+     */
+    get isAnyLoading$() {
+        return this.statesSubject.pipe(map(states => Array.from(states.values()).some(state => state.isLoading)));
+    }
+    /**
+     * Get observable for a specific loading operation
+     * @param id - The loading operation identifier
+     */
+    isLoading$(id = this.defaultId) {
+        return this.statesSubject.pipe(map(states => states.get(id)?.isLoading ?? false));
+    }
+    /**
+     * Get observable for loading state with message
+     * @param id - The loading operation identifier
+     */
+    getState$(id = this.defaultId) {
+        return this.statesSubject.pipe(map(states => states.get(id)));
+    }
+    /**
+     * Check if a specific operation is currently loading (synchronous)
+     * @param id - The loading operation identifier
+     */
+    isLoading(id = this.defaultId) {
+        return this.loadingStates.get(id)?.isLoading ?? false;
+    }
+    /**
+     * Check if any operation is currently loading (synchronous)
+     */
+    isAnyLoading() {
+        return Array.from(this.loadingStates.values()).some(state => state.isLoading);
+    }
+    /**
+     * Start a loading operation
+     * @param id - The loading operation identifier
+     * @param message - Optional message to display
+     */
+    start(id = this.defaultId, message) {
+        this.updateState(id, { isLoading: true, message, progress: undefined });
+    }
+    /**
+     * Stop a loading operation
+     * @param id - The loading operation identifier
+     */
+    stop(id = this.defaultId) {
+        this.updateState(id, { isLoading: false, message: undefined, progress: undefined });
+    }
+    /**
+     * Update progress for a loading operation
+     * @param id - The loading operation identifier
+     * @param progress - Progress percentage (0-100)
+     * @param message - Optional updated message
+     */
+    setProgress(id, progress, message) {
+        const currentState = this.loadingStates.get(id);
+        if (currentState) {
+            this.updateState(id, {
+                isLoading: true,
+                progress: Math.min(100, Math.max(0, progress)),
+                message: message ?? currentState.message
+            });
+        }
+    }
+    /**
+     * Update the message for a loading operation
+     * @param id - The loading operation identifier
+     * @param message - New message to display
+     */
+    setMessage(id, message) {
+        const currentState = this.loadingStates.get(id);
+        if (currentState) {
+            this.updateState(id, { ...currentState, id, message });
+        }
+    }
+    /**
+     * Stop all loading operations
+     */
+    stopAll() {
+        this.loadingStates.clear();
+        this.statesSubject.next(new Map());
+    }
+    /**
+     * Remove a loading state completely
+     * @param id - The loading operation identifier
+     */
+    remove(id) {
+        this.loadingStates.delete(id);
+        this.emitStates();
+    }
+    /**
+     * Execute an async operation with automatic loading state management
+     * @param id - The loading operation identifier
+     * @param operation - The async operation to execute
+     * @param message - Optional loading message
+     * @returns The result of the operation
+     */
+    async withLoading(id, operation, message) {
+        this.start(id, message);
+        try {
+            return await operation();
+        }
+        finally {
+            this.stop(id);
+        }
+    }
+    /**
+     * Update a loading state
+     */
+    updateState(id, partialState) {
+        const state = {
+            id,
+            isLoading: partialState.isLoading,
+            message: partialState.message,
+            progress: partialState.progress
+        };
+        this.loadingStates.set(id, state);
+        this.emitStates();
+    }
+    /**
+     * Emit current states to subscribers
+     */
+    emitStates() {
+        this.statesSubject.next(new Map(this.loadingStates));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoadingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoadingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LoadingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading.service.js","sourceRoot":"","sources":["../../../../../projects/ui-components/src/lib/services/loading.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\n/**\r\n * Loading state for a specific operation\r\n */\r\nexport interface LoadingState {\r\n  /** Unique identifier for the loading operation */\r\n  id: string;\r\n  /** Whether this operation is currently loading */\r\n  isLoading: boolean;\r\n  /** Optional message to display */\r\n  message?: string;\r\n  /** Optional progress percentage (0-100) */\r\n  progress?: number;\r\n}\r\n\r\n/**\r\n * A stateless, injectable loading service for managing loading states.\r\n *\r\n * This service provides a centralized way to track loading states across\r\n * the application, supporting multiple concurrent loading operations with\r\n * individual tracking capabilities.\r\n *\r\n * @example\r\n * ```typescript\r\n * import { LoadingService } from '@pecb-ui/components';\r\n *\r\n * @Component({...})\r\n * export class MyComponent {\r\n *   isLoading$ = this.loadingService.isLoading$('my-operation');\r\n *\r\n *   constructor(private loadingService: LoadingService) {}\r\n *\r\n *   async loadData(): Promise<void> {\r\n *     this.loadingService.start('my-operation', 'Loading data...');\r\n *     try {\r\n *       await this.fetchData();\r\n *     } finally {\r\n *       this.loadingService.stop('my-operation');\r\n *     }\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * @publicApi\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class LoadingService {\r\n  private readonly loadingStates = new Map<string, LoadingState>();\r\n  private readonly statesSubject = new BehaviorSubject<Map<string, LoadingState>>(new Map());\r\n\r\n  /** Default loading operation ID */\r\n  private readonly defaultId = 'global';\r\n\r\n  /**\r\n   * Observable of all loading states\r\n   */\r\n  get states$(): Observable<Map<string, LoadingState>> {\r\n    return this.statesSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Observable that emits true when any loading operation is active\r\n   */\r\n  get isAnyLoading$(): Observable<boolean> {\r\n    return this.statesSubject.pipe(\r\n      map(states => Array.from(states.values()).some(state => state.isLoading))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get observable for a specific loading operation\r\n   * @param id - The loading operation identifier\r\n   */\r\n  isLoading$(id: string = this.defaultId): Observable<boolean> {\r\n    return this.statesSubject.pipe(\r\n      map(states => states.get(id)?.isLoading ?? false)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get observable for loading state with message\r\n   * @param id - The loading operation identifier\r\n   */\r\n  getState$(id: string = this.defaultId): Observable<LoadingState | undefined> {\r\n    return this.statesSubject.pipe(\r\n      map(states => states.get(id))\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Check if a specific operation is currently loading (synchronous)\r\n   * @param id - The loading operation identifier\r\n   */\r\n  isLoading(id: string = this.defaultId): boolean {\r\n    return this.loadingStates.get(id)?.isLoading ?? false;\r\n  }\r\n\r\n  /**\r\n   * Check if any operation is currently loading (synchronous)\r\n   */\r\n  isAnyLoading(): boolean {\r\n    return Array.from(this.loadingStates.values()).some(state => state.isLoading);\r\n  }\r\n\r\n  /**\r\n   * Start a loading operation\r\n   * @param id - The loading operation identifier\r\n   * @param message - Optional message to display\r\n   */\r\n  start(id: string = this.defaultId, message?: string): void {\r\n    this.updateState(id, { isLoading: true, message, progress: undefined });\r\n  }\r\n\r\n  /**\r\n   * Stop a loading operation\r\n   * @param id - The loading operation identifier\r\n   */\r\n  stop(id: string = this.defaultId): void {\r\n    this.updateState(id, { isLoading: false, message: undefined, progress: undefined });\r\n  }\r\n\r\n  /**\r\n   * Update progress for a loading operation\r\n   * @param id - The loading operation identifier\r\n   * @param progress - Progress percentage (0-100)\r\n   * @param message - Optional updated message\r\n   */\r\n  setProgress(id: string, progress: number, message?: string): void {\r\n    const currentState = this.loadingStates.get(id);\r\n    if (currentState) {\r\n      this.updateState(id, {\r\n        isLoading: true,\r\n        progress: Math.min(100, Math.max(0, progress)),\r\n        message: message ?? currentState.message\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Update the message for a loading operation\r\n   * @param id - The loading operation identifier\r\n   * @param message - New message to display\r\n   */\r\n  setMessage(id: string, message: string): void {\r\n    const currentState = this.loadingStates.get(id);\r\n    if (currentState) {\r\n      this.updateState(id, { ...currentState, id, message });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Stop all loading operations\r\n   */\r\n  stopAll(): void {\r\n    this.loadingStates.clear();\r\n    this.statesSubject.next(new Map());\r\n  }\r\n\r\n  /**\r\n   * Remove a loading state completely\r\n   * @param id - The loading operation identifier\r\n   */\r\n  remove(id: string): void {\r\n    this.loadingStates.delete(id);\r\n    this.emitStates();\r\n  }\r\n\r\n  /**\r\n   * Execute an async operation with automatic loading state management\r\n   * @param id - The loading operation identifier\r\n   * @param operation - The async operation to execute\r\n   * @param message - Optional loading message\r\n   * @returns The result of the operation\r\n   */\r\n  async withLoading<T>(\r\n    id: string,\r\n    operation: () => Promise<T>,\r\n    message?: string\r\n  ): Promise<T> {\r\n    this.start(id, message);\r\n    try {\r\n      return await operation();\r\n    } finally {\r\n      this.stop(id);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Update a loading state\r\n   */\r\n  private updateState(id: string, partialState: Partial<LoadingState> & { isLoading: boolean }): void {\r\n    const state: LoadingState = {\r\n      id,\r\n      isLoading: partialState.isLoading,\r\n      message: partialState.message,\r\n      progress: partialState.progress\r\n    };\r\n\r\n    this.loadingStates.set(id, state);\r\n    this.emitStates();\r\n  }\r\n\r\n  /**\r\n   * Emit current states to subscribers\r\n   */\r\n  private emitStates(): void {\r\n    this.statesSubject.next(new Map(this.loadingStates));\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,144 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * A stateless, injectable notification service for displaying toast notifications.
+ *
+ * This service provides a reactive way to manage notifications across the application.
+ * It uses RxJS Subjects to emit notification events that can be consumed by notification
+ * display components.
+ *
+ * @example
+ * ```typescript
+ * import { NotificationService } from '@pecb-ui/components';
+ *
+ * @Component({...})
+ * export class MyComponent {
+ *   constructor(private notificationService: NotificationService) {}
+ *
+ *   showSuccess(): void {
+ *     this.notificationService.success('Operation completed successfully!');
+ *   }
+ *
+ *   showError(): void {
+ *     this.notificationService.error('An error occurred', 'Error Title');
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+export class NotificationService {
+    constructor() {
+        this.notificationSubject = new Subject();
+        this.dismissSubject = new Subject();
+        this.clearSubject = new Subject();
+        /** Default duration for notifications in milliseconds */
+        this.defaultDuration = 5000;
+        /** Default position for notifications */
+        this.defaultPosition = 'top-right';
+    }
+    /**
+     * Observable stream of notifications
+     */
+    get notifications$() {
+        return this.notificationSubject.asObservable();
+    }
+    /**
+     * Observable stream of dismissed notification IDs
+     */
+    get dismiss$() {
+        return this.dismissSubject.asObservable();
+    }
+    /**
+     * Observable stream for clear all events
+     */
+    get clear$() {
+        return this.clearSubject.asObservable();
+    }
+    /**
+     * Show a success notification
+     * @param message - The notification message
+     * @param title - Optional title
+     * @param config - Optional additional configuration
+     */
+    success(message, title, config) {
+        return this.show({ ...config, message, title, type: 'success' });
+    }
+    /**
+     * Show an error notification
+     * @param message - The notification message
+     * @param title - Optional title
+     * @param config - Optional additional configuration
+     */
+    error(message, title, config) {
+        return this.show({ ...config, message, title, type: 'error' });
+    }
+    /**
+     * Show a warning notification
+     * @param message - The notification message
+     * @param title - Optional title
+     * @param config - Optional additional configuration
+     */
+    warning(message, title, config) {
+        return this.show({ ...config, message, title, type: 'warning' });
+    }
+    /**
+     * Show an info notification
+     * @param message - The notification message
+     * @param title - Optional title
+     * @param config - Optional additional configuration
+     */
+    info(message, title, config) {
+        return this.show({ ...config, message, title, type: 'info' });
+    }
+    /**
+     * Show a notification with custom configuration
+     * @param config - Full notification configuration
+     * @returns The notification ID
+     */
+    show(config) {
+        const id = config.id || this.generateId();
+        const notification = {
+            id,
+            message: config.message,
+            title: config.title,
+            type: config.type,
+            duration: config.duration ?? this.defaultDuration,
+            dismissible: config.dismissible ?? true,
+            position: config.position ?? this.defaultPosition,
+            customClass: config.customClass,
+            timestamp: new Date()
+        };
+        this.notificationSubject.next(notification);
+        return id;
+    }
+    /**
+     * Dismiss a specific notification by ID
+     * @param id - The notification ID to dismiss
+     */
+    dismiss(id) {
+        this.dismissSubject.next(id);
+    }
+    /**
+     * Clear all notifications
+     */
+    clearAll() {
+        this.clearSubject.next();
+    }
+    /**
+     * Generate a unique notification ID
+     */
+    generateId() {
+        return `notification-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../projects/ui-components/src/lib/services/notification.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Subject, Observable } from 'rxjs';\r\n\r\n/**\r\n * Notification types supported by the service\r\n */\r\nexport type NotificationType = 'success' | 'error' | 'warning' | 'info';\r\n\r\n/**\r\n * Notification position on screen\r\n */\r\nexport type NotificationPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';\r\n\r\n/**\r\n * Notification configuration options\r\n */\r\nexport interface NotificationConfig {\r\n  /** Notification message */\r\n  message: string;\r\n  /** Notification title (optional) */\r\n  title?: string;\r\n  /** Type of notification */\r\n  type: NotificationType;\r\n  /** Duration in milliseconds (0 for persistent) */\r\n  duration?: number;\r\n  /** Whether the notification can be dismissed */\r\n  dismissible?: boolean;\r\n  /** Position on screen */\r\n  position?: NotificationPosition;\r\n  /** Custom CSS class */\r\n  customClass?: string;\r\n  /** Unique identifier */\r\n  id?: string;\r\n}\r\n\r\n/**\r\n * Notification object with all properties\r\n */\r\nexport interface Notification extends Required<Omit<NotificationConfig, 'title' | 'customClass'>> {\r\n  title?: string;\r\n  customClass?: string;\r\n  timestamp: Date;\r\n}\r\n\r\n/**\r\n * A stateless, injectable notification service for displaying toast notifications.\r\n *\r\n * This service provides a reactive way to manage notifications across the application.\r\n * It uses RxJS Subjects to emit notification events that can be consumed by notification\r\n * display components.\r\n *\r\n * @example\r\n * ```typescript\r\n * import { NotificationService } from '@pecb-ui/components';\r\n *\r\n * @Component({...})\r\n * export class MyComponent {\r\n *   constructor(private notificationService: NotificationService) {}\r\n *\r\n *   showSuccess(): void {\r\n *     this.notificationService.success('Operation completed successfully!');\r\n *   }\r\n *\r\n *   showError(): void {\r\n *     this.notificationService.error('An error occurred', 'Error Title');\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * @publicApi\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class NotificationService {\r\n  private readonly notificationSubject = new Subject<Notification>();\r\n  private readonly dismissSubject = new Subject<string>();\r\n  private readonly clearSubject = new Subject<void>();\r\n\r\n  /** Default duration for notifications in milliseconds */\r\n  private readonly defaultDuration = 5000;\r\n  /** Default position for notifications */\r\n  private readonly defaultPosition: NotificationPosition = 'top-right';\r\n\r\n  /**\r\n   * Observable stream of notifications\r\n   */\r\n  get notifications$(): Observable<Notification> {\r\n    return this.notificationSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Observable stream of dismissed notification IDs\r\n   */\r\n  get dismiss$(): Observable<string> {\r\n    return this.dismissSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Observable stream for clear all events\r\n   */\r\n  get clear$(): Observable<void> {\r\n    return this.clearSubject.asObservable();\r\n  }\r\n\r\n  /**\r\n   * Show a success notification\r\n   * @param message - The notification message\r\n   * @param title - Optional title\r\n   * @param config - Optional additional configuration\r\n   */\r\n  success(message: string, title?: string, config?: Partial<NotificationConfig>): string {\r\n    return this.show({ ...config, message, title, type: 'success' });\r\n  }\r\n\r\n  /**\r\n   * Show an error notification\r\n   * @param message - The notification message\r\n   * @param title - Optional title\r\n   * @param config - Optional additional configuration\r\n   */\r\n  error(message: string, title?: string, config?: Partial<NotificationConfig>): string {\r\n    return this.show({ ...config, message, title, type: 'error' });\r\n  }\r\n\r\n  /**\r\n   * Show a warning notification\r\n   * @param message - The notification message\r\n   * @param title - Optional title\r\n   * @param config - Optional additional configuration\r\n   */\r\n  warning(message: string, title?: string, config?: Partial<NotificationConfig>): string {\r\n    return this.show({ ...config, message, title, type: 'warning' });\r\n  }\r\n\r\n  /**\r\n   * Show an info notification\r\n   * @param message - The notification message\r\n   * @param title - Optional title\r\n   * @param config - Optional additional configuration\r\n   */\r\n  info(message: string, title?: string, config?: Partial<NotificationConfig>): string {\r\n    return this.show({ ...config, message, title, type: 'info' });\r\n  }\r\n\r\n  /**\r\n   * Show a notification with custom configuration\r\n   * @param config - Full notification configuration\r\n   * @returns The notification ID\r\n   */\r\n  show(config: NotificationConfig): string {\r\n    const id = config.id || this.generateId();\r\n\r\n    const notification: Notification = {\r\n      id,\r\n      message: config.message,\r\n      title: config.title,\r\n      type: config.type,\r\n      duration: config.duration ?? this.defaultDuration,\r\n      dismissible: config.dismissible ?? true,\r\n      position: config.position ?? this.defaultPosition,\r\n      customClass: config.customClass,\r\n      timestamp: new Date()\r\n    };\r\n\r\n    this.notificationSubject.next(notification);\r\n    return id;\r\n  }\r\n\r\n  /**\r\n   * Dismiss a specific notification by ID\r\n   * @param id - The notification ID to dismiss\r\n   */\r\n  dismiss(id: string): void {\r\n    this.dismissSubject.next(id);\r\n  }\r\n\r\n  /**\r\n   * Clear all notifications\r\n   */\r\n  clearAll(): void {\r\n    this.clearSubject.next();\r\n  }\r\n\r\n  /**\r\n   * Generate a unique notification ID\r\n   */\r\n  private generateId(): string {\r\n    return `notification-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;\r\n  }\r\n}\r\n"]}