@apple-pie/slice 0.1.21 → 0.1.23

package/dist/types/hooks/index.d.ts

@@ -5,5 +5,8 @@ export { useToolTip } from './useToolTip/useToolTip';
 export { type KeyboardShortcut, type KeyboardShortcuts, useKeyboardShortcuts, } from './useKeyboardShortcuts/useKeyboardShortcuts';
 export { useLastUpdated } from './useLastUpdated/useLastUpdated';
 export { useLocalStore } from './useLocalStore/useLocalStore';
+export { useMDStreamBuffer } from './useMdStreamBuffer/useMdStreamBuffer';
+export { useMicrophone } from './useMicrophone/useMicrophone';
+export { useAudioRecorder } from './useAudioRecorder/useAudioRecorder';
 export { useWindow, FormFactor, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, } from './useWindow/useWindow';
 export { useObserveResize } from './useObserveResize/useObserveResize';

package/dist/types/hooks/useAudioRecorder/useAudioRecorder.d.ts

@@ -0,0 +1,14 @@
+import type { RefObject } from 'react';
+type UseStreamToMp3Return = {
+    audioBlob: RefObject<Blob | null>;
+    error: Error | null;
+    isRecording: boolean;
+    recordingSizeMb: number;
+    mimeType: string | null;
+    resetRecording: () => void;
+    startRecording: () => void;
+    stopRecording: () => Promise<Blob | null>;
+};
+type AudioRecorderSource = MediaStream | MediaStreamTrack | RefObject<MediaStream | MediaStreamTrack | null> | null | undefined;
+export declare function useAudioRecorder(audioStream: AudioRecorderSource): UseStreamToMp3Return;
+export {};

package/dist/types/hooks/useMdStreamBuffer/useMdStreamBuffer.d.ts

@@ -0,0 +1,10 @@
+import type { MarkdownStreamBufferOptions, MarkdownStreamBufferSnapshot } from '../../utils';
+export declare function useMDStreamBuffer(options?: MarkdownStreamBufferOptions): {
+    raw: string;
+    healthy: string;
+    isComplete: boolean;
+    append: (value: string) => void;
+    flush: () => MarkdownStreamBufferSnapshot | undefined;
+    complete: () => MarkdownStreamBufferSnapshot | undefined;
+    reset: () => void;
+};

package/dist/types/hooks/useMicrophone/useMicrophone.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from 'react';
+type UseMicrophoneReturn = {
+    micStream: RefObject<MediaStream | null>;
+    micTrack: RefObject<MediaStreamTrack | null>;
+    muted: boolean;
+    isSupported: boolean;
+    isRequesting: boolean;
+    error: Error | null;
+    microphones: MediaDeviceInfo[];
+    requestMicrophone: () => Promise<MediaStream | null>;
+    stopMicrophone: () => void;
+    muteMic: () => boolean;
+    unmuteMic: () => boolean;
+    toggleMute: () => void;
+    refreshMicrophones: () => Promise<MediaDeviceInfo[]>;
+    setMicrophone: (deviceId: string) => Promise<void>;
+};
+export declare function useMicrophone(startMuted?: boolean, microphoneDeviceId?: string): UseMicrophoneReturn;
+export {};

package/dist/types/index.d.ts

@@ -2,7 +2,9 @@ export type { ToolTip, ToolTipInfo } from './components/sharedTypes';
 export { ToolTipType } from './components/sharedTypes';
 export { light, dark, lightTheme, darkTheme, motion, elevations, Elevation, } from './theme';
 export type { SliceTheme, Colors, Type, Corners, Elevations, } from './theme';
-export { type KeyboardShortcut, type KeyboardShortcuts, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, useKeyboardShortcuts, useTheme, useObserveTheme, useToolTip, useLastUpdated, useLocalStore, useWindow, useDoubleClick, useObserveResize, } from './hooks';
+export { type KeyboardShortcut, type KeyboardShortcuts, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, useKeyboardShortcuts, useTheme, useObserveTheme, useToolTip, useLastUpdated, useLocalStore, useMDStreamBuffer, useAudioRecorder, useMicrophone, useWindow, useDoubleClick, useObserveResize, } from './hooks';
+export { AudioBubble } from './components/AudioBubble/index';
+export type { AudioBubbleProps } from './components/AudioBubble/index';
 export { Avatar } from './components/Avatar/index';
 export type { AvatarProps } from './components/Avatar/index';
 export { AvatarGroup } from './components/AvatarGroup';

package/dist/types/utils/index.d.ts

@@ -1,5 +1,5 @@
 export { copyToClipboard, hexToRgb } from './functions/misc';
 export { debounce } from './functions/debounce';
 export * from './functions/colors';
-export { IndexedDB, SSEConnection, WSConnection } from './objects';
-export type { IndexedDBOptions, SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, UnifiedMessageEvent, WSConnectionOptions, } from './objects';
+export { AudioVisualizer, IndexedDB, MdBuffer, SSEConnection, WSConnection, } from './objects';
+export type { AudioVisualizerOptions, AudioVisualizerSource, IndexedDBOptions, MarkdownAutoCloseRule, MarkdownStreamBufferOptions, MarkdownStreamBufferSnapshot, SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, UnifiedMessageEvent, WSConnectionOptions, } from './objects';

