tas-uell-sdk 0.0.1

package/esm2020/lib/components/tas-videocall/tas-videocall.component.mjs

@@ -0,0 +1,160 @@
+import { Component, Input, ViewChild, } from "@angular/core";
+import { CallState, ViewMode } from "../../services/tas.service";
+import { Subscription } from "rxjs";
+import interact from "interactjs";
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-bootstrap/ng-bootstrap";
+import * as i2 from "../../services/tas.service";
+export class TasVideocallComponent {
+    constructor(activeModal, tasService) {
+        this.activeModal = activeModal;
+        this.tasService = tasService;
+        this.isReturningFromPip = false;
+        this.isPublisherSmall = true;
+        this.callState = CallState.IDLE;
+        this.isMuted = false;
+        this.subscriptions = new Subscription();
+    }
+    ngOnInit() {
+        this.setupSubscriptions();
+        this.initializeCall();
+    }
+    ngAfterViewInit() {
+        this.initInteract();
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+        if (!this.tasService.isPipMode()) {
+            this.tasService.disconnectSession();
+        }
+        interact(".publisher-view").unset();
+    }
+    // Public Methods
+    hangUp() {
+        this.tasService.disconnectSession();
+    }
+    toggleMute() {
+        this.tasService.toggleMute();
+    }
+    minimize() {
+        this.tasService.moveMainVideoTo("pip-main-video");
+        setTimeout(() => this.tasService.enterPipMode(), 50);
+    }
+    toggleSwap() {
+        this.isPublisherSmall = !this.isPublisherSmall;
+        this.resetVideoPositions();
+        setTimeout(() => this.initInteract());
+    }
+    onDoubleClick() {
+        this.toggleSwap();
+    }
+    // Private Methods
+    setupSubscriptions() {
+        this.subscriptions.add(this.tasService.callState$.subscribe((state) => {
+            this.callState = state;
+            if (state === CallState.DISCONNECTED) {
+                this.activeModal.close("hangup");
+            }
+        }));
+        this.subscriptions.add(this.tasService.viewMode$.subscribe((mode) => {
+            if (mode === ViewMode.PIP) {
+                this.activeModal.close("pip");
+            }
+        }));
+        this.subscriptions.add(this.tasService.isMuted$.subscribe((muted) => {
+            this.isMuted = muted;
+        }));
+    }
+    initializeCall() {
+        if (this.isReturningFromPip) {
+            setTimeout(() => this.tasService.moveVideosToFullscreen(), 100);
+        }
+        else if (this.sessionId && this.token) {
+            this.tasService
+                .connectSession(this.sessionId, this.token, "publisher-container", "subscriber-container")
+                .catch((err) => {
+                console.error("Error connecting to video call:", err);
+            });
+        }
+    }
+    resetVideoPositions() {
+        const publisherEl = this.publisherContainer?.nativeElement;
+        const subscriberEl = this.subscriberContainer?.nativeElement;
+        if (publisherEl) {
+            publisherEl.removeAttribute("style");
+            publisherEl.removeAttribute("data-x");
+            publisherEl.removeAttribute("data-y");
+        }
+        if (subscriberEl) {
+            subscriberEl.removeAttribute("style");
+            subscriberEl.removeAttribute("data-x");
+            subscriberEl.removeAttribute("data-y");
+        }
+    }
+    initInteract() {
+        interact(".publisher-view").unset();
+        interact(".publisher-view")
+            .draggable({
+            inertia: true,
+            modifiers: [
+                interact.modifiers.restrictRect({
+                    restriction: "parent",
+                    endOnly: true,
+                }),
+            ],
+            autoScroll: true,
+            listeners: {
+                move: (event) => {
+                    const target = event.target;
+                    const x = (parseFloat(target.getAttribute("data-x")) || 0) + event.dx;
+                    const y = (parseFloat(target.getAttribute("data-y")) || 0) + event.dy;
+                    target.style.transform = `translate(${x}px, ${y}px)`;
+                    target.setAttribute("data-x", String(x));
+                    target.setAttribute("data-y", String(y));
+                },
+            },
+        })
+            .resizable({
+            edges: { left: false, right: true, bottom: true, top: false },
+            listeners: {
+                move: (event) => {
+                    const target = event.target;
+                    let x = parseFloat(target.getAttribute("data-x")) || 0;
+                    let y = parseFloat(target.getAttribute("data-y")) || 0;
+                    target.style.width = `${event.rect.width}px`;
+                    target.style.height = `${event.rect.height}px`;
+                    x += event.deltaRect.left;
+                    y += event.deltaRect.top;
+                    target.style.transform = `translate(${x}px, ${y}px)`;
+                    target.setAttribute("data-x", String(x));
+                    target.setAttribute("data-y", String(y));
+                },
+            },
+            modifiers: [
+                interact.modifiers.restrictEdges({ outer: "parent" }),
+                interact.modifiers.restrictSize({ min: { width: 150, height: 100 } }),
+                interact.modifiers.aspectRatio({ ratio: "preserve" }),
+            ],
+            inertia: true,
+        });
+    }
+}
+TasVideocallComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasVideocallComponent, deps: [{ token: i1.NgbActiveModal }, { token: i2.TasService }], target: i0.ɵɵFactoryTarget.Component });
+TasVideocallComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: TasVideocallComponent, selector: "tas-videocall", inputs: { sessionId: "sessionId", token: "token", isReturningFromPip: "isReturningFromPip" }, viewQueries: [{ propertyName: "publisherContainer", first: true, predicate: ["publisherContainer"], descendants: true }, { propertyName: "subscriberContainer", first: true, predicate: ["subscriberContainer"], descendants: true }], ngImport: i0, template: "<div class=\"tas-videocall-container\">\n  <div\n    id=\"subscriber-container\"\n    [class.subscriber-view]=\"isPublisherSmall\"\n    [class.publisher-view]=\"!isPublisherSmall\"\n    #subscriberContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div\n    id=\"publisher-container\"\n    [class.publisher-view]=\"isPublisherSmall\"\n    [class.subscriber-view]=\"!isPublisherSmall\"\n    #publisherContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div class=\"controls-container\">\n    <button class=\"btn swap-btn\" (click)=\"toggleSwap()\" title=\"Cambiar vista\">\n      <i class=\"fa fa-refresh\"></i>\n    </button>\n    <button\n      class=\"btn pip-btn\"\n      (click)=\"minimize()\"\n      title=\"Minimizar (Picture in Picture)\"\n    >\n      <i class=\"fa fa-compress\"></i>\n    </button>\n    <button\n      class=\"btn mute-btn\"\n      [class.muted]=\"isMuted\"\n      (click)=\"toggleMute()\"\n      [title]=\"isMuted ? 'Activar micr\u00F3fono' : 'Silenciar micr\u00F3fono'\"\n    >\n      <i\n        class=\"fa\"\n        [class.fa-microphone]=\"!isMuted\"\n        [class.fa-microphone-slash]=\"isMuted\"\n      ></i>\n    </button>\n    <button class=\"btn hangup-btn\" (click)=\"hangUp()\" title=\"Colgar\">\n      <i class=\"fa fa-phone\" style=\"transform: rotate(135deg)\"></i>\n    </button>\n  </div>\n</div>\n", styles: [".tas-videocall-container{position:relative;width:100vw;height:100vh;background-color:#000;overflow:hidden}.tas-videocall-container ::ng-deep .OT_edge-bar-item,.tas-videocall-container ::ng-deep .OT_mute,.tas-videocall-container ::ng-deep .OT_audio-level-meter,.tas-videocall-container ::ng-deep .OT_bar,.tas-videocall-container ::ng-deep .OT_name{display:none!important}.tas-videocall-container .subscriber-view{width:100%;height:100%;z-index:1}.tas-videocall-container .publisher-view{position:absolute;top:20px;right:20px;width:200px;height:150px;z-index:2;border:2px solid #fff;border-radius:8px;background-color:#333}.tas-videocall-container .controls-container{display:flex;flex-direction:row;gap:20px;position:absolute;bottom:30px;left:50%;transform:translate(-50%);z-index:3;background-color:#00000080;padding:15px 25px;border-radius:50px;backdrop-filter:blur(5px)}.tas-videocall-container .controls-container .hangup-btn,.tas-videocall-container .controls-container .swap-btn,.tas-videocall-container .controls-container .pip-btn,.tas-videocall-container .controls-container .mute-btn{width:60px;height:60px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:24px;border:none;box-shadow:0 4px 6px #0000004d;transition:all .2s ease}.tas-videocall-container .controls-container .hangup-btn i,.tas-videocall-container .controls-container .swap-btn i,.tas-videocall-container .controls-container .pip-btn i,.tas-videocall-container .controls-container .mute-btn i{color:#fff}.tas-videocall-container .controls-container .hangup-btn{background:#dc3545}.tas-videocall-container .controls-container .hangup-btn:hover{background:#c82333;transform:scale(1.05)}.tas-videocall-container .controls-container .swap-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .swap-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .pip-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .pip-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .mute-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .mute-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .mute-btn.muted{background:#f39c12}.tas-videocall-container .controls-container .mute-btn.muted:hover{background:#e67e22}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasVideocallComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "tas-videocall", template: "<div class=\"tas-videocall-container\">\n  <div\n    id=\"subscriber-container\"\n    [class.subscriber-view]=\"isPublisherSmall\"\n    [class.publisher-view]=\"!isPublisherSmall\"\n    #subscriberContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div\n    id=\"publisher-container\"\n    [class.publisher-view]=\"isPublisherSmall\"\n    [class.subscriber-view]=\"!isPublisherSmall\"\n    #publisherContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div class=\"controls-container\">\n    <button class=\"btn swap-btn\" (click)=\"toggleSwap()\" title=\"Cambiar vista\">\n      <i class=\"fa fa-refresh\"></i>\n    </button>\n    <button\n      class=\"btn pip-btn\"\n      (click)=\"minimize()\"\n      title=\"Minimizar (Picture in Picture)\"\n    >\n      <i class=\"fa fa-compress\"></i>\n    </button>\n    <button\n      class=\"btn mute-btn\"\n      [class.muted]=\"isMuted\"\n      (click)=\"toggleMute()\"\n      [title]=\"isMuted ? 'Activar micr\u00F3fono' : 'Silenciar micr\u00F3fono'\"\n    >\n      <i\n        class=\"fa\"\n        [class.fa-microphone]=\"!isMuted\"\n        [class.fa-microphone-slash]=\"isMuted\"\n      ></i>\n    </button>\n    <button class=\"btn hangup-btn\" (click)=\"hangUp()\" title=\"Colgar\">\n      <i class=\"fa fa-phone\" style=\"transform: rotate(135deg)\"></i>\n    </button>\n  </div>\n</div>\n", styles: [".tas-videocall-container{position:relative;width:100vw;height:100vh;background-color:#000;overflow:hidden}.tas-videocall-container ::ng-deep .OT_edge-bar-item,.tas-videocall-container ::ng-deep .OT_mute,.tas-videocall-container ::ng-deep .OT_audio-level-meter,.tas-videocall-container ::ng-deep .OT_bar,.tas-videocall-container ::ng-deep .OT_name{display:none!important}.tas-videocall-container .subscriber-view{width:100%;height:100%;z-index:1}.tas-videocall-container .publisher-view{position:absolute;top:20px;right:20px;width:200px;height:150px;z-index:2;border:2px solid #fff;border-radius:8px;background-color:#333}.tas-videocall-container .controls-container{display:flex;flex-direction:row;gap:20px;position:absolute;bottom:30px;left:50%;transform:translate(-50%);z-index:3;background-color:#00000080;padding:15px 25px;border-radius:50px;backdrop-filter:blur(5px)}.tas-videocall-container .controls-container .hangup-btn,.tas-videocall-container .controls-container .swap-btn,.tas-videocall-container .controls-container .pip-btn,.tas-videocall-container .controls-container .mute-btn{width:60px;height:60px;border-radius:50%;display:flex;align-items:center;justify-content:center;font-size:24px;border:none;box-shadow:0 4px 6px #0000004d;transition:all .2s ease}.tas-videocall-container .controls-container .hangup-btn i,.tas-videocall-container .controls-container .swap-btn i,.tas-videocall-container .controls-container .pip-btn i,.tas-videocall-container .controls-container .mute-btn i{color:#fff}.tas-videocall-container .controls-container .hangup-btn{background:#dc3545}.tas-videocall-container .controls-container .hangup-btn:hover{background:#c82333;transform:scale(1.05)}.tas-videocall-container .controls-container .swap-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .swap-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .pip-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .pip-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .mute-btn{background:rgba(255,255,255,.2)}.tas-videocall-container .controls-container .mute-btn:hover{background:rgba(255,255,255,.35);transform:scale(1.05)}.tas-videocall-container .controls-container .mute-btn.muted{background:#f39c12}.tas-videocall-container .controls-container .mute-btn.muted:hover{background:#e67e22}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.NgbActiveModal }, { type: i2.TasService }]; }, propDecorators: { sessionId: [{
+                type: Input
+            }], token: [{
+                type: Input
+            }], isReturningFromPip: [{
+                type: Input
+            }], publisherContainer: [{
+                type: ViewChild,
+                args: ["publisherContainer"]
+            }], subscriberContainer: [{
+                type: ViewChild,
+                args: ["subscriberContainer"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tas-videocall.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/tas-videocall/tas-videocall.component.ts","../../../../../src/lib/components/tas-videocall/tas-videocall.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  OnDestroy,\n  Input,\n  ViewChild,\n  ElementRef,\n  AfterViewInit,\n} from \"@angular/core\";\nimport { NgbActiveModal } from \"@ng-bootstrap/ng-bootstrap\";\nimport { TasService, CallState, ViewMode } from \"../../services/tas.service\";\nimport { Subscription } from \"rxjs\";\nimport interact from \"interactjs\";\n\n@Component({\n  selector: \"tas-videocall\",\n  templateUrl: \"./tas-videocall.component.html\",\n  styleUrls: [\"./tas-videocall.component.scss\"],\n})\nexport class TasVideocallComponent implements OnInit, OnDestroy, AfterViewInit {\n  @Input() sessionId!: string;\n  @Input() token!: string;\n  @Input() isReturningFromPip: boolean = false;\n\n  @ViewChild(\"publisherContainer\") publisherContainer!: ElementRef;\n  @ViewChild(\"subscriberContainer\") subscriberContainer!: ElementRef;\n\n  public isPublisherSmall = true;\n  public callState = CallState.IDLE;\n  public isMuted = false;\n\n  private subscriptions = new Subscription();\n\n  constructor(\n    public activeModal: NgbActiveModal,\n    private tasService: TasService\n  ) {}\n\n  ngOnInit(): void {\n    this.setupSubscriptions();\n    this.initializeCall();\n  }\n\n  ngAfterViewInit(): void {\n    this.initInteract();\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n\n    if (!this.tasService.isPipMode()) {\n      this.tasService.disconnectSession();\n    }\n\n    interact(\".publisher-view\").unset();\n  }\n\n  // Public Methods\n  hangUp(): void {\n    this.tasService.disconnectSession();\n  }\n\n  toggleMute(): void {\n    this.tasService.toggleMute();\n  }\n\n  minimize(): void {\n    this.tasService.moveMainVideoTo(\"pip-main-video\");\n    setTimeout(() => this.tasService.enterPipMode(), 50);\n  }\n\n  toggleSwap(): void {\n    this.isPublisherSmall = !this.isPublisherSmall;\n    this.resetVideoPositions();\n    setTimeout(() => this.initInteract());\n  }\n\n  onDoubleClick(): void {\n    this.toggleSwap();\n  }\n\n  // Private Methods\n  private setupSubscriptions(): void {\n    this.subscriptions.add(\n      this.tasService.callState$.subscribe((state) => {\n        this.callState = state;\n        if (state === CallState.DISCONNECTED) {\n          this.activeModal.close(\"hangup\");\n        }\n      })\n    );\n\n    this.subscriptions.add(\n      this.tasService.viewMode$.subscribe((mode) => {\n        if (mode === ViewMode.PIP) {\n          this.activeModal.close(\"pip\");\n        }\n      })\n    );\n\n    this.subscriptions.add(\n      this.tasService.isMuted$.subscribe((muted) => {\n        this.isMuted = muted;\n      })\n    );\n  }\n\n  private initializeCall(): void {\n    if (this.isReturningFromPip) {\n      setTimeout(() => this.tasService.moveVideosToFullscreen(), 100);\n    } else if (this.sessionId && this.token) {\n      this.tasService\n        .connectSession(\n          this.sessionId,\n          this.token,\n          \"publisher-container\",\n          \"subscriber-container\"\n        )\n        .catch((err) => {\n          console.error(\"Error connecting to video call:\", err);\n        });\n    }\n  }\n\n  private resetVideoPositions(): void {\n    const publisherEl = this.publisherContainer?.nativeElement as HTMLElement;\n    const subscriberEl = this.subscriberContainer?.nativeElement as HTMLElement;\n\n    if (publisherEl) {\n      publisherEl.removeAttribute(\"style\");\n      publisherEl.removeAttribute(\"data-x\");\n      publisherEl.removeAttribute(\"data-y\");\n    }\n\n    if (subscriberEl) {\n      subscriberEl.removeAttribute(\"style\");\n      subscriberEl.removeAttribute(\"data-x\");\n      subscriberEl.removeAttribute(\"data-y\");\n    }\n  }\n\n  private initInteract(): void {\n    interact(\".publisher-view\").unset();\n\n    interact(\".publisher-view\")\n      .draggable({\n        inertia: true,\n        modifiers: [\n          interact.modifiers.restrictRect({\n            restriction: \"parent\",\n            endOnly: true,\n          }),\n        ],\n        autoScroll: true,\n        listeners: {\n          move: (event) => {\n            const target = event.target;\n            const x =\n              (parseFloat(target.getAttribute(\"data-x\")) || 0) + event.dx;\n            const y =\n              (parseFloat(target.getAttribute(\"data-y\")) || 0) + event.dy;\n\n            target.style.transform = `translate(${x}px, ${y}px)`;\n            target.setAttribute(\"data-x\", String(x));\n            target.setAttribute(\"data-y\", String(y));\n          },\n        },\n      })\n      .resizable({\n        edges: { left: false, right: true, bottom: true, top: false },\n        listeners: {\n          move: (event) => {\n            const target = event.target;\n            let x = parseFloat(target.getAttribute(\"data-x\")) || 0;\n            let y = parseFloat(target.getAttribute(\"data-y\")) || 0;\n\n            target.style.width = `${event.rect.width}px`;\n            target.style.height = `${event.rect.height}px`;\n\n            x += event.deltaRect.left;\n            y += event.deltaRect.top;\n\n            target.style.transform = `translate(${x}px, ${y}px)`;\n            target.setAttribute(\"data-x\", String(x));\n            target.setAttribute(\"data-y\", String(y));\n          },\n        },\n        modifiers: [\n          interact.modifiers.restrictEdges({ outer: \"parent\" }),\n          interact.modifiers.restrictSize({ min: { width: 150, height: 100 } }),\n          interact.modifiers.aspectRatio({ ratio: \"preserve\" }),\n        ],\n        inertia: true,\n      });\n  }\n}\n","<div class=\"tas-videocall-container\">\n  <div\n    id=\"subscriber-container\"\n    [class.subscriber-view]=\"isPublisherSmall\"\n    [class.publisher-view]=\"!isPublisherSmall\"\n    #subscriberContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div\n    id=\"publisher-container\"\n    [class.publisher-view]=\"isPublisherSmall\"\n    [class.subscriber-view]=\"!isPublisherSmall\"\n    #publisherContainer\n    (dblclick)=\"onDoubleClick()\"\n  ></div>\n\n  <div class=\"controls-container\">\n    <button class=\"btn swap-btn\" (click)=\"toggleSwap()\" title=\"Cambiar vista\">\n      <i class=\"fa fa-refresh\"></i>\n    </button>\n    <button\n      class=\"btn pip-btn\"\n      (click)=\"minimize()\"\n      title=\"Minimizar (Picture in Picture)\"\n    >\n      <i class=\"fa fa-compress\"></i>\n    </button>\n    <button\n      class=\"btn mute-btn\"\n      [class.muted]=\"isMuted\"\n      (click)=\"toggleMute()\"\n      [title]=\"isMuted ? 'Activar micrófono' : 'Silenciar micrófono'\"\n    >\n      <i\n        class=\"fa\"\n        [class.fa-microphone]=\"!isMuted\"\n        [class.fa-microphone-slash]=\"isMuted\"\n      ></i>\n    </button>\n    <button class=\"btn hangup-btn\" (click)=\"hangUp()\" title=\"Colgar\">\n      <i class=\"fa fa-phone\" style=\"transform: rotate(135deg)\"></i>\n    </button>\n  </div>\n</div>\n"]}

