@js-toolkit/web-utils 1.66.0 → 1.68.0

package/serviceWorker/ServiceWorkerInstaller.js

@@ -1 +1,112 @@
-import{EventEmitter}from"@js-toolkit/utils/EventEmitter";import{ErrorCompat}from"@js-toolkit/utils/ErrorCompat";import{onPageReady}from"../onPageReady";import{isLocalhost}from"./utils";export class ServiceWorkerUnavailableError extends ErrorCompat{constructor(){super(ServiceWorkerUnavailableError,"ServiceWorker is not available",{name:"ServiceWorkerUnavailableError"})}}export class ServiceWorkerInstaller extends EventEmitter{static isAvailable(){return"serviceWorker"in navigator}registration;cancelDefferedRegister;constructor(){super()}register(r,e){if(!ServiceWorkerInstaller.isAvailable())throw new ServiceWorkerUnavailableError;const{deffered:t,...i}=e??{},o=async()=>{try{if(isLocalhost()){const e=await fetch(r);if(!e.ok)throw new Error(`No service worker found at '${e.url}'.`,{cause:`Response: ${e.status} ${e.statusText}`})}const e=await navigator.serviceWorker.register(r,i);this.registration=e,this.emit("registered",{registration:e}),e.onupdatefound=()=>{const r=e.installing;null!=r&&(r.onstatechange=()=>{"installed"===r.state&&(navigator.serviceWorker.controller?this.emit("updatePending",{registration:e}):this.emit("updated",{registration:e}))},r.onerror=r=>{const e=new Error("Error during service worker installation",{cause:r});this.emit("error",{error:e})})}}catch(r){const e=new Error("Error during service worker registration",{cause:r});this.emit("error",{error:e})}};t?this.cancelDefferedRegister=onPageReady(o,"number"==typeof t?{timeout:t}:void 0):o()}unregister(){this.cancelDefferedRegister&&this.cancelDefferedRegister(),this.registration?.unregister().catch(r=>{const e=new Error("Error during service worker unregister",{cause:r});this.emit("error",{error:e})})}destroy(){this.cancelDefferedRegister&&this.cancelDefferedRegister(),this.removeAllListeners()}[Symbol.dispose](){this.destroy()}}
+/* eslint-disable @typescript-eslint/no-misused-promises */
+/* eslint-disable max-classes-per-file */
+/* eslint-disable @typescript-eslint/no-namespace */
+import { EventEmitter } from '@js-toolkit/utils/EventEmitter';
+import { ErrorCompat } from '@js-toolkit/utils/ErrorCompat';
+import { onPageReady } from '../onPageReady';
+import { isLocalhost } from './utils';
+/*
+ * https://web.dev/articles/service-workers-registration?hl=ru
+ */
+export class ServiceWorkerUnavailableError extends ErrorCompat {
+    constructor() {
+        super(ServiceWorkerUnavailableError, 'ServiceWorker is not available', {
+            name: 'ServiceWorkerUnavailableError',
+        });
+    }
+}
+export class ServiceWorkerInstaller extends EventEmitter {
+    static isAvailable() {
+        return 'serviceWorker' in navigator;
+    }
+    // private readonly logPrefix = 'SW:';
+    // private readonly options;
+    registration;
+    cancelDefferedRegister;
+    // constructor(/* options: ServiceWorkerInstaller.Options */) {
+    //   super();
+    //   // this.options = { ...options, logger: options.logger ?? console };
+    // }
+    register(swUrl, options) {
+        if (!ServiceWorkerInstaller.isAvailable()) {
+            throw new ServiceWorkerUnavailableError();
+        }
+        const { deffered, ...swOptions } = options ?? {};
+        const register = async () => {
+            try {
+                if (isLocalhost()) {
+                    // This is running on localhost. Let's check if a service worker still exists or not.
+                    const response = await fetch(swUrl);
+                    if (!response.ok) {
+                        throw new Error(`No service worker found at '${response.url}'.`, {
+                            cause: `Response: ${response.status} ${response.statusText}`,
+                        });
+                    }
+                }
+                const registration = await navigator.serviceWorker.register(swUrl, swOptions);
+                this.registration = registration;
+                this.emit('registered', { registration });
+                // https://whatwebcando.today/articles/handling-service-worker-updates/
+                registration.onupdatefound = () => {
+                    // At this point we only know the browser detected the Service Worker file change.
+                    //
+                    // Wait until the new instance is ready for activation (its state is installed).
+                    const sw = registration.installing;
+                    if (sw == null) {
+                        return;
+                    }
+                    sw.onstatechange = () => {
+                        if (sw.state === 'installed') {
+                            if (navigator.serviceWorker.controller) {
+                                // At this point, the updated precached content has been fetched,
+                                // but the previous service worker will still serve the older content (until all client tabs are closed).
+                                this.emit('updatePending', { registration });
+                            }
+                            else {
+                                // It's the first install.
+                                // At this point, everything has been precached.
+                                // It's the perfect time to display a "Content is cached for offline use." message.
+                                this.emit('updated', { registration });
+                            }
+                        }
+                    };
+                    sw.onerror = (error) => {
+                        // this.options.logger.error(this.logPrefix, 'Installing worker:', error);
+                        const nextError = new Error('Error during service worker installation', {
+                            cause: error,
+                        });
+                        this.emit('error', { error: nextError });
+                    };
+                };
+            }
+            catch (error) {
+                const nextError = new Error('Error during service worker registration', { cause: error });
+                // this.options.logger.error(this.logPrefix, getErrorMessage(nextError));
+                this.emit('error', { error: nextError });
+            }
+        };
+        if (typeof deffered === 'number' ? deffered > 0 : deffered) {
+            this.cancelDefferedRegister = onPageReady(register, typeof deffered === 'number' ? { timeout: deffered } : undefined);
+        }
+        else {
+            void register();
+        }
+    }
+    unregister() {
+        if (this.cancelDefferedRegister)
+            this.cancelDefferedRegister();
+        this.registration?.unregister().catch((error) => {
+            const nextError = new Error('Error during service worker unregister', { cause: error });
+            // this.options.logger.error(this.logPrefix, getErrorMessage(nextError));
+            this.emit('error', { error: nextError });
+        });
+    }
+    destroy() {
+        if (this.cancelDefferedRegister)
+            this.cancelDefferedRegister();
+        this.removeAllListeners();
+    }
+    [Symbol.dispose]() {
+        this.destroy();
+    }
+}

