@apple-pie/slice 0.1.30 → 0.1.32

package/dist/esm/chunks/Toast-8bUziIgh.mjs

@@ -0,0 +1,189 @@
+'use client';
+import { _ as __rest } from "./tslib.es6-C81Qhn1z.mjs";
+
+import { jsx, jsxs } from "react/jsx-runtime";
+
+import { AnimatePresence, motion } from "motion/react";
+
+import React, { useState, useRef, useEffect, useMemo, useCallback } from "react";
+
+import { useTheme } from "../hooks/useTheme.mjs";
+
+import "../theme/colors.mjs";
+
+import { s as setStyle, f as filterClasses, a as accessibleKeyDown } from "./misc-2MIIqzsX.mjs";
+
+import "../hooks/useWindow.mjs";
+
+import { I as Icon } from "./Icon-D4A6_c4x.mjs";
+
+import { P as ProgressIndicator } from "./ProgressIndicator-BV0ginXb.mjs";
+
+var ToastType, css = {
+    wrapper: "Toast-module_wrapper__1uj9O flexBox-module_rowBetween__5FEvi",
+    close: "Toast-module_close__i10-s flexBox-module_row__z24tF",
+    message: "Toast-module_message__3dP0P flexBox-module_rowStart__4tcxS",
+    progress: "Toast-module_progress__SWsbA flexBox-module_row__z24tF",
+    s: "Toast-module_s__kc5Ef type-module_body-s-regular__vRHSP",
+    m: "Toast-module_m__JtmLz type-module_body-m-regular__LuQBA",
+    l: "Toast-module_l__-W0PD type-module_body-l-regular__lOYbg"
+};
+
+!function(ToastType) {
+    ToastType.Success = "success", ToastType.Error = "error", ToastType.Warning = "warning", 
+    ToastType.Info = "info";
+}(ToastType || (ToastType = {}));
+
+const ToastBase = React.forwardRef((props, ref) => {
+    const {notifId: notifId, message: message = null, size: size = "m", border: border = !0, padding: padding, radius: radius = 8, container: container = "window", showDelay: showDelay = 0, duration: duration = 5e3, position: position = "bottom", offset: offset = 24, close: close = !0, progress: progress, type: type = ToastType.Info, didHide: didHide = () => null} = props, divAttributes = __rest(props, [ "notifId", "message", "size", "border", "padding", "radius", "container", "showDelay", "duration", "position", "offset", "close", "progress", "type", "didHide" ]), theme = useTheme(), {id: divId, className: className, style: style} = divAttributes, rest = __rest(divAttributes, [ "id", "className", "style" ]), divStyle = null != style ? style : {}, divClass = className ? `${className}` : "", [ready, setReady] = useState(!1), [content, setContent] = useState(null), timer = useRef(null);
+    useEffect(() => {
+        timer.current && clearTimeout(timer.current);
+        return message && message.length > 0 ? timer.current = setTimeout(() => {
+            setContent(message), timer.current && clearTimeout(timer.current), "Infinite" !== duration && (timer.current = setTimeout(() => {
+                setReady(!1);
+            }, duration));
+        }, showDelay) : setContent(null), () => {
+            timer.current && clearTimeout(timer.current);
+        };
+    }, [ message, showDelay, duration ]), useEffect(() => setReady(null !== content), [ content ]);
+    const defaultPadding = useMemo(() => close ? "10px 12px 10px 16px" : "10px 16px", [ close ]), colorScheme = useMemo(() => {
+        switch (type) {
+          case "success":
+            return {
+                border: "var(--array-land-label)",
+                bg: "var(--array-land)",
+                text: "var(--array-land-label)"
+            };
+
+          case "warning":
+            return {
+                border: "var(--array-orange-label)",
+                bg: "var(--array-orange)",
+                text: "var(--array-orange-label)"
+            };
+
+          case "error":
+            return {
+                border: "var(--feedback-warning)",
+                bg: "var(--array-magenta)",
+                text: "var(--feedback-warning)"
+            };
+
+          default:
+            return {
+                border: "var(--core-outline-primary)",
+                bg: "var(--core-surface-secondary)",
+                text: "var(--core-text-primary)"
+            };
+        }
+    }, [ type ]), cssVars = useMemo(() => ({
+        "--toast-padding": setStyle(padding, defaultPadding),
+        "--toast-background": colorScheme.bg,
+        "--toast-color": colorScheme.text,
+        "--toast-border": border ? `1px solid ${colorScheme.border}` : "unset",
+        "--toast-border-radius": setStyle(radius, 4),
+        "--toast-position": "window" === container ? "fixed" : "absolute"
+    }), [ padding, border, colorScheme, radius, defaultPadding, container ]), variants = useMemo(() => {
+        const positionShow = "bottom" === position ? {
+            bottom: offset
+        } : {
+            top: offset
+        }, positionHide = "bottom" === position ? {
+            bottom: -offset
+        } : {
+            top: -offset
+        }, transition = {
+            ease: "easeInOut",
+            duration: .25
+        };
+        return {
+            initial: Object.assign({
+                opacity: 0
+            }, positionHide),
+            animate: Object.assign(Object.assign({
+                opacity: 1
+            }, positionShow), {
+                transition: transition
+            }),
+            exit: Object.assign(Object.assign({
+                opacity: 0
+            }, positionHide), {
+                transition: transition
+            })
+        };
+    }, [ position, offset ]), classNames = useMemo(() => filterClasses([ css.wrapper, css[size], divClass ]), [ size, divClass ]), handleClose = useCallback(() => {
+        setReady(!1);
+    }, []), handleMouseOver = useCallback(() => {
+        timer.current && clearTimeout(timer.current);
+    }, []), handleMouseOut = useCallback(() => {
+        timer.current && clearTimeout(timer.current), "Infinite" !== duration && (timer.current = setTimeout(() => {
+            setContent(null);
+        }, duration));
+    }, [ duration ]), showProgress = useMemo(() => void 0 !== progress ? progress : "Infinite" === duration, [ progress, duration ]), iconColor = useMemo(() => {
+        switch (type) {
+          case ToastType.Error:
+            return theme.current.colors["feedback-warning"];
+
+          case ToastType.Success:
+            return theme.current.colors["array-land-label"];
+
+          case ToastType.Warning:
+            return theme.current.colors["array-orange-label"];
+
+          default:
+            return theme.current.colors["core-text-primary"];
+        }
+    }, [ type, theme ]);
+    return jsx(AnimatePresence, {
+        onExitComplete: () => didHide(),
+        initial: !1,
+        children: ready && jsxs(motion.div, Object.assign({
+            ref: ref,
+            id: divId,
+            className: classNames
+        }, rest, {
+            onMouseEnter: handleMouseOver,
+            onMouseLeave: handleMouseOut,
+            onFocus: handleMouseOver,
+            onBlur: handleMouseOut,
+            style: Object.assign(Object.assign(Object.assign({}, divStyle), cssVars), {
+                visibility: ready ? "visible" : "hidden"
+            }),
+            variants: variants,
+            initial: "initial",
+            animate: "animate",
+            exit: "exit",
+            children: [ jsxs("div", {
+                role: "status",
+                "aria-live": "polite",
+                className: css.message,
+                children: [ showProgress && jsx("div", {
+                    className: css.progress,
+                    children: jsx(ProgressIndicator, {
+                        show: !0,
+                        inline: !0,
+                        color: iconColor
+                    })
+                }), content ]
+            }), ("Infinite" === duration || close) && jsx("div", {
+                className: css.close,
+                tabIndex: 0,
+                role: "button",
+                "aria-label": "dismiss message",
+                onKeyDown: e => accessibleKeyDown(e, handleClose),
+                onClick: handleClose,
+                children: jsx(Icon, {
+                    name: "x",
+                    size: 20,
+                    strokeColor: iconColor
+                })
+            }) ]
+        }), notifId)
+    });
+});
+
+ToastBase.displayName = "Toast";
+
+const Toast = React.memo(ToastBase);
+
+export { Toast as T, ToastType as a };

