@ruc-lib/overlay 3.1.0 → 3.1.1

package/esm2020/lib/ruclib-overlay/ruclib-overlay.component.mjs

@@ -0,0 +1,196 @@
+import { Overlay, } from '@angular/cdk/overlay';
+import { Component, ElementRef, HostListener, Injector, Input, ViewChild, } from '@angular/core';
+import { OVERLAY_CONTROL, } from '../model/overlay.types';
+import { filter } from 'rxjs';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { OverlayService } from '../service/overlay.service';
+import { OverlayContentComponent } from '../overlay-content/overlay-content.component';
+import { MatButton } from '@angular/material/button';
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { positions } from '../constants/positions';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../service/overlay.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/button";
+export class RuclibOverlayComponent {
+    constructor(overlay, injector, overlayService) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.overlayService = overlayService;
+        this.rucInputData = {
+            content: 'Default content',
+        };
+        this.overlayRef = null;
+    }
+    ngOnInit() {
+        if (!this.buttonText) {
+            this.serviceSubscription = this.overlayService.popoverState$.subscribe((data) => {
+                if (data && !this.isOpen) {
+                    this.show(data.trigger, data.config);
+                }
+                else if (!data) {
+                    this.destroy();
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.positionSubscription?.unsubscribe();
+        this.serviceSubscription?.unsubscribe();
+        this.destroy();
+    }
+    get isOpen() {
+        return !!this.overlayRef;
+    }
+    // --- Trigger Handlers for self-contained button ---
+    toggle() {
+        if (this.rucInputData.trigger !== 'hover') {
+            this.isOpen
+                ? this.destroy()
+                : this.show(this.triggerButtonRef.nativeElement, this.rucInputData);
+        }
+    }
+    handleMouseEnter() {
+        if (this.rucInputData.trigger === 'hover') {
+            if (this.closeTimeout)
+                clearTimeout(this.closeTimeout); // Clear any pending close command
+            this.show(this.triggerButtonRef.nativeElement, this.rucInputData);
+        }
+    }
+    handleMouseLeave() {
+        if (this.rucInputData.trigger === 'hover') {
+            // Use the configurable closeDelay
+            const delay = this.rucInputData.closeDelay ?? 200;
+            this.closeTimeout = setTimeout(() => this.destroy(), delay);
+        }
+    }
+    show(trigger, config) {
+        if (this.isOpen)
+            return;
+        const positionStrategy = this.createPositionStrategy(trigger, config.placement || 'bottom');
+        this.overlayRef = this.overlay.create({
+            positionStrategy,
+            hasBackdrop: config.trigger !== 'hover',
+            backdropClass: 'cdk-overlay-transparent-backdrop',
+            scrollStrategy: this.overlay.scrollStrategies.reposition(),
+        });
+        this.overlayRef.keydownEvents().pipe(filter(event => event.keyCode === ESCAPE)).subscribe(() => this.destroy());
+        const control = { config, close: this.destroy.bind(this) };
+        const injector = Injector.create({
+            parent: this.injector,
+            providers: [{ provide: OVERLAY_CONTROL, useValue: control }],
+        });
+        const portal = new ComponentPortal(OverlayContentComponent, null, injector);
+        const componentRef = this.overlayRef.attach(portal);
+        componentRef.instance.customTheme = this.customTheme;
+        // --- START: MODIFICATION FOR DYNAMIC ARROW ---
+        this.positionSubscription = positionStrategy.positionChanges.subscribe((change) => {
+            // 1. Get the new placement ('top', 'bottom', etc.)
+            const newPlacement = this.getPlacementFromPosition(change.connectionPair);
+            componentRef.instance.actualPlacement = newPlacement;
+            // 2. Calculate the arrow's offset
+            if (this.overlayRef) {
+                const triggerRect = trigger.getBoundingClientRect();
+                const popoverRect = this.overlayRef.overlayElement.getBoundingClientRect();
+                let arrowOffset = 0;
+                // If popover is top/bottom, arrow moves horizontally (left)
+                if (newPlacement.startsWith('top') ||
+                    newPlacement.startsWith('bottom')) {
+                    const triggerCenter = triggerRect.left + triggerRect.width / 2;
+                    arrowOffset = triggerCenter - popoverRect.left;
+                }
+                // If popover is left/right, arrow moves vertically (top)
+                else {
+                    const triggerCenter = triggerRect.top + triggerRect.height / 2;
+                    arrowOffset = triggerCenter - popoverRect.top;
+                }
+                // 3. Pass the offset to the content component
+                componentRef.instance.arrowOffset = arrowOffset;
+            }
+            componentRef.changeDetectorRef.detectChanges();
+        });
+        componentRef.instance.mouseEnterPopover.subscribe(() => {
+            if (this.closeTimeout)
+                clearTimeout(this.closeTimeout);
+        });
+        componentRef.instance.mouseLeavePopover.subscribe(() => this.handleMouseLeave());
+        if (config.trigger !== 'hover') {
+            this.overlayRef.backdropClick().subscribe(() => this.destroy());
+        }
+        const popoverId = `popover-${Math.random().toString(36).substring(2, 9)}`;
+        componentRef.location.nativeElement.setAttribute('id', popoverId);
+        trigger.setAttribute('aria-describedby', popoverId);
+        this.lastTriggerElement = trigger;
+    }
+    // Renamed from hide() to destroy() for clarity
+    destroy() {
+        if (!this.overlayRef)
+            return; // Prevent multiple calls
+        if (this.lastTriggerElement) {
+            this.lastTriggerElement.removeAttribute('aria-describedby');
+            this.lastTriggerElement = undefined;
+        }
+        this.positionSubscription?.unsubscribe();
+        this.overlayRef.dispose();
+        this.overlayRef = null;
+    }
+    getPlacementFromPosition(position) {
+        if (position.originY === 'top' && position.overlayY === 'bottom')
+            return 'top';
+        if (position.originY === 'bottom' && position.overlayY === 'top')
+            return 'bottom';
+        if (position.originX === 'start' && position.overlayX === 'end')
+            return 'left';
+        if (position.originX === 'end' && position.overlayX === 'start')
+            return 'right';
+        return 'bottom';
+    }
+    createPositionStrategy(origin, placement) {
+        let preferredPosition;
+        switch (placement) {
+            case 'top':
+                preferredPosition = positions[1];
+                break;
+            case 'right':
+                preferredPosition = positions[2];
+                break;
+            case 'left':
+                preferredPosition = positions[3];
+                break;
+            default:
+                preferredPosition = positions[0];
+                break;
+        }
+        return this.overlay
+            .position()
+            .flexibleConnectedTo(origin)
+            .withPositions([preferredPosition, ...positions])
+            .withPush(true);
+    }
+    //Document-level listeners for closing
+    onEscape() {
+        this.positionSubscription?.unsubscribe();
+        this.serviceSubscription?.unsubscribe();
+        this.destroy();
+    }
+}
+RuclibOverlayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayComponent, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: i2.OverlayService }], target: i0.ɵɵFactoryTarget.Component });
+RuclibOverlayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: RuclibOverlayComponent, selector: "uxp-ruclib-overlay", inputs: { buttonText: "buttonText", rucInputData: "rucInputData", customTheme: "customTheme" }, host: { listeners: { "document:keydown:escape": "onEscape()" } }, viewQueries: [{ propertyName: "triggerButtonRef", first: true, predicate: MatButton, descendants: true, read: ElementRef }], ngImport: i0, template: "<button\r\nmat-raised-button\r\n  color=\"primary\"\r\n  *ngIf=\"buttonText\"\r\n  #triggerButton\r\n  (click)=\"toggle()\"\r\n  (mouseenter)=\"handleMouseEnter()\"\r\n  (mouseleave)=\"handleMouseLeave()\"\r\n  class=\"popover-trigger-btn\">\r\n  {{ buttonText }}\r\n</button>\r\n", styles: [""], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'uxp-ruclib-overlay', template: "<button\r\nmat-raised-button\r\n  color=\"primary\"\r\n  *ngIf=\"buttonText\"\r\n  #triggerButton\r\n  (click)=\"toggle()\"\r\n  (mouseenter)=\"handleMouseEnter()\"\r\n  (mouseleave)=\"handleMouseLeave()\"\r\n  class=\"popover-trigger-btn\">\r\n  {{ buttonText }}\r\n</button>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.OverlayService }]; }, propDecorators: { buttonText: [{
+                type: Input
+            }], rucInputData: [{
+                type: Input
+            }], customTheme: [{
+                type: Input
+            }], triggerButtonRef: [{
+                type: ViewChild,
+                args: [MatButton, { read: ElementRef }]
+            }], onEscape: [{
+                type: HostListener,
+                args: ['document:keydown:escape']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ruclib-overlay.component.js","sourceRoot":"","sources":["../../../../src/lib/ruclib-overlay/ruclib-overlay.component.ts","../../../../src/lib/ruclib-overlay/ruclib-overlay.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ConnectedPosition,\r\n  ConnectionPositionPair,\r\n  FlexibleConnectedPositionStrategy,\r\n  Overlay,\r\n  OverlayRef,\r\n} from '@angular/cdk/overlay';\r\nimport {\r\n  Component,\r\n  ElementRef,\r\n  HostListener,\r\n  Injector,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  ViewChild,\r\n} from '@angular/core';\r\nimport {\r\n  OVERLAY_CONTROL,\r\n  OverlayConfig,\r\n  OverlayControl,\r\n  OverlayData,\r\n} from '../model/overlay.types';\r\nimport { filter, Subscription } from 'rxjs';\r\nimport { ComponentPortal } from '@angular/cdk/portal';\r\nimport { OverlayService } from '../service/overlay.service';\r\nimport { OverlayContentComponent } from '../overlay-content/overlay-content.component';\r\nimport { MatButton } from '@angular/material/button';\r\nimport { ESCAPE } from '@angular/cdk/keycodes';\r\nimport { positions } from '../constants/positions';\r\n\r\nexport type PopoverPlacement = 'top' | 'bottom' | 'left' | 'right';\r\nexport type PopoverAnimation = 'fade' | 'scale';\r\nexport type ChartType = 'doughnut' | 'pie' | 'bar';\r\n\r\nexport interface ChartModel {\r\n  chartType: ChartType;\r\n  data: any;\r\n}\r\n\r\n@Component({\r\n  selector: 'uxp-ruclib-overlay',\r\n  templateUrl: './ruclib-overlay.component.html',\r\n  styleUrls: ['./ruclib-overlay.component.scss'],\r\n})\r\nexport class RuclibOverlayComponent implements OnInit, OnDestroy {\r\n  @Input() buttonText?: string;\r\n  @Input() rucInputData: OverlayConfig = {\r\n    content: 'Default content',\r\n  };\r\n  @Input() customTheme!: string;\r\n\r\n  @ViewChild(MatButton, { read: ElementRef })\r\n  private triggerButtonRef!: ElementRef;\r\n\r\n  private overlayRef: OverlayRef | null = null;\r\n  private serviceSubscription!: Subscription;\r\n  private closeTimeout?: ReturnType<typeof setTimeout>; // Use the correct type\r\n  private lastTriggerElement?: HTMLElement;\r\n  private positionSubscription!: Subscription;\r\n\r\n  constructor(\r\n    private overlay: Overlay,\r\n    private injector: Injector,\r\n    private overlayService: OverlayService\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    if (!this.buttonText) {\r\n      this.serviceSubscription = this.overlayService.popoverState$.subscribe(\r\n        (data: any) => {\r\n          if (data && !this.isOpen) {\r\n            this.show(data.trigger, data.config);\r\n          } else if (!data) {\r\n            this.destroy();\r\n          }\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.positionSubscription?.unsubscribe();\r\n    this.serviceSubscription?.unsubscribe();\r\n    this.destroy();\r\n  }\r\n\r\n  get isOpen(): boolean {\r\n    return !!this.overlayRef;\r\n  }\r\n\r\n  // --- Trigger Handlers for self-contained button ---\r\n  toggle(): void {\r\n    if (this.rucInputData.trigger !== 'hover') {\r\n      this.isOpen\r\n        ? this.destroy()\r\n        : this.show(this.triggerButtonRef.nativeElement, this.rucInputData);\r\n    }\r\n  }\r\n\r\n  handleMouseEnter(): void {\r\n    if (this.rucInputData.trigger === 'hover') {\r\n      if (this.closeTimeout) clearTimeout(this.closeTimeout); // Clear any pending close command\r\n      this.show(this.triggerButtonRef.nativeElement, this.rucInputData);\r\n    }\r\n  }\r\n\r\n  handleMouseLeave(): void {\r\n    if (this.rucInputData.trigger === 'hover') {\r\n      // Use the configurable closeDelay\r\n      const delay = this.rucInputData.closeDelay ?? 200;\r\n      this.closeTimeout = setTimeout(() => this.destroy(), delay);\r\n    }\r\n  }\r\n\r\n  private show(trigger: HTMLElement, config: OverlayConfig): void {\r\n    if (this.isOpen) return;\r\n\r\n    const positionStrategy = this.createPositionStrategy(\r\n      trigger,\r\n      config.placement || 'bottom'\r\n    );\r\n    this.overlayRef = this.overlay.create({\r\n      positionStrategy,\r\n      hasBackdrop: config.trigger !== 'hover',\r\n      backdropClass: 'cdk-overlay-transparent-backdrop',\r\n      scrollStrategy: this.overlay.scrollStrategies.reposition(),\r\n    });\r\n\r\n    this.overlayRef.keydownEvents().pipe(filter(event=> event.keyCode === ESCAPE)).subscribe(()=> this.destroy());\r\n\r\n    const control: OverlayControl = { config, close: this.destroy.bind(this) };\r\n    const injector = Injector.create({\r\n      parent: this.injector,\r\n      providers: [{ provide: OVERLAY_CONTROL, useValue: control }],\r\n    });\r\n\r\n    const portal = new ComponentPortal(OverlayContentComponent, null, injector);\r\n    const componentRef = this.overlayRef.attach(portal);\r\n    componentRef.instance.customTheme = this.customTheme;\r\n\r\n    // --- START: MODIFICATION FOR DYNAMIC ARROW ---\r\n    this.positionSubscription = positionStrategy.positionChanges.subscribe(\r\n      (change) => {\r\n        // 1. Get the new placement ('top', 'bottom', etc.)\r\n        const newPlacement = this.getPlacementFromPosition(\r\n          change.connectionPair\r\n        );\r\n        componentRef.instance.actualPlacement = newPlacement;\r\n\r\n        // 2. Calculate the arrow's offset\r\n        if (this.overlayRef) {\r\n          const triggerRect = trigger.getBoundingClientRect();\r\n          const popoverRect =\r\n            this.overlayRef.overlayElement.getBoundingClientRect();\r\n\r\n          let arrowOffset = 0;\r\n          // If popover is top/bottom, arrow moves horizontally (left)\r\n          if (\r\n            newPlacement.startsWith('top') ||\r\n            newPlacement.startsWith('bottom')\r\n          ) {\r\n            const triggerCenter = triggerRect.left + triggerRect.width / 2;\r\n            arrowOffset = triggerCenter - popoverRect.left;\r\n          }\r\n          // If popover is left/right, arrow moves vertically (top)\r\n          else {\r\n            const triggerCenter = triggerRect.top + triggerRect.height / 2;\r\n            arrowOffset = triggerCenter - popoverRect.top;\r\n          }\r\n\r\n          // 3. Pass the offset to the content component\r\n          componentRef.instance.arrowOffset = arrowOffset;\r\n        }\r\n\r\n        componentRef.changeDetectorRef.detectChanges();\r\n      }\r\n    );\r\n\r\n    componentRef.instance.mouseEnterPopover.subscribe(() => {\r\n      if (this.closeTimeout) clearTimeout(this.closeTimeout);\r\n    });\r\n    componentRef.instance.mouseLeavePopover.subscribe(() =>\r\n      this.handleMouseLeave()\r\n    );\r\n\r\n    if (config.trigger !== 'hover') {\r\n      this.overlayRef.backdropClick().subscribe(() => this.destroy());\r\n    }\r\n\r\n    const popoverId = `popover-${Math.random().toString(36).substring(2, 9)}`;\r\n    componentRef.location.nativeElement.setAttribute('id', popoverId);\r\n    trigger.setAttribute('aria-describedby', popoverId);\r\n    this.lastTriggerElement = trigger;\r\n  }\r\n\r\n  // Renamed from hide() to destroy() for clarity\r\n  private destroy(): void {\r\n    if (!this.overlayRef) return; // Prevent multiple calls\r\n\r\n    if (this.lastTriggerElement) {\r\n      this.lastTriggerElement.removeAttribute('aria-describedby');\r\n      this.lastTriggerElement = undefined;\r\n    }\r\n    this.positionSubscription?.unsubscribe();\r\n    this.overlayRef.dispose();\r\n    this.overlayRef = null;\r\n  }\r\n\r\n  private getPlacementFromPosition(\r\n    position: ConnectionPositionPair\r\n  ): PopoverPlacement {\r\n    if (position.originY === 'top' && position.overlayY === 'bottom')\r\n      return 'top';\r\n    if (position.originY === 'bottom' && position.overlayY === 'top')\r\n      return 'bottom';\r\n    if (position.originX === 'start' && position.overlayX === 'end')\r\n      return 'left';\r\n    if (position.originX === 'end' && position.overlayX === 'start')\r\n      return 'right';\r\n    return 'bottom';\r\n  }\r\n\r\n  private createPositionStrategy(\r\n    origin: HTMLElement,\r\n    placement: string\r\n  ): FlexibleConnectedPositionStrategy {\r\n    let preferredPosition: ConnectedPosition;\r\n    switch (placement) {\r\n      case 'top':\r\n        preferredPosition = positions[1];\r\n        break;\r\n      case 'right':\r\n        preferredPosition = positions[2];\r\n        break;\r\n      case 'left':\r\n        preferredPosition = positions[3];\r\n        break;\r\n      default:\r\n        preferredPosition = positions[0];\r\n        break;\r\n    }\r\n\r\n    return this.overlay\r\n      .position()\r\n      .flexibleConnectedTo(origin)\r\n      .withPositions([preferredPosition, ...positions])\r\n      .withPush(true);\r\n  }\r\n\r\n  //Document-level listeners for closing\r\n  @HostListener('document:keydown:escape')\r\n  onEscape(): void {\r\n    this.positionSubscription?.unsubscribe();\r\n    this.serviceSubscription?.unsubscribe();\r\n    this.destroy();\r\n  }\r\n}\r\n","<button\r\nmat-raised-button\r\n  color=\"primary\"\r\n  *ngIf=\"buttonText\"\r\n  #triggerButton\r\n  (click)=\"toggle()\"\r\n  (mouseenter)=\"handleMouseEnter()\"\r\n  (mouseleave)=\"handleMouseLeave()\"\r\n  class=\"popover-trigger-btn\">\r\n  {{ buttonText }}\r\n</button>\r\n"]}

package/esm2020/lib/ruclib-overlay.module.mjs

@@ -0,0 +1,48 @@
+import { MatCardModule } from '@angular/material/card';
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RuclibOverlayComponent } from './ruclib-overlay/ruclib-overlay.component';
+import { OverlayContentComponent } from './overlay-content/overlay-content.component';
+import { MatIconModule } from '@angular/material/icon';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { MatButtonModule } from '@angular/material/button';
+import { RucOverlayChartComponent } from './ruc-overlay-chart/ruc-overlay-chart.component';
+import * as i0 from "@angular/core";
+export class RuclibOverlayModule {
+}
+RuclibOverlayModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RuclibOverlayModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayModule, declarations: [RuclibOverlayComponent,
+        OverlayContentComponent,
+        RucOverlayChartComponent], imports: [CommonModule,
+        MatIconModule,
+        OverlayModule,
+        BrowserAnimationsModule,
+        MatButtonModule,
+        MatCardModule], exports: [RuclibOverlayComponent, RucOverlayChartComponent] });
+RuclibOverlayModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayModule, imports: [CommonModule,
+        MatIconModule,
+        OverlayModule,
+        BrowserAnimationsModule,
+        MatButtonModule,
+        MatCardModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RuclibOverlayModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatIconModule,
+                        OverlayModule,
+                        BrowserAnimationsModule,
+                        MatButtonModule,
+                        MatCardModule
+                    ],
+                    declarations: [
+                        RuclibOverlayComponent,
+                        OverlayContentComponent,
+                        RucOverlayChartComponent
+                    ],
+                    exports: [RuclibOverlayComponent, RucOverlayChartComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/service/overlay.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class OverlayService {
+    constructor() {
+        this.popoverState = new Subject();
+        this.popoverState$ = this.popoverState.asObservable();
+    }
+    /**
+     * Broadcasts a command to open a popover using the OverlayData structure.
+     */
+    open(config, trigger) {
+        console.log(config, trigger);
+        // The service's responsibility is to bundle the config and trigger
+        // into a PopoverData object and send it.
+        this.popoverState.next({ config, trigger });
+    }
+    /**
+     * Broadcasts a command to close any currently open service-controlled popover.
+     */
+    close() {
+        this.popoverState.next(null);
+    }
+}
+OverlayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OverlayService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OverlayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: OverlayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ruc-lib-overlay.mjs

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