package/serviceWorker/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference lib="webworker" preserve="true" />
 export declare function isLocalhost(hostname?: string): boolean;
 /** Delete all caches that aren't named in `caches`. */
-export declare function removeUnknownCaches<T extends Record<string, string>>(expectedCaches: T): Promise<unknown>;
+export declare function removeUnknownCaches(expectedCaches: Record<string, string>): Promise<unknown>;
 export declare function addResourcesToCache(cacheName: string, resources: readonly RequestInfo[]): Promise<void>;
 interface CacheFirstOptions extends Pick<FetchEvent, 'request'> {
     readonly fallbackUrl?: string | undefined;

package/serviceWorker/utils.js

@@ -1 +1,86 @@
-import{getErrorMessage}from"@js-toolkit/utils/getErrorMessage";export function isLocalhost(e=window.location.hostname){return!("localhost"!==e&&"[::1]"!==e&&!e.match(/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/))}export function removeUnknownCaches(e){return caches.keys().then(r=>{const o=new Set(Object.values(e));return Promise.all(r.map(e=>{if(!o.has(e))return caches.delete(e)}))})}export async function addResourcesToCache(e,r){const o=await caches.open(e);await o.addAll(r)}export async function cacheFirst(e,{request:r,fallbackUrl:o,saveToCache:t,logger:n=console}){const s=await caches.open(e),c=await s.match(r);if(c)return n.debug("Found response in cache:",c),c;n.debug("No response for %s found in cache. About to fetch from network...",r.url);try{const e=await fetch(r.clone());return n.debug("Response for %s from network is: %O",r.url,e),e.status<400&&(!t||t({request:r,response:e}))?(n.debug("Caching the response to",r.url),s.put(r,e.clone()).catch(e=>{n.error(getErrorMessage(new Error(`Caching error of ${r.url}`,{cause:e})))})):n.debug("Not caching the response to",r.url),e}catch(e){const r=o&&await s.match(o);if(r)return r;throw n.error("Error in fetch handler:",e),e}}
+/// <reference lib="webworker" preserve="true" />
+import { getErrorMessage } from '@js-toolkit/utils/getErrorMessage';
+export function isLocalhost(hostname = window.location.hostname) {
+    return !!(hostname === 'localhost' ||
+        // [::1] is the IPv6 localhost address.
+        hostname === '[::1]' ||
+        // 127.0.0.1/8 is considered localhost for IPv4.
+        /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/.exec(hostname));
+}
+/** Delete all caches that aren't named in `caches`. */
+export function removeUnknownCaches(expectedCaches) {
+    return caches.keys().then((cacheNames) => {
+        const expectedCacheNamesSet = new Set(Object.values(expectedCaches));
+        return Promise.all(
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        cacheNames.map((cacheName) => {
+            if (!expectedCacheNamesSet.has(cacheName)) {
+                // If this cache name isn't present in the set of "expected" cache names, then delete it.
+                // logger.debug('Deleting out of date cache:', cacheName);
+                return caches.delete(cacheName);
+            }
+            return undefined;
+        }));
+    });
+}
+export async function addResourcesToCache(cacheName, resources) {
+    const cache = await caches.open(cacheName);
+    await cache.addAll(resources);
+}
+export async function cacheFirst(cacheName, { request, fallbackUrl, saveToCache, logger = console }) {
+    // First try to get the resource from the cache
+    const cache = await caches.open(cacheName);
+    const responseFromCache = await cache.match(request);
+    if (responseFromCache) {
+        logger.debug('Found response in cache:', responseFromCache);
+        return responseFromCache;
+    }
+    // Otherwise, if there is no entry in the cache for `request`, response will be undefined,
+    // and we need to fetch() the resource.
+    logger.debug('No response for %s found in cache. About to fetch from network...', request.url);
+    // Next try to use the preloaded response, if it's there
+    // NOTE: Chrome throws errors regarding preloadResponse, see:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1420515
+    // https://github.com/mdn/dom-examples/issues/145
+    // To avoid those errors, remove or comment out this block of preloadResponse
+    // code along with enableNavigationPreload() and the "activate" listener.
+    // const preloadResponseValue = await preloadResponse;
+    // if (preloadResponseValue) {
+    //   logger.info('using preload response', preloadResponseValue);
+    //   putInCache(request, preloadResponseValue.clone());
+    //   return preloadResponseValue;
+    // }
+    // Next try to get the resource from the network
+    // We call .clone() on the request since we might use it in a call to cache.put() later on.
+    // Both fetch() and cache.put() "consume" the request, so we need to make a copy.
+    // (see https://fetch.spec.whatwg.org/#dom-request-clone)
+    try {
+        const response = await fetch(request.clone());
+        logger.debug('Response for %s from network is: %O', request.url, response);
+        // This avoids caching responses that we know are errors (i.e. HTTP status code of 4xx or 5xx).
+        if (response.status < 400 && (!saveToCache || saveToCache({ request, response }))) {
+            // We call .clone() on the response to save a copy of it to the cache. By doing so, we get to keep
+            // the original response object which we will return back to the controlled page.
+            // (see https://fetch.spec.whatwg.org/#dom-response-clone)
+            logger.debug('Caching the response to', request.url);
+            cache.put(request, response.clone()).catch((error) => {
+                logger.error(getErrorMessage(new Error(`Caching error of ${request.url}`, { cause: error })));
+            });
+        }
+        else {
+            logger.debug('Not caching the response to', request.url);
+        }
+        return response;
+    }
+    catch (error) {
+        const fallbackResponse = fallbackUrl ? await cache.match(fallbackUrl) : undefined;
+        if (fallbackResponse) {
+            return fallbackResponse;
+        }
+        // This catch() will handle exceptions that arise from the match() or fetch() operations.
+        // Note that a HTTP error response (e.g. 404) will NOT trigger an exception.
+        // It will return a normal response object that has the appropriate error code set.
+        logger.error('Error in fetch handler:', error);
+        throw error;
+    }
+}

package/stopPropagation.d.ts

@@ -1,3 +1,3 @@
-export declare function stopPropagation<T extends {
+export declare function stopPropagation(event: {
     stopPropagation: VoidFunction;
-}>(event: T): void;
+}): void;

package/stopPropagation.js

@@ -1 +1,3 @@
-export function stopPropagation(o){o.stopPropagation()}
+export function stopPropagation(event) {
+    event.stopPropagation();
+}

package/takeScreenshot.js

@@ -1 +1,51 @@
-import{hasIn}from"@js-toolkit/utils/hasIn";export function get2dContextError(){return new Error("Failed to get canvas 2d context.")}const getDefaultWidth=t=>t instanceof HTMLVideoElement?t.videoWidth:hasIn(t,"displayWidth")?t.displayWidth:t.width instanceof SVGAnimatedLength?t.width.animVal.value:t.width,getDefaultHeight=t=>t instanceof HTMLVideoElement?t.videoHeight:hasIn(t,"displayHeight")?t.displayHeight:t.height instanceof SVGAnimatedLength?t.height.animVal.value:t.height;export function takeScreenshot(t,{width:e=getDefaultWidth(t),height:i=getDefaultHeight(t),type:n="image/jpeg",quality:a=1}={}){const o=document.createElement("canvas");o.width=e,o.height=i;const h=o.getContext("2d");if(!h)throw get2dContextError();return h.drawImage(t,0,0),o.toDataURL(n,a)}export function takeScreenshotAsync(t,{width:e=getDefaultWidth(t),height:i=getDefaultHeight(t),type:n="image/jpeg",quality:a=1}={}){return new Promise((o,h)=>{const r=document.createElement("canvas");r.width=e,r.height=i;const d=r.getContext("2d");if(!d)throw get2dContextError();d.drawImage(t,0,0),r.toBlob(t=>{null==t?h(new Error("Unable get blob")):o(t)},n,a)})}
+import { hasIn } from '@js-toolkit/utils/hasIn';
+export function get2dContextError() {
+    return new Error('Failed to get canvas 2d context.');
+}
+const getDefaultWidth = (element) => {
+    if (element instanceof HTMLVideoElement) {
+        return element.videoWidth;
+    }
+    if (hasIn(element, 'displayWidth')) {
+        return element.displayWidth;
+    }
+    return element.width instanceof SVGAnimatedLength ? element.width.animVal.value : element.width;
+};
+const getDefaultHeight = (element) => {
+    if (element instanceof HTMLVideoElement) {
+        return element.videoHeight;
+    }
+    if (hasIn(element, 'displayHeight')) {
+        return element.displayHeight;
+    }
+    return element.height instanceof SVGAnimatedLength
+        ? element.height.animVal.value
+        : element.height;
+};
+export function takeScreenshot(element, { width = getDefaultWidth(element), height = getDefaultHeight(element), type = 'image/jpeg', quality = 1, } = {}) {
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        throw get2dContextError();
+    ctx.drawImage(element, 0, 0);
+    return canvas.toDataURL(type, quality);
+}
+export function takeScreenshotAsync(element, { width = getDefaultWidth(element), height = getDefaultHeight(element), type = 'image/jpeg', quality = 1, } = {}) {
+    return new Promise((resolve, reject) => {
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            throw get2dContextError();
+        ctx.drawImage(element, 0, 0);
+        canvas.toBlob((blob) => {
+            if (blob == null)
+                reject(new Error('Unable get blob'));
+            else
+                resolve(blob);
+        }, type, quality);
+    });
+}

package/toBase64.js

@@ -1 +1,9 @@
-export function toBase64(o){const n=window.TextEncoder?Array.from((new TextEncoder).encode(o),o=>String.fromCodePoint(o)).join(""):unescape(encodeURIComponent(o));return window.btoa(n)}
+/* eslint-disable @typescript-eslint/no-deprecated */
+/* eslint-disable @typescript-eslint/strict-boolean-expressions */
+/** Safe for unicode string. */
+export function toBase64(str) {
+    const binString = window.TextEncoder
+        ? Array.from(new TextEncoder().encode(str), (byte) => String.fromCodePoint(byte)).join('')
+        : unescape(encodeURIComponent(str));
+    return window.btoa(binString);
+}

package/toLocalPoint.js

@@ -1 +1,9 @@
-export function toLocalPoint(t,n){const e="tagName"in n?n.getBoundingClientRect():n;return{x:t.clientX-e.left,y:t.clientY-e.top}}
+export function toLocalPoint(coord, targetOrClientRect) {
+    const rect = 'tagName' in targetOrClientRect
+        ? targetOrClientRect.getBoundingClientRect()
+        : targetOrClientRect;
+    return {
+        x: coord.clientX - rect.left,
+        y: coord.clientY - rect.top,
+    };
+}

package/types/index.js

@@ -1 +1,2 @@
-"use strict";
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */

package/types/refs.js

@@ -1 +1 @@
-import"@js-toolkit/utils/types";
+import '@js-toolkit/utils/types';

package/viewableTracker.js

@@ -1 +1,69 @@
-import throttleFn from"lodash.throttle";export function getViewableTracker(t,{visiblePart:e=.8,scrollThrottle:i=200,documentVisibility:n=!0,onChange:o}){const s=Math.min(+e,1);let r,l=0,c="visible"===document.visibilityState;const a=()=>{if(n&&"visible"!==document.visibilityState)return;const{top:e,bottom:i,height:l}=t.getBoundingClientRect(),c=l*s,a=e+c,d=window.innerHeight>=a&&i>c;r!==d&&(r=d,o(d))},d=()=>{const t="visible"===document.visibilityState;c!==t&&(c=t,t?(r=void 0,a()):r!==t&&o(t))},v=i&&i>0?throttleFn(a,i):()=>{n&&"visible"!==document.visibilityState||(l=window.requestAnimationFrame(a))};window.addEventListener("scroll",v,{capture:!1,passive:!0}),n&&document.addEventListener("visibilitychange",d);return{check:()=>{a(),n&&d()},destroy:()=>{cancelAnimationFrame(l),window.removeEventListener("scroll",v,{capture:!1}),document.removeEventListener("visibilitychange",d)},[Symbol.dispose](){this.destroy()}}}
+import throttleFn from 'lodash.throttle';
+export function getViewableTracker(element, { visiblePart: visiblePartOption = 0.8, scrollThrottle = 200, documentVisibility = true, onChange, }) {
+    const visiblePart = Math.min(+visiblePartOption, 1);
+    // const visiblePart = +visiblePartOption;
+    let raf = 0;
+    let lastViewable;
+    let lastDocumentViewable = document.visibilityState === 'visible';
+    const checkVisibility = () => {
+        if (documentVisibility && document.visibilityState !== 'visible')
+            return;
+        const { top, bottom, height } = element.getBoundingClientRect();
+        const visibleHeight = height * visiblePart;
+        const bottomPos = top + visibleHeight;
+        const viewable = window.innerHeight >= bottomPos && bottom > visibleHeight;
+        // console.log(bottomPos, top, bottom, visibleHeight, viewable);
+        if (lastViewable !== viewable) {
+            lastViewable = viewable;
+            onChange(viewable);
+        }
+    };
+    const checkVisibilityRaf = () => {
+        if (documentVisibility && document.visibilityState !== 'visible')
+            return;
+        raf = window.requestAnimationFrame(checkVisibility);
+    };
+    const checkDocumentVisibility = () => {
+        const viewable = document.visibilityState === 'visible';
+        if (lastDocumentViewable === viewable)
+            return;
+        lastDocumentViewable = viewable;
+        // Check if visible on page
+        if (viewable /* && visiblePart > 0 */) {
+            // Always re-check, the page size may be changed or something else.
+            lastViewable = undefined;
+            checkVisibility();
+        }
+        // Hidden tab
+        else if ( /* visiblePart <= 0 || */lastViewable !== viewable) {
+            onChange(viewable);
+        }
+    };
+    const handler = scrollThrottle > 0 ? throttleFn(checkVisibility, scrollThrottle) : checkVisibilityRaf;
+    // if (visiblePart > 0) {
+    window.addEventListener('scroll', handler, { capture: false, passive: true });
+    // }
+    if (documentVisibility) {
+        document.addEventListener('visibilitychange', checkDocumentVisibility);
+    }
+    const check = () => {
+        // if (visiblePart > 0) {
+        checkVisibility();
+        // }
+        if (documentVisibility) {
+            checkDocumentVisibility();
+        }
+    };
+    const destroy = () => {
+        cancelAnimationFrame(raf);
+        window.removeEventListener('scroll', handler, { capture: false });
+        document.removeEventListener('visibilitychange', checkDocumentVisibility);
+    };
+    return {
+        check,
+        destroy,
+        [Symbol.dispose]() {
+            this.destroy();
+        },
+    };
+}

package/webrtc/PeerConnection.js

@@ -1 +1,212 @@
-import{EventEmitter}from"@js-toolkit/utils/EventEmitter";import{getErrorMessage}from"@js-toolkit/utils/getErrorMessage";import{hasIn}from"@js-toolkit/utils/hasIn";import log from"@js-toolkit/utils/log";import*as sdpUtils from"./sdputils";export class PeerConnection extends EventEmitter{options;get Events(){return PeerConnection.Events}logger;pc;constructor(e={}){super(),this.options=e,this.logger=e.logger??log.getLogger("PeerConnection"),this.pc=this.createPC()}clear(){this.pc.onsignalingstatechange=null,this.pc.onconnectionstatechange=null,this.pc.oniceconnectionstatechange=null,this.pc.ontrack=null,this.pc.onnegotiationneeded=null,this.pc.onicecandidate=null,this.pc.onicecandidateerror=null}createPC(){const e=new RTCPeerConnection(this.options.rtc);e.onsignalingstatechange=()=>{this.logger.debug(`Signaling state changed to: ${e.signalingState}`),"closed"===e.signalingState&&(this.emit(this.Events.Closed),this.clear())};const t=e=>{this.logger.debug(`Connection state changed to: ${e}`),"connected"===e?this.emit(this.Events.Connected):"disconnected"===e&&this.emit(this.Events.Disconnected)};return hasIn(RTCPeerConnection.prototype,"onconnectionstatechange")?e.onconnectionstatechange=()=>t(e.connectionState):e.oniceconnectionstatechange=()=>t(e.iceConnectionState),e.ontrack=({streams:e,track:t})=>{if(this.logger.debug("Remote stream received.",e.length,t.kind),0===e.length)return;const[n]=e;n.onremovetrack=()=>{this.logger.debug("onremovetrack"),this.emit(this.Events.RemoteStreamChanged,n)},n.onaddtrack=()=>{this.logger.debug("onaddtrack"),this.emit(this.Events.RemoteStreamChanged,n)},this.emit(this.Events.RemoteStreamChanged,n)},e.onnegotiationneeded=()=>{const{iceConnectionState:t}=e;"connected"!==t&&"completed"!==t||(this.logger.debug("Reinitializing connection..."),this.emit(this.Events.ReinitializingConnectionRequired))},e.onicecandidate=({candidate:e})=>{e?sdpUtils.isValidIceCandidate(e)&&this.emit(this.Events.LocalIceCandidate,e):this.emit(this.Events.EndOfIceCandidates)},e.onicecandidateerror=e=>{if(e instanceof RTCPeerConnectionIceErrorEvent){const{errorCode:t,errorText:n,hostCandidate:i,url:o}=e;this.logger.warn(`ICE candidate error: errorCode=${t}, errorText=${n}, hostCandidate=${i}, url=${o}`)}else this.logger.warn(`ICE candidate error: ${getErrorMessage(e)}`)},e}async setLocalDescription(e,t){const n=sdpUtils.prepareLocalDescription(t,this.options.codecs);return await e.setLocalDescription(n),n}async setRemoteDescription(e,t){const n=sdpUtils.prepareRemoteDescription(t,this.options.codecs);return await e.setRemoteDescription(n),n}isConnected(){return"connected"===this.pc.iceConnectionState||"completed"===this.pc.iceConnectionState}isClosed(){return"closed"===this.pc.signalingState}addIceCandidate(e){return this.pc.addIceCandidate(e)}attachStream(e){const t=this.pc.getSenders(),n=t.length?e.getTracks().filter(e=>!t.find(({track:t})=>!!t&&t.id===e.id)):e.getTracks();n.length?(n.forEach(t=>this.pc.addTrack(t,e)),this.logger.debug(`Attached ${n.length} track(s) to a peer connection.`)):this.logger.debug("No tracks to attach to a peer connection.")}reattachStream(e){const t=this.pc.iceConnectionState;if("new"!==t&&"connected"!==t&&"completed"!==t)return;const n=e?e.getTracks():[];this.pc.getSenders().forEach(e=>{const{track:t}=e;!t||"ended"!==t.readyState&&n.find(e=>e.id===t.id)||(this.pc.removeTrack(e),this.logger.debug(`'${t&&t.kind}' track is removed from a peer connection.`))}),e&&this.attachStream(e)}async createOffer(){const e=await this.pc.createOffer(this.options.offerOptions);return this.setLocalDescription(this.pc,e)}async createAnswer(e){await this.setRemoteDescription(this.pc,e);const t=await this.pc.createAnswer(this.options.offerOptions);return this.setLocalDescription(this.pc,t)}applyAnswer(e){return this.setRemoteDescription(this.pc,e)}reconnect(){this.close(),this.pc=this.createPC()}close(){this.pc.close(),this.pc.onsignalingstatechange&&(this.emit(this.Events.Closed),this.clear())}destroy(){this.close(),this.removeAllListeners()}[Symbol.dispose](){this.destroy()}}!function(e){let t;!function(e){e.LocalIceCandidate="LocalIceCandidate",e.EndOfIceCandidates="EndOfIceCandidates",e.Connected="Connected",e.Disconnected="Disconnected",e.RemoteStreamChanged="RemoteStreamChanged",e.ReinitializingConnectionRequired="ReinitializingConnectionRequired",e.Closed="Closed"}(t=e.Events||(e.Events={}))}(PeerConnection||(PeerConnection={}));
+import { EventEmitter } from '@js-toolkit/utils/EventEmitter';
+import { getErrorMessage } from '@js-toolkit/utils/getErrorMessage';
+import { hasIn } from '@js-toolkit/utils/hasIn';
+import log from '@js-toolkit/utils/log';
+import * as sdpUtils from './sdputils';
+export class PeerConnection extends EventEmitter {
+    options;
+    // eslint-disable-next-line class-methods-use-this
+    get Events() {
+        return PeerConnection.Events;
+    }
+    logger;
+    pc;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.logger = options.logger ?? log.getLogger('PeerConnection');
+        this.pc = this.createPC();
+    }
+    clear() {
+        this.pc.onsignalingstatechange = null;
+        this.pc.onconnectionstatechange = null;
+        this.pc.oniceconnectionstatechange = null;
+        this.pc.ontrack = null;
+        this.pc.onnegotiationneeded = null;
+        this.pc.onicecandidate = null;
+        this.pc.onicecandidateerror = null;
+    }
+    createPC() {
+        const pc = new RTCPeerConnection(this.options.rtc);
+        pc.onsignalingstatechange = () => {
+            this.logger.debug(`Signaling state changed to: ${pc.signalingState}`);
+            if (pc.signalingState === 'closed') {
+                this.emit(this.Events.Closed);
+                this.clear();
+            }
+        };
+        const handleConnectionStateChange = (state) => {
+            this.logger.debug(`Connection state changed to: ${state}`);
+            if (state === 'connected')
+                this.emit(this.Events.Connected);
+            else if (state === 'disconnected')
+                this.emit(this.Events.Disconnected);
+        };
+        if (hasIn(RTCPeerConnection.prototype, 'onconnectionstatechange')) {
+            pc.onconnectionstatechange = () => handleConnectionStateChange(pc.connectionState);
+        }
+        else {
+            pc.oniceconnectionstatechange = () => handleConnectionStateChange(pc.iceConnectionState);
+        }
+        // All tracks must be in one stream for controlling adding/removing tracks.
+        pc.ontrack = ({ streams, track }) => {
+            this.logger.debug('Remote stream received.', streams.length, track.kind);
+            if (streams.length === 0)
+                return;
+            const [stream] = streams;
+            stream.onremovetrack = () => {
+                this.logger.debug('onremovetrack');
+                this.emit(this.Events.RemoteStreamChanged, stream);
+            };
+            stream.onaddtrack = () => {
+                this.logger.debug('onaddtrack');
+                this.emit(this.Events.RemoteStreamChanged, stream);
+            };
+            // stream.oninactive = () => {
+            //   this.logger.debug('oninactive');
+            // };
+            this.emit(this.Events.RemoteStreamChanged, stream);
+        };
+        pc.onnegotiationneeded = () => {
+            // When media stream is changed we should re-communicate.
+            const { iceConnectionState: state } = pc;
+            if (state === 'connected' || state === 'completed') {
+                this.logger.debug('Reinitializing connection...');
+                this.emit(this.Events.ReinitializingConnectionRequired);
+            }
+        };
+        pc.onicecandidate = ({ candidate }) => {
+            if (!candidate) {
+                // End of candidates.
+                this.emit(this.Events.EndOfIceCandidates);
+                return;
+            }
+            if (!sdpUtils.isValidIceCandidate(candidate))
+                return;
+            this.emit(this.Events.LocalIceCandidate, candidate);
+            // this.logger.debug(`New ICE candidate: ${JSON.stringify(candidate)}`);
+        };
+        pc.onicecandidateerror = (event) => {
+            if (event instanceof RTCPeerConnectionIceErrorEvent) {
+                const { errorCode, errorText, hostCandidate, url } = event;
+                this.logger.warn(`ICE candidate error: errorCode=${errorCode}, errorText=${errorText}, hostCandidate=${hostCandidate}, url=${url}`);
+            }
+            else {
+                this.logger.warn(`ICE candidate error: ${getErrorMessage(event)}`);
+            }
+        };
+        return pc;
+    }
+    async setLocalDescription(pc, desc) {
+        const newDesc = sdpUtils.prepareLocalDescription(desc, this.options.codecs);
+        await pc.setLocalDescription(newDesc);
+        return newDesc;
+    }
+    async setRemoteDescription(pc, desc) {
+        const newDesc = sdpUtils.prepareRemoteDescription(desc, this.options.codecs);
+        await pc.setRemoteDescription(newDesc);
+        return newDesc;
+    }
+    isConnected() {
+        return this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
+    }
+    isClosed() {
+        return this.pc.signalingState === 'closed';
+    }
+    /** Add icecandidate when the clients is exchanging icecandidates. */
+    addIceCandidate(candidate) {
+        return this.pc.addIceCandidate(candidate);
+    }
+    /** Add stream to the remote peer if needed. */
+    attachStream(stream) {
+        const senders = this.pc.getSenders();
+        // Get tracks which not existed in peer connection.
+        const newTracks = senders.length > 0
+            ? stream
+                .getTracks()
+                .filter((t) => !senders.find(({ track }) => !!track && track.id === t.id))
+            : stream.getTracks();
+        // If connection has already attached tracks then not possible attach tracks again.
+        if (newTracks.length === 0) {
+            this.logger.debug('No tracks to attach to a peer connection.');
+            return;
+        }
+        newTracks.forEach((track) => this.pc.addTrack(track, stream));
+        this.logger.debug(`Attached ${newTracks.length} track(s) to a peer connection.`);
+    }
+    /**
+     * Remove ended tracks and unknown tracks and invoke `attachStream`.
+     * If stream is not passed then all tracks will be removed.
+     */
+    reattachStream(stream) {
+        // Reattach only if connected or just created
+        const state = this.pc.iceConnectionState;
+        if (state !== 'new' && state !== 'connected' && state !== 'completed')
+            return;
+        // Remove diff tracks from connection
+        // If do not remove tracks then they are piling up on the remote client (in received stream).
+        // The removing track must by in `ended` readyState.
+        const tracks = stream ? stream.getTracks() : [];
+        this.pc.getSenders().forEach((s) => {
+            const { track } = s;
+            if (track && (track.readyState === 'ended' || !tracks.find((_) => _.id === track.id))) {
+                this.pc.removeTrack(s);
+                this.logger.debug(`'${track.kind}' track is removed from a peer connection.`);
+            }
+        });
+        if (stream)
+            this.attachStream(stream);
+    }
+    /** A call to establish a connection. */
+    async createOffer() {
+        const desc = await this.pc.createOffer(this.options.offerOptions);
+        // this.logger.debug(`Offer created with: ${JSON.stringify(options)}`);
+        return this.setLocalDescription(this.pc, desc);
+    }
+    /** A call from another client which received an offer. */
+    async createAnswer(offer) {
+        await this.setRemoteDescription(this.pc, offer);
+        const desc = await this.pc.createAnswer(this.options.offerOptions);
+        return this.setLocalDescription(this.pc, desc);
+    }
+    /** Apply answer from another client after calling `createOffer`. */
+    applyAnswer(remoteDesc) {
+        return this.setRemoteDescription(this.pc, remoteDesc);
+    }
+    reconnect() {
+        this.close();
+        this.pc = this.createPC();
+    }
+    /** After calling this method the connection can no longer be used unless `reconnect` will be called. */
+    close() {
+        this.pc.close();
+        // The event is not fired if close manually
+        if (this.pc.onsignalingstatechange) {
+            this.emit(this.Events.Closed);
+            this.clear();
+        }
+    }
+    destroy() {
+        this.close();
+        this.removeAllListeners();
+    }
+    [Symbol.dispose]() {
+        this.destroy();
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (PeerConnection) {
+    let Events;
+    (function (Events) {
+        /** IceCandidate for exchanging. */
+        Events["LocalIceCandidate"] = "LocalIceCandidate";
+        Events["EndOfIceCandidates"] = "EndOfIceCandidates";
+        /** The connection is established. */
+        Events["Connected"] = "Connected";
+        /** The remote client closed a connection or connection is failed. */
+        Events["Disconnected"] = "Disconnected";
+        Events["RemoteStreamChanged"] = "RemoteStreamChanged";
+        Events["ReinitializingConnectionRequired"] = "ReinitializingConnectionRequired";
+        Events["Closed"] = "Closed";
+    })(Events = PeerConnection.Events || (PeerConnection.Events = {}));
+})(PeerConnection || (PeerConnection = {}));