package/dist/esm/chunks/ToggleButton-BOFITa8_.mjs

@@ -0,0 +1,47 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+
+import { useMemo } from "react";
+
+import { I as IconButton } from "./IconButton-B_W-aOsB.mjs";
+
+import { L as Label } from "./Label-I75yz3gq.mjs";
+
+var css_toggleButton = "ToggleButton-module_toggleButton__H7KgI flexBox-module_rowStart__4tcxS";
+
+function ToggleButton(props) {
+    const {label: label, textSize: textSize, icon: icon, selected: selected = !1, iconColor: iconColor = "var(--core-text-primary)", iconColorOn: iconColorOn = "var(--core-surface-primary)", bgColor: bgColor = "var(--core-surface-secondary)", bgColorOn: bgColorOn = "var(--core-text-special)", iconSize: iconSize = 20, buttonSize: buttonSize = "m", tooltip: tooltip, gap: gap = 4, unselect: unselect = !0, fill: fill = !1, disabled: disabled = !1, onChange: onChange, onSelect: onSelect, onToolTip: onToolTip, children: children} = props, handleClick = () => {
+        if (!unselect && selected) return;
+        const newState = !selected;
+        null == onChange || onChange(newState), newState && (null == onSelect || onSelect());
+    }, cssVars = useMemo(() => ({
+        "--tb-gap": `${gap}px`
+    }), [ gap ]);
+    return jsxs("div", {
+        className: css_toggleButton,
+        style: cssVars,
+        children: [ icon && jsx(IconButton, {
+            icon: icon,
+            buttonSize: buttonSize,
+            tooltip: tooltip,
+            toggle: !selected,
+            isToggled: selected,
+            bgColorOn: bgColorOn,
+            bgColor: bgColor,
+            iconColor: iconColor,
+            iconColorOn: iconColorOn,
+            onClick: handleClick,
+            iconSize: iconSize,
+            iconFill: fill,
+            disabled: disabled,
+            onToolTip: onToolTip
+        }), (children || label) && jsx(Label, {
+            textSize: textSize,
+            borderSize: 0,
+            padding: 0,
+            onClick: handleClick,
+            children: null != children ? children : label
+        }) ]
+    });
+}
+
+export { ToggleButton as T };