package/esm2020/lib/interfaces/tas.interfaces.mjs

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

package/esm2020/lib/services/tas.service.mjs

@@ -0,0 +1,265 @@
+import { Injectable, Inject, Optional } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { catchError, map } from "rxjs/operators";
+import * as OT from "@opentok/client";
+import { TAS_CONFIG, TAS_HTTP_CLIENT, } from "../tas.config";
+import * as i0 from "@angular/core";
+export var CallState;
+(function (CallState) {
+    CallState["IDLE"] = "IDLE";
+    CallState["CONNECTING"] = "CONNECTING";
+    CallState["CONNECTED"] = "CONNECTED";
+    CallState["DISCONNECTED"] = "DISCONNECTED";
+    CallState["ERROR"] = "ERROR";
+})(CallState || (CallState = {}));
+export var ViewMode;
+(function (ViewMode) {
+    ViewMode["FULLSCREEN"] = "FULLSCREEN";
+    ViewMode["PIP"] = "PIP";
+})(ViewMode || (ViewMode = {}));
+export class TasService {
+    constructor(config, httpClient) {
+        this.config = config;
+        this.httpClient = httpClient;
+        this.session = null;
+        this.publisher = null;
+        this.subscribers = [];
+        this.callStateSubject = new BehaviorSubject(CallState.IDLE);
+        this.callState$ = this.callStateSubject.asObservable();
+        this.viewModeSubject = new BehaviorSubject(ViewMode.FULLSCREEN);
+        this.viewMode$ = this.viewModeSubject.asObservable();
+        this.isMutedSubject = new BehaviorSubject(false);
+        this.isMuted$ = this.isMutedSubject.asObservable();
+        // Session info for PiP mode restoration
+        this.currentSessionId = null;
+        this.currentToken = null;
+        if (!this.config || !this.httpClient) {
+            console.warn("TasService: Configuration not provided. Make sure to use TasModule.forRoot()");
+        }
+    }
+    // Getters
+    get currentSession() {
+        return this.session;
+    }
+    get currentPublisher() {
+        return this.publisher;
+    }
+    get currentSubscribers() {
+        return this.subscribers;
+    }
+    get sessionId() {
+        return this.currentSessionId;
+    }
+    get token() {
+        return this.currentToken;
+    }
+    get isMuted() {
+        return this.isMutedSubject.getValue();
+    }
+    // View Mode Methods
+    setViewMode(mode) {
+        this.viewModeSubject.next(mode);
+    }
+    enterPipMode() {
+        this.viewModeSubject.next(ViewMode.PIP);
+    }
+    exitPipMode() {
+        this.viewModeSubject.next(ViewMode.FULLSCREEN);
+    }
+    isPipMode() {
+        return this.viewModeSubject.getValue() === ViewMode.PIP;
+    }
+    // Audio Control
+    toggleMute() {
+        if (this.publisher) {
+            const newMuteState = !this.isMutedSubject.getValue();
+            this.publisher.publishAudio(!newMuteState);
+            this.isMutedSubject.next(newMuteState);
+        }
+    }
+    setMute(muted) {
+        if (this.publisher) {
+            this.publisher.publishAudio(!muted);
+            this.isMutedSubject.next(muted);
+        }
+    }
+    // Session Management
+    disconnectSession() {
+        if (this.session) {
+            this.session.disconnect();
+            this.session = null;
+        }
+        this.publisher = null;
+        this.subscribers = [];
+        this.currentSessionId = null;
+        this.currentToken = null;
+        this.isMutedSubject.next(false);
+        this.viewModeSubject.next(ViewMode.FULLSCREEN);
+        this.callStateSubject.next(CallState.DISCONNECTED);
+    }
+    isCallActive() {
+        return this.callStateSubject.getValue() === CallState.CONNECTED;
+    }
+    // API Methods
+    createRoom(payload) {
+        if (!this.config || !this.httpClient) {
+            throw new Error("TasService not configured. Use TasModule.forRoot()");
+        }
+        const url = `${this.config.apiBaseUrl}/v2/room`;
+        return this.httpClient.post(url, payload).pipe(map((response) => response), catchError((error) => {
+            console.error("TAS Service: createRoom failed", error);
+            throw error;
+        }));
+    }
+    generateToken(payload) {
+        if (!this.config || !this.httpClient) {
+            throw new Error("TasService not configured. Use TasModule.forRoot()");
+        }
+        const url = `${this.config.apiBaseUrl}/v2/room/token`;
+        return this.httpClient.post(url, payload).pipe(map((response) => response), catchError((error) => {
+            console.error("TAS Service: generateToken failed", error);
+            throw error;
+        }));
+    }
+    /**
+     * Connects to a TokBox video session
+     */
+    connectSession(sessionId, token, publisherElement, subscriberElement) {
+        this.callStateSubject.next(CallState.CONNECTING);
+        this.currentSessionId = sessionId;
+        this.currentToken = token;
+        return new Promise((resolve, reject) => {
+            if (!this.config) {
+                this.callStateSubject.next(CallState.ERROR);
+                reject(new Error("TasService not configured. Use TasModule.forRoot()"));
+                return;
+            }
+            if (!OT.checkSystemRequirements()) {
+                this.callStateSubject.next(CallState.ERROR);
+                reject(new Error("Browser not compatible with TokBox"));
+                return;
+            }
+            this.session = OT.initSession(this.config.tokBoxApiKey, sessionId);
+            // Handle new streams (remote participants joining)
+            this.session.on("streamCreated", (event) => {
+                const subscriber = this.session?.subscribe(event.stream, subscriberElement, {
+                    insertMode: "append",
+                    width: "100%",
+                    height: "100%",
+                }, (error) => {
+                    if (error) {
+                        console.error("Error subscribing to stream:", error);
+                    }
+                });
+                if (subscriber) {
+                    this.subscribers.push(subscriber);
+                }
+            });
+            // Handle streams ending (remote participants leaving)
+            this.session.on("streamDestroyed", (event) => {
+                this.subscribers = this.subscribers.filter((sub) => sub.stream?.streamId !== event.stream.streamId);
+            });
+            // Handle session disconnection
+            this.session.on("sessionDisconnected", () => {
+                this.callStateSubject.next(CallState.DISCONNECTED);
+            });
+            // Connect to session
+            this.session.connect(token, (error) => {
+                if (error) {
+                    console.error("Error connecting to session:", error);
+                    this.callStateSubject.next(CallState.ERROR);
+                    reject(error);
+                    return;
+                }
+                // Initialize publisher (local video)
+                this.publisher = OT.initPublisher(publisherElement, {
+                    insertMode: "append",
+                    width: "100%",
+                    height: "100%",
+                }, (err) => {
+                    if (err) {
+                        console.error("Error initializing publisher:", err);
+                        this.callStateSubject.next(CallState.ERROR);
+                        reject(err);
+                        return;
+                    }
+                    // Publish to session
+                    this.session?.publish(this.publisher, (pubErr) => {
+                        if (pubErr) {
+                            console.error("Error publishing stream:", pubErr);
+                            this.callStateSubject.next(CallState.ERROR);
+                            reject(pubErr);
+                        }
+                        else {
+                            this.callStateSubject.next(CallState.CONNECTED);
+                            resolve();
+                        }
+                    });
+                });
+            });
+        });
+    }
+    // Video Element Movement Methods
+    movePublisherTo(newContainerId) {
+        if (!this.publisher)
+            return;
+        const publisherElement = this.publisher.element;
+        const newContainer = document.getElementById(newContainerId);
+        if (publisherElement && newContainer) {
+            newContainer.appendChild(publisherElement);
+        }
+    }
+    moveSubscribersTo(newContainerId) {
+        const newContainer = document.getElementById(newContainerId);
+        if (!newContainer)
+            return;
+        this.subscribers.forEach((subscriber) => {
+            const subscriberElement = subscriber.element;
+            if (subscriberElement) {
+                newContainer.appendChild(subscriberElement);
+            }
+        });
+    }
+    /**
+     * Moves the main video (subscriber if available, otherwise publisher) to a container.
+     * Used for PiP mode to show only one video.
+     */
+    moveMainVideoTo(newContainerId) {
+        const newContainer = document.getElementById(newContainerId);
+        if (!newContainer)
+            return;
+        // Prefer remote video (subscriber) as main
+        if (this.subscribers.length > 0 && this.subscribers[0].element) {
+            newContainer.appendChild(this.subscribers[0].element);
+            return;
+        }
+        // Fall back to local video (publisher)
+        if (this.publisher?.element) {
+            newContainer.appendChild(this.publisher.element);
+        }
+    }
+    /**
+     * Moves videos back to fullscreen containers
+     */
+    moveVideosToFullscreen() {
+        this.moveSubscribersTo("subscriber-container");
+        this.movePublisherTo("publisher-container");
+    }
+}
+TasService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, deps: [{ token: TAS_CONFIG, optional: true }, { token: TAS_HTTP_CLIENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TasService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TAS_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TAS_HTTP_CLIENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tas.service.js","sourceRoot":"","sources":["../../../../src/lib/services/tas.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, Optional } from \"@angular/core\";\nimport { BehaviorSubject, Observable } from \"rxjs\";\nimport { catchError, map } from \"rxjs/operators\";\nimport * as OT from \"@opentok/client\";\nimport {\n  TAS_CONFIG,\n  TAS_HTTP_CLIENT,\n  TasConfig,\n  TasHttpClient,\n} from \"../tas.config\";\nimport {\n  CreateRoomRequest,\n  CreateRoomResponse,\n  GenerateTokenRequest,\n  GenerateTokenResponse,\n} from \"../interfaces/tas.interfaces\";\n\nexport enum CallState {\n  IDLE = \"IDLE\",\n  CONNECTING = \"CONNECTING\",\n  CONNECTED = \"CONNECTED\",\n  DISCONNECTED = \"DISCONNECTED\",\n  ERROR = \"ERROR\",\n}\n\nexport enum ViewMode {\n  FULLSCREEN = \"FULLSCREEN\",\n  PIP = \"PIP\",\n}\n\n@Injectable({ providedIn: \"root\" })\nexport class TasService {\n  private session: OT.Session | null = null;\n  private publisher: OT.Publisher | null = null;\n  private subscribers: OT.Subscriber[] = [];\n\n  private callStateSubject = new BehaviorSubject<CallState>(CallState.IDLE);\n  public callState$ = this.callStateSubject.asObservable();\n\n  private viewModeSubject = new BehaviorSubject<ViewMode>(ViewMode.FULLSCREEN);\n  public viewMode$ = this.viewModeSubject.asObservable();\n\n  private isMutedSubject = new BehaviorSubject<boolean>(false);\n  public isMuted$ = this.isMutedSubject.asObservable();\n\n  // Session info for PiP mode restoration\n  private currentSessionId: string | null = null;\n  private currentToken: string | null = null;\n\n  constructor(\n    @Optional() @Inject(TAS_CONFIG) private config: TasConfig | null,\n    @Optional() @Inject(TAS_HTTP_CLIENT) private httpClient: TasHttpClient | null\n  ) {\n    if (!this.config || !this.httpClient) {\n      console.warn(\n        \"TasService: Configuration not provided. Make sure to use TasModule.forRoot()\"\n      );\n    }\n  }\n\n  // Getters\n  public get currentSession(): OT.Session | null {\n    return this.session;\n  }\n\n  public get currentPublisher(): OT.Publisher | null {\n    return this.publisher;\n  }\n\n  public get currentSubscribers(): OT.Subscriber[] {\n    return this.subscribers;\n  }\n\n  public get sessionId(): string | null {\n    return this.currentSessionId;\n  }\n\n  public get token(): string | null {\n    return this.currentToken;\n  }\n\n  public get isMuted(): boolean {\n    return this.isMutedSubject.getValue();\n  }\n\n  // View Mode Methods\n  public setViewMode(mode: ViewMode): void {\n    this.viewModeSubject.next(mode);\n  }\n\n  public enterPipMode(): void {\n    this.viewModeSubject.next(ViewMode.PIP);\n  }\n\n  public exitPipMode(): void {\n    this.viewModeSubject.next(ViewMode.FULLSCREEN);\n  }\n\n  public isPipMode(): boolean {\n    return this.viewModeSubject.getValue() === ViewMode.PIP;\n  }\n\n  // Audio Control\n  public toggleMute(): void {\n    if (this.publisher) {\n      const newMuteState = !this.isMutedSubject.getValue();\n      this.publisher.publishAudio(!newMuteState);\n      this.isMutedSubject.next(newMuteState);\n    }\n  }\n\n  public setMute(muted: boolean): void {\n    if (this.publisher) {\n      this.publisher.publishAudio(!muted);\n      this.isMutedSubject.next(muted);\n    }\n  }\n\n  // Session Management\n  public disconnectSession(): void {\n    if (this.session) {\n      this.session.disconnect();\n      this.session = null;\n    }\n    this.publisher = null;\n    this.subscribers = [];\n    this.currentSessionId = null;\n    this.currentToken = null;\n    this.isMutedSubject.next(false);\n    this.viewModeSubject.next(ViewMode.FULLSCREEN);\n    this.callStateSubject.next(CallState.DISCONNECTED);\n  }\n\n  public isCallActive(): boolean {\n    return this.callStateSubject.getValue() === CallState.CONNECTED;\n  }\n\n  // API Methods\n  public createRoom(\n    payload: CreateRoomRequest\n  ): Observable<CreateRoomResponse> {\n    if (!this.config || !this.httpClient) {\n      throw new Error(\"TasService not configured. Use TasModule.forRoot()\");\n    }\n    const url = `${this.config.apiBaseUrl}/v2/room`;\n    return this.httpClient.post<CreateRoomResponse>(url, payload).pipe(\n      map((response) => response as CreateRoomResponse),\n      catchError((error) => {\n        console.error(\"TAS Service: createRoom failed\", error);\n        throw error;\n      })\n    );\n  }\n\n  public generateToken(\n    payload: GenerateTokenRequest\n  ): Observable<GenerateTokenResponse> {\n    if (!this.config || !this.httpClient) {\n      throw new Error(\"TasService not configured. Use TasModule.forRoot()\");\n    }\n    const url = `${this.config.apiBaseUrl}/v2/room/token`;\n    return this.httpClient.post<GenerateTokenResponse>(url, payload).pipe(\n      map((response: any) => response as GenerateTokenResponse),\n      catchError((error) => {\n        console.error(\"TAS Service: generateToken failed\", error);\n        throw error;\n      })\n    );\n  }\n\n  /**\n   * Connects to a TokBox video session\n   */\n  public connectSession(\n    sessionId: string,\n    token: string,\n    publisherElement: string,\n    subscriberElement: string\n  ): Promise<void> {\n    this.callStateSubject.next(CallState.CONNECTING);\n    this.currentSessionId = sessionId;\n    this.currentToken = token;\n\n    return new Promise((resolve, reject) => {   \n      if (!this.config) {\n        this.callStateSubject.next(CallState.ERROR);\n        reject(new Error(\"TasService not configured. Use TasModule.forRoot()\"));\n        return;\n      }\n\n      if (!OT.checkSystemRequirements()) {\n        this.callStateSubject.next(CallState.ERROR);\n        reject(new Error(\"Browser not compatible with TokBox\"));\n        return;\n      }\n\n      this.session = OT.initSession(this.config.tokBoxApiKey, sessionId);\n\n      // Handle new streams (remote participants joining)\n      this.session.on(\"streamCreated\", (event) => {\n        const subscriber = this.session?.subscribe(\n          event.stream,\n          subscriberElement,\n          {\n            insertMode: \"append\",\n            width: \"100%\",\n            height: \"100%\",\n          },\n          (error) => {\n            if (error) {\n              console.error(\"Error subscribing to stream:\", error);\n            }\n          }\n        );\n        if (subscriber) {\n          this.subscribers.push(subscriber);\n        }\n      });\n\n      // Handle streams ending (remote participants leaving)\n      this.session.on(\"streamDestroyed\", (event) => {\n        this.subscribers = this.subscribers.filter(\n          (sub) => sub.stream?.streamId !== event.stream.streamId\n        );\n      });\n\n      // Handle session disconnection\n      this.session.on(\"sessionDisconnected\", () => {\n        this.callStateSubject.next(CallState.DISCONNECTED);\n      });\n\n      // Connect to session\n      this.session.connect(token, (error) => {\n        if (error) {\n          console.error(\"Error connecting to session:\", error);\n          this.callStateSubject.next(CallState.ERROR);\n          reject(error);\n          return;\n        }\n\n        // Initialize publisher (local video)\n        this.publisher = OT.initPublisher(\n          publisherElement,\n          {\n            insertMode: \"append\",\n            width: \"100%\",\n            height: \"100%\",\n          },\n          (err) => {\n            if (err) {\n              console.error(\"Error initializing publisher:\", err);\n              this.callStateSubject.next(CallState.ERROR);\n              reject(err);\n              return;\n            }\n\n            // Publish to session\n            this.session?.publish(this.publisher!, (pubErr) => {\n              if (pubErr) {\n                console.error(\"Error publishing stream:\", pubErr);\n                this.callStateSubject.next(CallState.ERROR);\n                reject(pubErr);\n              } else {\n                this.callStateSubject.next(CallState.CONNECTED);\n                resolve();\n              }\n            });\n          }\n        );\n      });\n    });\n  }\n\n  // Video Element Movement Methods\n  public movePublisherTo(newContainerId: string): void {\n    if (!this.publisher) return;\n\n    const publisherElement = this.publisher.element;\n    const newContainer = document.getElementById(newContainerId);\n\n    if (publisherElement && newContainer) {\n      newContainer.appendChild(publisherElement);\n    }\n  }\n\n  public moveSubscribersTo(newContainerId: string): void {\n    const newContainer = document.getElementById(newContainerId);\n    if (!newContainer) return;\n\n    this.subscribers.forEach((subscriber) => {\n      const subscriberElement = subscriber.element;\n      if (subscriberElement) {\n        newContainer.appendChild(subscriberElement);\n      }\n    });\n  }\n\n  /**\n   * Moves the main video (subscriber if available, otherwise publisher) to a container.\n   * Used for PiP mode to show only one video.\n   */\n  public moveMainVideoTo(newContainerId: string): void {\n    const newContainer = document.getElementById(newContainerId);\n    if (!newContainer) return;\n\n    // Prefer remote video (subscriber) as main\n    if (this.subscribers.length > 0 && this.subscribers[0].element) {\n      newContainer.appendChild(this.subscribers[0].element);\n      return;\n    }\n\n    // Fall back to local video (publisher)\n    if (this.publisher?.element) {\n      newContainer.appendChild(this.publisher.element);\n    }\n  }\n\n  /**\n   * Moves videos back to fullscreen containers\n   */\n  public moveVideosToFullscreen(): void {\n    this.moveSubscribersTo(\"subscriber-container\");\n    this.movePublisherTo(\"publisher-container\");\n  }\n}\n"]}