package/dist/types/utils/objects/MDStreamBuffer/MdStreamBuffer.d.ts

@@ -0,0 +1,63 @@
+import type { MarkdownStreamBufferOptions, MarkdownStreamBufferSnapshot } from './_types';
+/**
+ * Buffer streamed Markdown and emit parser-safe snapshots on animation frames.
+ */
+export declare class MdBuffer {
+    private readonly endOfStreamToken?;
+    private readonly htmlHandling;
+    private readonly includeLinksAndImages;
+    private readonly onFlush?;
+    private readonly requestFrame;
+    private readonly cancelFrame;
+    private readonly watchedMarkers;
+    private committedRaw;
+    private activeRaw;
+    private frameHandle;
+    private completeSignal;
+    constructor(options?: MarkdownStreamBufferOptions);
+    /**
+     * The raw Markdown accumulated so far.
+     */
+    get raw(): string;
+    /**
+     * The current parser-safe preview derived from the raw buffer.
+     */
+    get healthy(): string;
+    /**
+     * Append a streamed Markdown token and schedule a frame flush.
+     */
+    append(chunk: string): MarkdownStreamBufferSnapshot | undefined;
+    /**
+     * Emit the current snapshot immediately.
+     */
+    flush(reason?: MarkdownStreamBufferSnapshot['reason']): MarkdownStreamBufferSnapshot;
+    /**
+     * Mark the stream as complete and flush one final snapshot.
+     */
+    complete(): MarkdownStreamBufferSnapshot;
+    /**
+     * Clear the buffered state and cancel any pending frame.
+     */
+    reset(): void;
+    /**
+     * Cancel future work and release the retained state.
+     */
+    dispose(): void;
+    private handleEndOfStreamToken;
+    private scheduleFlush;
+    private commitStableLines;
+    private buildHealthyOutput;
+    private buildHealthyTail;
+    private closeInlineMarkdown;
+    private closeLinksAndImages;
+    private getPairedRules;
+    private closeSymmetricPairedMarkers;
+    private closeAsymmetricPairedMarkers;
+    private closeLineMarkers;
+    private closeTrailingLink;
+    private closeTrailingImage;
+    private closeTrailingImageSignal;
+    private findTrailingLink;
+    private findTrailingImage;
+    private findTrailingInlineConstruct;
+}

package/dist/types/utils/objects/MDStreamBuffer/_defaults.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownAutoCloseRule } from './_types';
+export declare const DEFAULT_MAX_DEFERRED_CHARACTERS = 48;
+export declare const DEFAULT_WATCHED_MARKERS: MarkdownAutoCloseRule[];

package/dist/types/utils/objects/MDStreamBuffer/_types.d.ts

@@ -0,0 +1,25 @@
+export interface MarkdownStreamBufferSnapshot {
+    raw: string;
+    healthy: string;
+    reason: 'raf' | 'manual' | 'complete';
+    isComplete: boolean;
+}
+export interface MarkdownAutoCloseRule {
+    name?: string;
+    open: string;
+    close: string;
+    mode?: 'paired' | 'line';
+    linePattern?: RegExp;
+    partialLinePattern?: RegExp;
+    requiresLineStart?: boolean;
+    requiresContent?: boolean;
+}
+export interface MarkdownStreamBufferOptions {
+    endOfStreamToken?: string;
+    htmlHandling?: 'ignore' | 'strip';
+    includeLinksAndImages?: boolean;
+    onFlush?: (snapshot: MarkdownStreamBufferSnapshot) => void;
+    requestFrame?: (callback: FrameRequestCallback) => number;
+    cancelFrame?: (handle: number) => void;
+    watchedMarkers?: MarkdownAutoCloseRule[];
+}

package/dist/types/utils/objects/WebRTCConnection/WebRTCConnection.d.ts