package/dist/esm/chunks/UploadArea-DE2ccDVx.mjs

@@ -0,0 +1,135 @@
+'use client';
+import { jsxs, jsx } from "react/jsx-runtime";
+
+import React, { useState, useRef, useId, useCallback, useMemo } from "react";
+
+import { s as setStyle, a as accessibleKeyDown } from "./misc-2MIIqzsX.mjs";
+
+import { I as Icon } from "./Icon-D4A6_c4x.mjs";
+
+import { P as ProgressIndicator } from "./ProgressIndicator-BV0ginXb.mjs";
+
+import { F as FileList } from "./FileList-vMiGJByw.mjs";
+
+var css = {
+    wrapper: "UploadArea-module_wrapper__aircC flexBox-module_column__ezvMq",
+    icon: "UploadArea-module_icon__M7n-m flexBox-module_row__z24tF",
+    title: "UploadArea-module_title__VbNGq type-module_body-l-bold__Fh2dt",
+    message: "UploadArea-module_message__U1ZVM flexBox-module_row__z24tF",
+    files: "UploadArea-module_files__Q796x flexBox-module_column__ezvMq",
+    xs: "UploadArea-module_xs__-AoM7 type-module_body-xs-regular__ZAFft",
+    s: "UploadArea-module_s__wy1zN type-module_body-s-regular__vRHSP",
+    m: "UploadArea-module_m__bKuFN type-module_body-m-regular__LuQBA",
+    l: "UploadArea-module_l__KG9YN type-module_body-l-regular__lOYbg"
+};
+
+const imageTypes = [ "png", "jpg", "jpeg", "gif", "svg", "heic", "heif" ], videoTypes = [ "mp4", "avi", "mov", "wmv", "flv" ], documentTypes = [ "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx" ], audioTypes = [ "mp3", "wav", "ogg", "aac", "flac" ], textTypes = [ "txt", "rtf", "md", "csv", "json", "xml" ], allTypes = [ ...imageTypes, ...videoTypes, ...documentTypes, ...audioTypes, ...textTypes ];
+
+var FileTypes;
+
+!function(FileTypes) {
+    FileTypes.images = "images", FileTypes.videos = "videos", FileTypes.documents = "documents", 
+    FileTypes.audio = "audio", FileTypes.text = "text", FileTypes.all = "all", FileTypes.custom = "custom";
+}(FileTypes || (FileTypes = {}));
+
+const UploadAreaBase = React.forwardRef((props, ref) => {
+    const {icon: icon = "upload", iconColor: iconColor = "var(--core-text-primary)", iconColorHover: iconColorHover = "var(--core-text-special)", title: title = "Upload Files", width: width = "100%", height: height = "auto", message: message = "Drag and drop files here or click to upload", busyMessage: busyMessage = "Uploading in progress", iconSize: iconSize = 24, textSize: textSize = "m", borderWidth: borderWidth, border: border = 1, borderStyle: borderStyle = "dashed", borderColor: borderColor = "var(--core-outline-primary)", borderColorHover: borderColorHover = "var(--core-outline-special)", borderRadius: borderRadius, radius: radius = 8, padding: padding = 32, backgroundColor: backgroundColor, backgroundColorHover: backgroundColorHover, bgColor: bgColor = "var(--core-surface-secondary)", bgColorHover: bgColorHover = "var(--core-surface-special)", acceptedTypes: acceptedTypes = allTypes, multiple: multiple = !0, busy: busy = !1, canRemove: canRemove = !0, showProgress: showProgress = !0, files: files = [], onUpload: onUpload} = props, [hovered, setHovered] = useState(!1), inputRef = useRef(null), dragDepth = useRef(0), inputId = useId(), titleId = useId(), messageId = useId(), isInteractive = !busy && files.length < 1, resolvedBorderWidth = null != borderWidth ? borderWidth : border, resolvedBorderRadius = null != borderRadius ? borderRadius : radius, resolvedBackgroundColor = null != backgroundColor ? backgroundColor : bgColor, resolvedBackgroundColorHover = null != backgroundColorHover ? backgroundColorHover : bgColorHover, handleClickUpload = useCallback(() => {
+        var _a;
+        isInteractive && (null == inputRef ? void 0 : inputRef.current) && (inputRef.current.value = "", 
+        null === (_a = inputRef.current) || void 0 === _a || _a.click());
+    }, [ isInteractive ]), handleFileInputChange = useCallback(e => {
+        busy || e.target.files && (null == onUpload || onUpload(Array.from(e.target.files)));
+    }, [ busy, onUpload ]), hasFilesInDrag = useCallback(e => {
+        var _a, _b;
+        return Array.from(null !== (_b = null === (_a = e.dataTransfer) || void 0 === _a ? void 0 : _a.types) && void 0 !== _b ? _b : []).includes("Files");
+    }, []), handleDragEnter = useCallback(e => {
+        e.preventDefault(), !busy && hasFilesInDrag(e) && (dragDepth.current += 1, 1 === dragDepth.current && setHovered(!0));
+    }, [ busy, hasFilesInDrag ]), handleDragLeave = useCallback(e => {
+        e.preventDefault(), busy || (dragDepth.current = Math.max(0, dragDepth.current - 1), 
+        0 === dragDepth.current && setHovered(!1));
+    }, [ busy ]), handleDrop = useCallback(e => {
+        var _a;
+        if (e.preventDefault(), busy) return;
+        dragDepth.current = 0, setHovered(!1);
+        const files = Array.from(null !== (_a = e.dataTransfer.files) && void 0 !== _a ? _a : []);
+        null == onUpload || onUpload(files);
+    }, [ busy, onUpload ]), iconStrokeColor = useMemo(() => hovered ? iconColorHover : iconColor, [ hovered, iconColor, iconColorHover ]), cssVars = useMemo(() => ({
+        "--ua-border": `${resolvedBorderWidth}px`,
+        "--ua-border-style": borderStyle,
+        "--ua-border-color": hovered || busy ? borderColorHover : borderColor,
+        "--ua-radius": `${resolvedBorderRadius}px`,
+        "--ua-padding": setStyle(padding),
+        "--ua-bg-color": hovered ? resolvedBackgroundColorHover : resolvedBackgroundColor,
+        "--ua-icon-size": `${iconSize}px`,
+        "--ua-cursor": busy || files.length > 0 ? "default" : "pointer",
+        "--ua-width": setStyle(width),
+        "--ua-height": setStyle(height)
+    }), [ resolvedBorderWidth, borderStyle, borderColor, borderColorHover, resolvedBorderRadius, padding, resolvedBackgroundColor, resolvedBackgroundColorHover, iconSize, busy, hovered, height, files.length, width ]);
+    return jsxs("div", {
+        className: css.wrapper,
+        style: cssVars,
+        ref: ref,
+        role: isInteractive ? "button" : void 0,
+        "aria-label": isInteractive ? "Click to upload files" : void 0,
+        "aria-describedby": `${titleId} ${messageId}`,
+        "aria-disabled": !isInteractive,
+        tabIndex: isInteractive ? 0 : -1,
+        onClick: isInteractive ? handleClickUpload : void 0,
+        onKeyDown: isInteractive ? e => accessibleKeyDown(e, () => handleClickUpload()) : void 0,
+        onDragEnter: handleDragEnter,
+        onDragOver: e => {
+            e.preventDefault();
+        },
+        onDragLeave: handleDragLeave,
+        onDrop: handleDrop,
+        children: [ jsx("div", {
+            className: css.icon,
+            children: jsx(Icon, {
+                size: iconSize,
+                name: icon,
+                strokeColor: iconStrokeColor,
+                pointer: !1
+            })
+        }), jsx("div", {
+            id: titleId,
+            className: css.title,
+            children: title
+        }), jsxs("div", {
+            id: messageId,
+            className: `${css.message} ${css[textSize]}`,
+            children: [ busy && showProgress && jsx(ProgressIndicator, {
+                show: !0,
+                size: 20,
+                inline: !0,
+                color: iconStrokeColor
+            }), busy ? busyMessage : message ]
+        }), files.length > 0 && jsx("div", {
+            className: css.files,
+            children: jsx(FileList, {
+                files: files,
+                bgColor: "var(--core-surface-primary)",
+                size: "m",
+                direction: "column",
+                gap: 8,
+                iconSize: 24,
+                padding: "10px",
+                canRemove: canRemove
+            })
+        }), jsx("input", {
+            id: inputId,
+            ref: inputRef,
+            type: "file",
+            hidden: !0,
+            disabled: busy,
+            multiple: multiple,
+            accept: acceptedTypes ? acceptedTypes.join(", ") : void 0,
+            onChange: handleFileInputChange
+        }) ]
+    });
+});
+
+UploadAreaBase.displayName = "UploadArea";
+
+const UploadArea = React.memo(UploadAreaBase);
+
+export { UploadArea as U, allTypes as a, audioTypes as b, documentTypes as d, imageTypes as i, textTypes as t, videoTypes as v };