package/esm2020/lib/tas.config.mjs

@@ -0,0 +1,14 @@
+import { InjectionToken } from "@angular/core";
+/**
+ * Injection token for TAS configuration
+ */
+export const TAS_CONFIG = new InjectionToken("TAS_CONFIG");
+/**
+ * Injection token for HTTP client
+ */
+export const TAS_HTTP_CLIENT = new InjectionToken("TAS_HTTP_CLIENT");
+/**
+ * Injection token for user data provider
+ */
+export const TAS_USER_DATA_PROVIDER = new InjectionToken("TAS_USER_DATA_PROVIDER");
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tas.module.mjs

@@ -0,0 +1,73 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { NgbModalModule } from "@ng-bootstrap/ng-bootstrap";
+import { TasButtonComponent } from "./components/tas-btn/tas-btn.component";
+import { TasVideocallComponent } from "./components/tas-videocall/tas-videocall.component";
+import { TasFloatingCallComponent } from "./components/tas-floating-call/tas-floating-call.component";
+import { TAS_CONFIG, TAS_HTTP_CLIENT, TAS_USER_DATA_PROVIDER, } from "./tas.config";
+import * as i0 from "@angular/core";
+export class TasModule {
+    /**
+     * Use this method in your app module to configure the TAS SDK
+     *
+     * @example
+     * ```typescript
+     * TasModule.forRoot({
+     *   config: {
+     *     tokBoxApiKey: environment.tokBox,
+     *     apiBaseUrl: environment.apiUrl
+     *   },
+     *   httpClient: MyHttpClientAdapter,
+     *   userDataProvider: MyUserDataProvider
+     * })
+     * ```
+     */
+    static forRoot(moduleConfig) {
+        const providers = [
+            {
+                provide: TAS_CONFIG,
+                useValue: moduleConfig.config,
+            },
+        ];
+        if (moduleConfig.httpClient) {
+            providers.push({
+                provide: TAS_HTTP_CLIENT,
+                useClass: moduleConfig.httpClient,
+            });
+        }
+        if (moduleConfig.userDataProvider) {
+            providers.push({
+                provide: TAS_USER_DATA_PROVIDER,
+                useClass: moduleConfig.userDataProvider,
+            });
+        }
+        return {
+            ngModule: TasModule,
+            providers,
+        };
+    }
+}
+TasModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TasModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasModule, declarations: [TasButtonComponent,
+        TasVideocallComponent,
+        TasFloatingCallComponent], imports: [CommonModule, NgbModalModule], exports: [TasButtonComponent,
+        TasVideocallComponent,
+        TasFloatingCallComponent] });
+TasModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasModule, imports: [[CommonModule, NgbModalModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TasModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        TasButtonComponent,
+                        TasVideocallComponent,
+                        TasFloatingCallComponent,
+                    ],
+                    imports: [CommonModule, NgbModalModule],
+                    exports: [
+                        TasButtonComponent,
+                        TasVideocallComponent,
+                        TasFloatingCallComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,16 @@
+/*
+ * Public API Surface of tas-uell-sdk
+ */
+// Module
+export * from "./lib/tas.module";
+// Configuration
+export * from "./lib/tas.config";
+// Services
+export * from "./lib/services/tas.service";
+// Components
+export * from "./lib/components/tas-btn/tas-btn.component";
+export * from "./lib/components/tas-videocall/tas-videocall.component";
+export * from "./lib/components/tas-floating-call/tas-floating-call.component";
+// Interfaces
+export * from "./lib/interfaces/tas.interfaces";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsU0FBUztBQUNULGNBQWMsa0JBQWtCLENBQUM7QUFFakMsZ0JBQWdCO0FBQ2hCLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsV0FBVztBQUNYLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsYUFBYTtBQUNiLGNBQWMsNENBQTRDLENBQUM7QUFDM0QsY0FBYyx3REFBd0QsQ0FBQztBQUN2RSxjQUFjLGdFQUFnRSxDQUFDO0FBRS9FLGFBQWE7QUFDYixjQUFjLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiB0YXMtdWVsbC1zZGtcbiAqL1xuXG4vLyBNb2R1bGVcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi90YXMubW9kdWxlXCI7XG5cbi8vIENvbmZpZ3VyYXRpb25cbmV4cG9ydCAqIGZyb20gXCIuL2xpYi90YXMuY29uZmlnXCI7XG5cbi8vIFNlcnZpY2VzXG5leHBvcnQgKiBmcm9tIFwiLi9saWIvc2VydmljZXMvdGFzLnNlcnZpY2VcIjtcblxuLy8gQ29tcG9uZW50c1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NvbXBvbmVudHMvdGFzLWJ0bi90YXMtYnRuLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NvbXBvbmVudHMvdGFzLXZpZGVvY2FsbC90YXMtdmlkZW9jYWxsLmNvbXBvbmVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vbGliL2NvbXBvbmVudHMvdGFzLWZsb2F0aW5nLWNhbGwvdGFzLWZsb2F0aW5nLWNhbGwuY29tcG9uZW50XCI7XG5cbi8vIEludGVyZmFjZXNcbmV4cG9ydCAqIGZyb20gXCIuL2xpYi9pbnRlcmZhY2VzL3Rhcy5pbnRlcmZhY2VzXCI7XG4iXX0=