@@ -0,0 +1,86 @@
+import type { WebRTCConnectionOptions } from './_types';
+export declare class WebRTCConnection {
+    private readonly peerConnection;
+    private readonly RTCSenderAudioTrack?;
+    private readonly RTCSenderVideoTrack?;
+    private RTCScreenShareTrack;
+    private RTCScreenShareSender;
+    private readonly RTCReceiverAudioStream;
+    private readonly RTCReceiverVideoTracks;
+    private readonly RTCReceiverAudioTracks;
+    private readonly RTCDataChannels;
+    private readonly connectionUrl;
+    private connectionOffer;
+    private audioElement;
+    private readonly autoPlayAudio;
+    private readonly onRemoteAudioStream?;
+    private readonly onRemoteVideoStream?;
+    private readonly onDataChannelEvent?;
+    private iceTimer?;
+    private offerOptions?;
+    private bearerToken?;
+    /**
+     * Create the base instance
+     */
+    constructor(rtcConnectionInfo: WebRTCConnectionOptions);
+    /**
+     * Initialize the RTC connection
+     */
+    initialize(offerOptions?: RTCOfferOptions, bearerToken?: string): Promise<void>;
+    /**
+     * Start an optional screen share stream and renegotiate if already connected
+     */
+    startScreenShare(): Promise<void>;
+    /**
+     * Stop the optional screen share stream and renegotiate if already connected
+     */
+    stopScreenShare(stopTrack?: boolean): Promise<void>;
+    /**
+     * Create an offer, wait for ICE gathering, POST SDP, and apply the answer
+     */
+    private negotiate;
+    /**
+     * Send a JSON-serializable payload over a named data channel
+     */
+    sendMessage(channelName: string, data: string | number | boolean | object | null): void;
+    /**
+     * Mute or unmute all incoming audio playback
+     */
+    muteAllAudio(muted: boolean): void;
+    /**
+     * Mute or unmute a specific incoming audio track
+     */
+    muteAudioTrack(trackId: string, muted: boolean): void;
+    /**
+     * Set the playback volume for the incoming audio element
+     */
+    setAudioVolume(volume: number): void;
+    /**
+     * Create an audio source node from the unified incoming audio stream
+     */
+    createIncomingAudioSource(audioContext: AudioContext): MediaStreamAudioSourceNode;
+    /**
+     * Handle track events adding them to the unified audio and video streams
+     */
+    private onTrack;
+    /**
+     * Create a local audio element and set its source to the rtc incoming media stream
+     */
+    private setupIncomingAudioStream;
+    /**
+     * Set up a local stream with mic and video tracks and add to peer connection
+     */
+    private setupOutgoingMediaStream;
+    /**
+     * Setup data channels
+     */
+    private setupDataChannels;
+    /**
+     * Add listeners for data events and push through callback
+     */
+    private setupDataChannelEventListeners;
+    /**
+     * Wait for the ICE gathering to be complete
+     */
+    private waitForIceGathering;
+}

package/dist/types/utils/objects/WebRTCConnection/_types.d.ts

@@ -0,0 +1,11 @@
+export interface WebRTCConnectionOptions {
+    connectionUrl?: string;
+    audioElement?: HTMLAudioElement;
+    autoPlayAudio?: boolean;
+    dataChannels?: string | string[];
+    micMediaTrack: MediaStreamTrack;
+    videoMediaTrack?: MediaStreamTrack;
+    onRemoteVideoStream?: (streams: Map<string, MediaStream>) => void;
+    onRemoteAudioStream?: (streams: Map<string, MediaStream>) => void;
+    onDataChannelEvent?: (channel: string, eventType: 'message' | 'open' | 'close' | 'error', eventData: MessageEvent | Event | RTCErrorEvent) => void;
+}

package/dist/types/utils/objects/audioVisualizer/audioVisualizer.d.ts

@@ -0,0 +1,40 @@
+type AudioVisualizerSource = MediaStream | MediaStreamTrack;
+type AudioVisualizerOptions = {
+    fftSize?: number;
+    intensityMultiplier?: number;
+    maxScale?: number;
+    minScale?: number;
+    onUpdate?: (state: {
+        intensity: number;
+        scale: number;
+    }) => void;
+    peakIntensity?: number;
+    releasePerSecond?: number;
+    risePerSecond?: number;
+};
+export declare class AudioVisualizer {
+    private readonly fftSize;
+    private readonly intensityMultiplier;
+    private readonly maxScale;
+    private readonly minScale;
+    private readonly onUpdate?;
+    private readonly peakIntensity;
+    private readonly releasePerSecond;
+    private readonly risePerSecond;
+    private readonly source;
+    private analyser;
+    private animationFrameId;
+    private audioContext;
+    private currentIntensity;
+    private lastFrameTime;
+    private sourceNode;
+    private timeDomainData;
+    constructor(source: AudioVisualizerSource, options?: AudioVisualizerOptions);
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    getIntensity(): number;
+    getScale(): number;
+    private readonly onFrame;
+}
+export type { AudioVisualizerOptions, AudioVisualizerSource };

package/dist/types/utils/objects/index.d.ts

@@ -1,5 +1,9 @@
 export { IndexedDB } from './IndexedDB/IndexedDB';
 export type { IndexedDBOptions } from './IndexedDB/IndexedDB';
+export { AudioVisualizer } from './audioVisualizer/audioVisualizer';
+export type { AudioVisualizerOptions, AudioVisualizerSource, } from './audioVisualizer/audioVisualizer';
+export { MdBuffer } from './MDStreamBuffer/MdStreamBuffer';
+export type { MarkdownAutoCloseRule, MarkdownStreamBufferOptions, MarkdownStreamBufferSnapshot, } from './MDStreamBuffer/_types';
 export { SSEConnection } from './SSEConnection/SSEConnection';
 export { WSConnection } from './WSConnection/WSConnection';
 export type { SSECustomEvent, SSEConnectionCloseOption, SSEConnectionOptions, SSEEventMap, SSEUnifiedBuiltInMessage, SSEUnifiedCustomMessage, SSEUnifiedMessage, } from './SSEConnection/SSEConnection';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@apple-pie/slice",
-	"version": "0.1.21",
+	"version": "0.1.23",
 	"main": "dist/cjs/index.js",
 	"module": "dist/esm/index.mjs",
 	"exports": {