package/dist/esm/chunks/{WSConnection-DV7k84B4.mjs → WSConnection-CHudrD62.mjs}

@@ -1,4 +1,4 @@
-import { _ as __awaiter } from "./tslib.es6-C-olHjXV.mjs";
+import { a as __awaiter } from "./tslib.es6-C81Qhn1z.mjs";
 
 /**
  * Manage a WebSocket connection with optional unified events, retries, and keep-alive pings.

package/dist/esm/chunks/WebRTCConnection-DQbNa7Z9.mjs

@@ -0,0 +1,252 @@
+import { a as __awaiter } from "./tslib.es6-C81Qhn1z.mjs";
+
+class WebRTCConnection {
+    /**
+     * Report whether the peer connection is currently connected
+     */
+    get connected() {
+        return "connected" === this.peerConnection.connectionState;
+    }
+    /**
+     * Report whether the connection currently has an audio path attached
+     */    get audioConnected() {
+        var _a, _b;
+        const hasLocalAudioTrack = "live" === (null === (_b = null === (_a = this.RTCSenderAudioSender) || void 0 === _a ? void 0 : _a.track) || void 0 === _b ? void 0 : _b.readyState), hasRemoteAudioTrack = this.RTCReceiverAudioTracks.size > 0;
+        return Boolean(hasLocalAudioTrack || hasRemoteAudioTrack);
+    }
+    /**
+     * Report whether the connection currently has a video path attached
+     */    get videoConnected() {
+        var _a, _b;
+        const hasLocalVideoTrack = "live" === (null === (_a = this.RTCSenderVideoTrack) || void 0 === _a ? void 0 : _a.readyState) || "live" === (null === (_b = this.RTCScreenShareTrack) || void 0 === _b ? void 0 : _b.readyState), hasRemoteVideoTrack = this.RTCReceiverVideoTracks.size > 0;
+        return Boolean(hasLocalVideoTrack || hasRemoteVideoTrack);
+    }
+    /**
+     * Report whether any data channel is currently open
+     */    get dataConnected() {
+        return this.RTCDataChannels.some(channel => "open" === channel.readyState);
+    }
+    /**
+     * Create the base instance
+     */    constructor(rtcConnectionInfo) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (this.RTCSenderAudioTrack = null, this.RTCSenderVideoTrack = null, this.RTCSenderAudioSender = null, 
+        this.RTCSenderAudioStream = new MediaStream, this.RTCScreenShareTrack = null, this.RTCScreenShareSender = null, 
+        this.RTCReceiverAudioStream = new MediaStream, this.RTCReceiverVideoTracks = new Map, 
+        this.RTCReceiverAudioTracks = new Map, this.RTCDataChannels = [], this.connectionUrl = "", 
+        this.connectionOffer = null, this.autoPlayAudio = !0, this.iceTimer = null, !globalThis.document) throw new Error("RTC needs a valid browser environment");
+        if (this.connectionUrl = null !== (_a = rtcConnectionInfo.connectionUrl) && void 0 !== _a ? _a : "", 
+        this.peerConnection = new RTCPeerConnection, this.RTCSenderAudioTrack = null !== (_d = null !== (_c = null === (_b = rtcConnectionInfo.micStream) || void 0 === _b ? void 0 : _b.getAudioTracks()[0]) && void 0 !== _c ? _c : rtcConnectionInfo.micTrack) && void 0 !== _d ? _d : null, 
+        !this.RTCSenderAudioTrack) throw new Error("WebRTCConnection requires a microphone stream or track");
+        this.RTCSenderVideoTrack = rtcConnectionInfo.videoTrack, this.audioElement = null !== (_e = rtcConnectionInfo.audioElement) && void 0 !== _e ? _e : document.createElement("audio"), 
+        this.autoPlayAudio = null === (_f = rtcConnectionInfo.autoPlayAudio) || void 0 === _f || _f;
+        const channels = null !== (_g = rtcConnectionInfo.dataChannels) && void 0 !== _g ? _g : [];
+        this.onRemoteVideoStream = rtcConnectionInfo.onRemoteVideoStream, this.onRemoteAudioStream = rtcConnectionInfo.onRemoteAudioStream, 
+        this.onDataChannelEvent = rtcConnectionInfo.onDataChannelEvent, this.setupIncomingAudioStream(), 
+        "number" == typeof rtcConnectionInfo.volume && this.setVolume(rtcConnectionInfo.volume), 
+        this.setupOutgoingMediaStream(), this.setupDataChannels(channels), this.setupDataChannelEventListeners(), 
+        this.peerConnection.ontrack = this.onTrack.bind(this);
+    }
+    /**
+     * Initialize the RTC connection
+     */    initialize(offerOptions, bearerToken) {
+        return __awaiter(this, void 0, void 0, function*() {
+            this.offerOptions = offerOptions, this.bearerToken = bearerToken, yield this.negotiate();
+        });
+    }
+    /**
+     * Start an optional screen share stream and renegotiate if already connected
+     */    startScreenShare() {
+        return __awaiter(this, void 0, void 0, function*() {
+            var _a, _b;
+            if (!(null === (_b = null === (_a = globalThis.navigator) || void 0 === _a ? void 0 : _a.mediaDevices) || void 0 === _b ? void 0 : _b.getDisplayMedia)) throw new Error("Screen share is not supported in this browser");
+            if (this.RTCScreenShareSender) return;
+            const screenTrack = (yield navigator.mediaDevices.getDisplayMedia({
+                video: !0,
+                audio: !1
+            })).getVideoTracks()[0];
+            if (!screenTrack) throw new Error("No screen share video track was provided");
+            const screenShareStream = new MediaStream([ screenTrack ]);
+            this.RTCScreenShareTrack = screenTrack, this.RTCScreenShareSender = this.peerConnection.addTrack(screenTrack, screenShareStream), 
+            screenTrack.addEventListener("ended", () => {
+                this.stopScreenShare(!1);
+            }), this.peerConnection.remoteDescription && (yield this.negotiate());
+        });
+    }
+    /**
+     * Stop the optional screen share stream and renegotiate if already connected
+     */    stopScreenShare() {
+        return __awaiter(this, arguments, void 0, function*(stopTrack = !0) {
+            this.RTCScreenShareSender && (this.peerConnection.removeTrack(this.RTCScreenShareSender), 
+            this.RTCScreenShareSender = null), stopTrack && this.RTCScreenShareTrack && this.RTCScreenShareTrack.stop(), 
+            this.RTCScreenShareTrack = null, this.peerConnection.remoteDescription && (yield this.negotiate());
+        });
+    }
+    /**
+     * Create an offer, wait for ICE gathering, POST SDP, and apply the answer
+     */    negotiate() {
+        return __awaiter(this, void 0, void 0, function*() {
+            var _a;
+            if (!this.peerConnection) throw new Error("Peer connection not initialized");
+            if (!this.connectionUrl) throw new Error("Peer connection url not provided");
+            this.connectionOffer = yield this.peerConnection.createOffer(this.offerOptions), 
+            yield this.peerConnection.setLocalDescription(this.connectionOffer), yield this.waitForIceGathering();
+            const headers = {
+                "Content-Type": "application/sdp"
+            };
+            this.bearerToken && "" !== this.bearerToken && (headers.Authorization = `Bearer ${this.bearerToken}`);
+            const sdpResponse = yield fetch(this.connectionUrl, {
+                method: "POST",
+                body: null === (_a = this.connectionOffer) || void 0 === _a ? void 0 : _a.sdp,
+                headers: headers
+            });
+            if (!sdpResponse.ok) throw new Error(`Failed to send connection offer to ${this.connectionUrl}. Status: ${sdpResponse.status} ${sdpResponse.statusText}`);
+            const sdpReply = {
+                type: "answer",
+                sdp: yield sdpResponse.text()
+            };
+            yield this.peerConnection.setRemoteDescription(sdpReply);
+        });
+    }
+    /**
+     * Send a JSON-serializable payload over a named data channel
+     */    sendMessage(channelName, data) {
+        const channel = this.RTCDataChannels.find(dataChannel => dataChannel.label === channelName);
+        if (!channel) throw new Error(`Data channel "${channelName}" not found`);
+        if ("open" !== channel.readyState) throw new Error(`Data channel "${channelName}" is not open. Current state: ${channel.readyState}`);
+        channel.send(JSON.stringify(data));
+    }
+    /**
+     * Mute or unmute all incoming audio playback
+     */    muteAllAudio(muted) {
+        this.audioElement.muted = muted;
+    }
+    /**
+     * Mute or unmute a specific incoming audio track
+     */    muteAudioTrack(trackId, muted) {
+        const track = this.RTCReceiverAudioTracks.get(trackId);
+        if (!track) throw new Error(`Audio track "${trackId}" not found`);
+        track.enabled = !muted;
+    }
+    /**
+     * Set the playback volume for the incoming audio element
+     */    setVolume(volume) {
+        this.audioElement.volume = Math.max(0, Math.min(1, volume));
+    }
+    /**
+     * Replace the outgoing audio source with the first track from a stream
+     */    setOutgoingAudioStream(stream) {
+        return __awaiter(this, void 0, void 0, function*() {
+            var _a;
+            yield this.replaceAudioTrack(null !== (_a = null == stream ? void 0 : stream.getAudioTracks()[0]) && void 0 !== _a ? _a : null);
+        });
+    }
+    /**
+     * Replace the outgoing audio track without rebuilding the peer connection
+     */    replaceAudioTrack(track) {
+        return __awaiter(this, void 0, void 0, function*() {
+            this.RTCSenderAudioTrack = track, this.syncSenderAudioStream(track), this.RTCSenderAudioSender ? yield this.RTCSenderAudioSender.replaceTrack(track) : track && (this.RTCSenderAudioSender = this.peerConnection.addTrack(track, this.RTCSenderAudioStream), 
+            this.peerConnection.remoteDescription && (yield this.negotiate()));
+        });
+    }
+    /**
+     * Close the peer connection and release local media bindings
+     */    close() {
+        this.iceTimer && (clearTimeout(this.iceTimer), this.iceTimer = null), this.RTCScreenShareSender && (this.peerConnection.removeTrack(this.RTCScreenShareSender), 
+        this.RTCScreenShareSender = null), this.RTCSenderAudioSender && (this.peerConnection.removeTrack(this.RTCSenderAudioSender), 
+        this.RTCSenderAudioSender = null), this.RTCScreenShareTrack = null, this.RTCSenderAudioTrack = null, 
+        this.audioElement.srcObject = null, this.peerConnection.close();
+    }
+    /**
+     * Create an audio source node from the unified incoming audio stream
+     */    createIncomingAudioSource(audioContext) {
+        return audioContext.createMediaStreamSource(this.RTCReceiverAudioStream);
+    }
+    /**
+     * Handle track events adding them to the unified audio and video streams
+     */    onTrack(event) {
+        var _a, _b;
+        if (event.streams[0]) {
+            if ("video" === event.track.kind) {
+                const stream = event.streams[0], id = stream.id;
+                this.RTCReceiverVideoTracks.has(id) || (this.RTCReceiverVideoTracks.set(id, stream), 
+                null === (_a = this.onRemoteVideoStream) || void 0 === _a || _a.call(this, this.RTCReceiverVideoTracks));
+            }
+            if ("audio" === event.track.kind) {
+                const id = event.track.id;
+                this.RTCReceiverAudioTracks.has(id) || (this.RTCReceiverAudioStream.addTrack(event.track), 
+                this.RTCReceiverAudioTracks.set(id, event.track), null === (_b = this.onRemoteAudioStream) || void 0 === _b || _b.call(this, new Map([ [ this.RTCReceiverAudioStream.id, this.RTCReceiverAudioStream ] ])));
+            }
+        }
+    }
+    /**
+     * Create a local audio element and set its source to the rtc incoming media stream
+     */    setupIncomingAudioStream() {
+        this.audioElement.autoplay = this.autoPlayAudio, this.audioElement.srcObject = this.RTCReceiverAudioStream;
+    }
+    /**
+     * Set up a local stream with mic and video tracks and add to peer connection
+     */    setupOutgoingMediaStream() {
+        if (this.RTCSenderAudioTrack && (this.syncSenderAudioStream(this.RTCSenderAudioTrack), 
+        this.RTCSenderAudioSender = this.peerConnection.addTrack(this.RTCSenderAudioTrack, this.RTCSenderAudioStream)), 
+        this.RTCSenderVideoTrack) {
+            const senderStream = new MediaStream([ this.RTCSenderVideoTrack ]);
+            this.peerConnection.addTrack(this.RTCSenderVideoTrack, senderStream);
+        }
+    }
+    /**
+     * Keep the sender stream aligned to the current local audio track
+     */    syncSenderAudioStream(track) {
+        for (const currentTrack of this.RTCSenderAudioStream.getAudioTracks()) this.RTCSenderAudioStream.removeTrack(currentTrack);
+        track && this.RTCSenderAudioStream.addTrack(track);
+    }
+    /**
+     * Setup data channels
+     */    setupDataChannels(channels) {
+        const channelsArray = Array.isArray(channels) ? channels : [ channels ];
+        if (channelsArray.length > 0) for (const channel of channelsArray) {
+            const dataChannel = this.peerConnection.createDataChannel(channel);
+            this.RTCDataChannels.push(dataChannel);
+        }
+    }
+    /**
+     * Add listeners for data events and push through callback
+     */    setupDataChannelEventListeners() {
+        for (const channel of this.RTCDataChannels) {
+            const channelName = channel.label;
+            channel.addEventListener("message", event => {
+                var _a;
+                null === (_a = this.onDataChannelEvent) || void 0 === _a || _a.call(this, channelName, "message", event);
+            }), channel.addEventListener("open", event => {
+                var _a;
+                null === (_a = this.onDataChannelEvent) || void 0 === _a || _a.call(this, channelName, "open", event);
+            }), channel.addEventListener("close", event => {
+                var _a;
+                null === (_a = this.onDataChannelEvent) || void 0 === _a || _a.call(this, channelName, "close", event);
+            }), channel.addEventListener("error", event => {
+                var _a;
+                null === (_a = this.onDataChannelEvent) || void 0 === _a || _a.call(this, channelName, "error", event);
+            });
+        }
+    }
+    /**
+     * Wait for the ICE gathering to be complete
+     */    waitForIceGathering() {
+        return __awaiter(this, void 0, void 0, function*() {
+            if ("complete" !== this.peerConnection.iceGatheringState) return new Promise((resolve, reject) => {
+                const handleStateChange = () => {
+                    "complete" === this.peerConnection.iceGatheringState && (this.iceTimer && clearTimeout(this.iceTimer), 
+                    this.iceTimer = null, this.peerConnection.removeEventListener("icegatheringstatechange", handleStateChange), 
+                    resolve());
+                };
+                this.peerConnection.addEventListener("icegatheringstatechange", handleStateChange), 
+                this.iceTimer = setTimeout(() => {
+                    this.peerConnection.removeEventListener("icegatheringstatechange", handleStateChange), 
+                    this.iceTimer = null, reject(new Error("ICE gathering timed out"));
+                }, 5e3);
+            });
+        });
+    }
+}
+
+export { WebRTCConnection as W };

package/dist/esm/chunks/{localDBStore-Dnpo5nSv.mjs → localDBStore-CaYiqITY.mjs}

@@ -1,4 +1,4 @@
-import { _ as __awaiter, a as __rest } from "./tslib.es6-C-olHjXV.mjs";
+import { a as __awaiter, _ as __rest } from "./tslib.es6-C81Qhn1z.mjs";
 
 import { useMemo } from "react";
 
@@ -6,7 +6,7 @@ import { create } from "zustand";
 
 import { useShallow } from "zustand/react/shallow";
 
-import { I as IndexedDB } from "./IndexedDB-Dk7a4fPS.mjs";
+import { I as IndexedDB } from "./IndexedDB-CTqfKmp1.mjs";
 
 function isValidIDBKey(key) {
     return "string" == typeof key || "number" == typeof key || key instanceof Date || key instanceof ArrayBuffer || (Array.isArray(key) ? key.every(entry => isValidIDBKey(entry)) : ArrayBuffer.isView(key));