@sdata/web-vue 3.18.0 → 3.20.0

package/es/sender/types.d.ts

@@ -0,0 +1,228 @@
+import type { CSSProperties, Component, VNodeChild } from 'vue';
+import type { TooltipProps } from '../tooltip';
+export type SenderSubmitType = 'enter' | 'shiftEnter';
+export type SenderInsertPosition = 'start' | 'end' | 'cursor';
+export type SenderSuffixPlacement = 'content' | 'footer';
+export type SenderSemanticType = 'root' | 'prefix' | 'input' | 'suffix' | 'footer' | 'switch' | 'content';
+export interface SenderComponents {
+    input?: Component;
+}
+export interface SenderSpeechConfig {
+    recording?: boolean;
+    onRecordingChange?: (recording: boolean) => void;
+    audioConstraints?: MediaTrackConstraints;
+    bufferSize?: number;
+    workletUrl?: string;
+    processorName?: string;
+    processorOptions?: Record<string, unknown>;
+    url?: string;
+    protocols?: string | string[];
+    sendMetadata?: boolean;
+}
+export type SenderControlledSpeechConfig = SenderSpeechConfig;
+export type SenderAllowSpeech = boolean | SenderSpeechConfig;
+export interface SenderSpeechStartEvent {
+    source: 'capture' | 'controlled';
+    startedAt: number;
+    stream?: MediaStream;
+    audioContext?: AudioContext;
+    sampleRate?: number;
+}
+export interface SenderSpeechDataEvent {
+    buffer: ArrayBuffer;
+    sampleRate: number;
+    sequence: number;
+    timestamp: number;
+}
+export type SenderSpeechEndReason = 'manual' | 'controlled' | 'error' | 'unmount';
+export interface SenderSpeechEndEvent {
+    source: 'capture' | 'controlled';
+    reason: SenderSpeechEndReason;
+    startedAt: number;
+    endedAt: number;
+    duration: number;
+    chunks: number;
+}
+export type SenderSpeechErrorPhase = 'permission' | 'audioContext' | 'audioWorklet' | 'transport';
+export interface SenderSpeechErrorEvent {
+    error: Error;
+    phase: SenderSpeechErrorPhase;
+}
+export interface SenderSpeechTransportOpenEvent {
+    event: Event;
+    socket: WebSocket;
+}
+export interface SenderSpeechTransportMessageEvent {
+    event: MessageEvent;
+    socket: WebSocket;
+}
+export interface SenderSpeechTransportCloseEvent {
+    event: CloseEvent;
+    socket: WebSocket;
+}
+export interface SenderSkillClosableConfig {
+    closeIcon?: VNodeChild;
+    onClose?: (event: MouseEvent) => void;
+    disabled?: boolean;
+}
+export interface SenderSkill {
+    title?: VNodeChild;
+    value: string;
+    tooltip?: string | TooltipProps;
+    closable?: boolean | SenderSkillClosableConfig;
+}
+export interface SenderSlotConfigBase {
+    type: 'text' | 'input' | 'select' | 'tag' | 'custom' | 'content';
+    formatResult?: (value: unknown) => string;
+}
+export interface SenderTextSlotConfig extends SenderSlotConfigBase {
+    type: 'text';
+    value?: string;
+    editable?: boolean;
+    placeholder?: string;
+    key?: string;
+}
+export interface SenderInputSlotConfig extends SenderSlotConfigBase {
+    type: 'input';
+    key: string;
+    props?: {
+        defaultValue?: string | number;
+        placeholder?: string;
+    };
+}
+export interface SenderSelectSlotConfig extends SenderSlotConfigBase {
+    type: 'select';
+    key: string;
+    props?: {
+        defaultValue?: string;
+        options: string[];
+        placeholder?: string;
+    };
+}
+export interface SenderTagSlotConfig extends SenderSlotConfigBase {
+    type: 'tag';
+    key: string;
+    props?: {
+        label: string | number;
+        value?: string;
+    };
+}
+export interface SenderContentSlotConfig extends SenderSlotConfigBase {
+    type: 'content';
+    key: string;
+    props?: {
+        defaultValue?: unknown;
+        placeholder?: string;
+    };
+}
+export interface SenderCustomSlotState {
+    disabled?: boolean;
+    readonly?: boolean;
+}
+export type SenderCustomSlotRender = (value: unknown, onChange: (value: unknown) => void, state: SenderCustomSlotState, item: SenderCustomSlotConfig) => VNodeChild;
+export interface SenderCustomSlotConfig extends SenderSlotConfigBase {
+    type: 'custom';
+    key: string;
+    props?: {
+        defaultValue?: unknown;
+        [key: string]: unknown;
+    };
+    customRender?: SenderCustomSlotRender;
+}
+export type SenderSlotConfig = SenderTextSlotConfig | SenderInputSlotConfig | SenderSelectSlotConfig | SenderTagSlotConfig | SenderContentSlotConfig | SenderCustomSlotConfig;
+export type SenderResolvedSlotConfig = SenderSlotConfig & {
+    value?: unknown;
+};
+export interface SenderValue {
+    value: string;
+    slotConfig: SenderResolvedSlotConfig[];
+    skill?: SenderSkill;
+}
+export interface SenderFocusOptions {
+    preventScroll?: boolean;
+    cursor?: 'start' | 'end' | 'all' | 'slot';
+    key?: string;
+}
+export interface SenderRef {
+    readonly inputElement: HTMLTextAreaElement | HTMLDivElement | null;
+    readonly nativeElement: HTMLDivElement | null;
+    focus: (options?: SenderFocusOptions) => void;
+    blur: () => void;
+    insert: (value: string | SenderSlotConfig[], position?: SenderInsertPosition, replaceCharacters?: string, preventScroll?: boolean) => void;
+    clear: () => void;
+    getValue: () => SenderValue;
+}
+export interface SenderActionContext {
+    send: () => void;
+    clear: () => void;
+    cancel: () => void;
+    speech: () => void;
+    submitDisabled: boolean;
+    clearDisabled: boolean;
+    cancelDisabled: boolean;
+    speechDisabled: boolean;
+    recording: boolean;
+    loading: boolean;
+}
+export interface SenderProps {
+    modelValue?: string;
+    defaultValue?: string;
+    loading?: boolean;
+    readonly?: boolean | string;
+    submitType?: SenderSubmitType;
+    disabled?: boolean;
+    slotConfig?: readonly SenderSlotConfig[];
+    allowSpeech?: SenderAllowSpeech;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    skill?: SenderSkill;
+    placeholder?: string;
+    showActions?: boolean;
+    suffixPlacement?: SenderSuffixPlacement;
+    components?: SenderComponents;
+    classNames?: Partial<Record<SenderSemanticType, string>>;
+    styles?: Partial<Record<SenderSemanticType, CSSProperties>>;
+    onKeydown?: (event: KeyboardEvent) => void | false;
+    onKeyup?: (event: KeyboardEvent) => void;
+}
+export interface SenderEmits {
+    'update:modelValue': [value: string];
+    'change': [
+        value: string,
+        event: Event | undefined,
+        slotConfig: SenderResolvedSlotConfig[],
+        skill: SenderSkill | undefined
+    ];
+    'submit': [value: string, slotConfig: SenderResolvedSlotConfig[], skill: SenderSkill | undefined];
+    'cancel': [];
+    'paste': [event: ClipboardEvent];
+    'pasteFile': [files: FileList];
+    'focus': [event: FocusEvent];
+    'blur': [event: FocusEvent];
+    'speechStart': [event: SenderSpeechStartEvent];
+    'speechData': [event: SenderSpeechDataEvent];
+    'speechEnd': [event: SenderSpeechEndEvent];
+    'speechError': [event: SenderSpeechErrorEvent];
+    'speechTransportOpen': [event: SenderSpeechTransportOpenEvent];
+    'speechTransportMessage': [event: SenderSpeechTransportMessageEvent];
+    'speechTransportClose': [event: SenderSpeechTransportCloseEvent];
+}
+export type SenderHeaderSemanticType = 'header' | 'content';
+export interface SenderHeaderProps {
+    open?: boolean;
+    forceRender?: boolean;
+    title?: VNodeChild;
+    closable?: boolean;
+    classNames?: Partial<Record<SenderHeaderSemanticType, string>>;
+    styles?: Partial<Record<SenderHeaderSemanticType, CSSProperties>>;
+}
+export interface SenderSwitchProps {
+    modelValue?: boolean;
+    defaultValue?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    classNames?: Partial<Record<'root' | 'content' | 'icon' | 'title', string>>;
+    styles?: Partial<Record<'root' | 'content' | 'icon' | 'title', CSSProperties>>;
+}

package/es/sender/use-speech.d.ts

@@ -0,0 +1,19 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { SenderAllowSpeech, SenderSpeechDataEvent, SenderSpeechEndEvent, SenderSpeechErrorEvent, SenderSpeechStartEvent, SenderSpeechTransportCloseEvent, SenderSpeechTransportMessageEvent, SenderSpeechTransportOpenEvent } from './types';
+interface UseSpeechOptions {
+    onStart: (event: SenderSpeechStartEvent) => void;
+    onData: (event: SenderSpeechDataEvent) => void;
+    onEnd: (event: SenderSpeechEndEvent) => void;
+    onError: (event: SenderSpeechErrorEvent) => void;
+    onTransportOpen: (event: SenderSpeechTransportOpenEvent) => void;
+    onTransportMessage: (event: SenderSpeechTransportMessageEvent) => void;
+    onTransportClose: (event: SenderSpeechTransportCloseEvent) => void;
+}
+export declare function useSpeech(allowSpeech: MaybeRefOrGetter<SenderAllowSpeech | undefined>, options: UseSpeechOptions): {
+    available: import("vue").ComputedRef<boolean>;
+    recording: import("vue").ComputedRef<boolean>;
+    requesting: import("vue").ShallowRef<boolean, boolean>;
+    statusText: import("vue").ComputedRef<string>;
+    trigger: (breakRecording?: boolean) => Promise<void>;
+};
+export {};

package/es/sender/use-speech.js

@@ -0,0 +1,338 @@
+import _objectSpread2 from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/objectSpread2.js";
+import { useI18n } from "../locale/index.js";
+import _asyncToGenerator from "../_virtual/_@oxc-project_runtime@0.139.0/helpers/esm/asyncToGenerator.js";
+import { computed, onBeforeUnmount, onMounted, shallowRef, toValue, watch } from "vue";
+//#region components/sender/use-speech.ts
+var DEFAULT_PROCESSOR_NAME = "sd-sender-audio-processor";
+var DEFAULT_BUFFER_SIZE = 4096;
+var resolveBufferSize = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(128, Math.floor(value)) : DEFAULT_BUFFER_SIZE;
+var WORKLET_SOURCE = `
+class SdSenderAudioProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    this.bufferSize = Math.max(128, options.processorOptions?.bufferSize || ${DEFAULT_BUFFER_SIZE});
+    this.buffer = new Float32Array(this.bufferSize);
+    this.offset = 0;
+    this.port.onmessage = (event) => {
+      if (event.data?.type !== 'flush') return;
+      if (this.offset > 0) {
+        const chunk = this.buffer.slice(0, this.offset);
+        this.port.postMessage(chunk.buffer, [chunk.buffer]);
+        this.offset = 0;
+      }
+      this.port.postMessage({ type: 'flushed' });
+    };
+  }
+
+  process(inputs) {
+    const channels = inputs[0];
+    if (!channels?.length) return true;
+    const frames = channels[0].length;
+    for (let frame = 0; frame < frames; frame += 1) {
+      let sample = 0;
+      for (let channel = 0; channel < channels.length; channel += 1) {
+        sample += channels[channel][frame] || 0;
+      }
+      this.buffer[this.offset] = sample / channels.length;
+      this.offset += 1;
+      if (this.offset === this.bufferSize) {
+        const chunk = this.buffer;
+        this.port.postMessage(chunk.buffer, [chunk.buffer]);
+        this.buffer = new Float32Array(this.bufferSize);
+        this.offset = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('${DEFAULT_PROCESSOR_NAME}', SdSenderAudioProcessor);
+`;
+var isPermissionDeniedError = (error) => error instanceof DOMException ? error.name === "NotAllowedError" || error.name === "SecurityError" : error instanceof Error && (error.name === "NotAllowedError" || error.name === "SecurityError");
+function useSpeech(allowSpeech, options) {
+	const { t } = useI18n();
+	const config = computed(() => toValue(allowSpeech));
+	const controlled = computed(() => typeof config.value === "object" && typeof config.value.recording === "boolean" && typeof config.value.onRecordingChange === "function");
+	const supported = shallowRef(false);
+	const internalRecording = shallowRef(false);
+	const requesting = shallowRef(false);
+	const captureError = shallowRef();
+	const stream = shallowRef();
+	const audioContext = shallowRef();
+	const sourceNode = shallowRef();
+	const workletNode = shallowRef();
+	const socket = shallowRef();
+	const startedAt = shallowRef(0);
+	const chunks = shallowRef(0);
+	const sequence = shallowRef(0);
+	let generatedWorkletUrl;
+	let resolveWorkletFlush;
+	let disposed = false;
+	const recording = computed(() => controlled.value && typeof config.value === "object" ? Boolean(config.value.recording) : internalRecording.value);
+	const available = computed(() => Boolean(config.value) && (controlled.value || supported.value) && !(captureError.value && isPermissionDeniedError(captureError.value.error)));
+	const statusText = computed(() => {
+		var _captureError$value;
+		if (requesting.value) return t("sender.speech.requestingPermission");
+		if (captureError.value && isPermissionDeniedError(captureError.value.error)) return t("sender.speech.permissionDenied");
+		if (!controlled.value && !supported.value) return t("sender.speech.unsupported");
+		if (recording.value) return t("sender.speech.stop");
+		if (((_captureError$value = captureError.value) === null || _captureError$value === void 0 ? void 0 : _captureError$value.error.name) === "NotFoundError") return t("sender.speech.noMicrophone");
+		if (captureError.value) return t("sender.speech.microphoneUnavailable");
+		return t("sender.speech.start");
+	});
+	const resolveAudioContext = () => {
+		var _window$AudioContext;
+		const AudioContextConstructor = (_window$AudioContext = window.AudioContext) !== null && _window$AudioContext !== void 0 ? _window$AudioContext : window.webkitAudioContext;
+		if (!AudioContextConstructor) throw new Error("AudioContext is not supported");
+		return new AudioContextConstructor();
+	};
+	const resolveWorkletUrl = () => {
+		var _generatedWorkletUrl;
+		if (typeof config.value === "object" && config.value.workletUrl) return config.value.workletUrl;
+		(_generatedWorkletUrl = generatedWorkletUrl) !== null && _generatedWorkletUrl !== void 0 || (generatedWorkletUrl = URL.createObjectURL(new Blob([WORKLET_SOURCE], { type: "text/javascript" })));
+		return generatedWorkletUrl;
+	};
+	const connectTransport = (url, protocols) => new Promise((resolve, reject) => {
+		const nextSocket = protocols ? new WebSocket(url, protocols) : new WebSocket(url);
+		let opened = false;
+		socket.value = nextSocket;
+		nextSocket.binaryType = "arraybuffer";
+		nextSocket.onopen = (event) => {
+			opened = true;
+			options.onTransportOpen({
+				event,
+				socket: nextSocket
+			});
+			resolve(nextSocket);
+		};
+		nextSocket.onmessage = (event) => options.onTransportMessage({
+			event,
+			socket: nextSocket
+		});
+		nextSocket.onclose = (event) => options.onTransportClose({
+			event,
+			socket: nextSocket
+		});
+		nextSocket.onerror = () => {
+			const errorEvent = {
+				error: /* @__PURE__ */ new Error(`Unable to connect to speech URL: ${url}`),
+				phase: "transport"
+			};
+			if (opened) options.onError(errorEvent);
+			else reject(errorEvent.error);
+		};
+	});
+	const flushWorklet = () => new Promise((resolve) => {
+		var _workletNode$value;
+		const port = (_workletNode$value = workletNode.value) === null || _workletNode$value === void 0 ? void 0 : _workletNode$value.port;
+		if (!port) {
+			resolve();
+			return;
+		}
+		const timeout = window.setTimeout(resolve, 100);
+		resolveWorkletFlush = () => {
+			window.clearTimeout(timeout);
+			resolveWorkletFlush = void 0;
+			resolve();
+		};
+		port.postMessage({ type: "flush" });
+	});
+	const releaseResources = function() {
+		var _ref = _asyncToGenerator(function* () {
+			var _workletNode$value2, _sourceNode$value, _stream$value, _audioContext$value, _audioContext$value2;
+			(_workletNode$value2 = workletNode.value) === null || _workletNode$value2 === void 0 || _workletNode$value2.disconnect();
+			(_sourceNode$value = sourceNode.value) === null || _sourceNode$value === void 0 || _sourceNode$value.disconnect();
+			(_stream$value = stream.value) === null || _stream$value === void 0 || _stream$value.getTracks().forEach((track) => track.stop());
+			if (((_audioContext$value = audioContext.value) === null || _audioContext$value === void 0 ? void 0 : _audioContext$value.state) !== "closed") yield (_audioContext$value2 = audioContext.value) === null || _audioContext$value2 === void 0 ? void 0 : _audioContext$value2.close();
+			if (socket.value && (socket.value.readyState === WebSocket.OPEN || socket.value.readyState === WebSocket.CONNECTING)) socket.value.close(1e3, "speech-ended");
+			workletNode.value = void 0;
+			sourceNode.value = void 0;
+			stream.value = void 0;
+			audioContext.value = void 0;
+			socket.value = void 0;
+		});
+		return function releaseResources() {
+			return _ref.apply(this, arguments);
+		};
+	}();
+	const stopCapture = function() {
+		var _ref2 = _asyncToGenerator(function* (reason = "manual") {
+			var _socket$value, _config$value$onRecor, _config$value;
+			if (!internalRecording.value) return;
+			yield flushWorklet();
+			const endedAt = performance.now();
+			internalRecording.value = false;
+			if (((_socket$value = socket.value) === null || _socket$value === void 0 ? void 0 : _socket$value.readyState) === WebSocket.OPEN && typeof config.value === "object" && config.value.sendMetadata !== false) socket.value.send(JSON.stringify({
+				type: "end",
+				reason
+			}));
+			yield releaseResources();
+			if (typeof config.value === "object") (_config$value$onRecor = (_config$value = config.value).onRecordingChange) === null || _config$value$onRecor === void 0 || _config$value$onRecor.call(_config$value, false);
+			options.onEnd({
+				source: "capture",
+				reason,
+				startedAt: startedAt.value,
+				endedAt,
+				duration: endedAt - startedAt.value,
+				chunks: chunks.value
+			});
+		});
+		return function stopCapture() {
+			return _ref2.apply(this, arguments);
+		};
+	}();
+	const startCapture = function() {
+		var _ref3 = _asyncToGenerator(function* () {
+			if (requesting.value || internalRecording.value || !available.value) return;
+			requesting.value = true;
+			captureError.value = void 0;
+			let phase = "permission";
+			try {
+				var _speechConfig$audioCo, _speechConfig$process, _socket$value3, _speechConfig$onRecor;
+				const speechConfig = typeof config.value === "object" ? config.value : void 0;
+				const bufferSize = resolveBufferSize(speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.bufferSize);
+				stream.value = yield navigator.mediaDevices.getUserMedia({
+					audio: (_speechConfig$audioCo = speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.audioConstraints) !== null && _speechConfig$audioCo !== void 0 ? _speechConfig$audioCo : true,
+					video: false
+				});
+				if (disposed) {
+					yield releaseResources();
+					return;
+				}
+				if (speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.url) {
+					phase = "transport";
+					yield connectTransport(speechConfig.url, speechConfig.protocols);
+					if (disposed) {
+						yield releaseResources();
+						return;
+					}
+				}
+				phase = "audioContext";
+				const nextAudioContext = resolveAudioContext();
+				audioContext.value = nextAudioContext;
+				phase = "audioWorklet";
+				yield nextAudioContext.audioWorklet.addModule(resolveWorkletUrl());
+				if (disposed) {
+					yield releaseResources();
+					return;
+				}
+				const processorName = (_speechConfig$process = speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.processorName) !== null && _speechConfig$process !== void 0 ? _speechConfig$process : DEFAULT_PROCESSOR_NAME;
+				const nextWorkletNode = new AudioWorkletNode(nextAudioContext, processorName, {
+					numberOfInputs: 1,
+					numberOfOutputs: 0,
+					channelCount: 1,
+					processorOptions: _objectSpread2(_objectSpread2({}, speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.processorOptions), {}, { bufferSize })
+				});
+				workletNode.value = nextWorkletNode;
+				sourceNode.value = nextAudioContext.createMediaStreamSource(stream.value);
+				nextWorkletNode.port.onmessage = (event) => {
+					var _socket$value2;
+					if (!(event.data instanceof ArrayBuffer) && "type" in event.data) {
+						if (event.data.type === "flushed") resolveWorkletFlush === null || resolveWorkletFlush === void 0 || resolveWorkletFlush();
+						return;
+					}
+					if (!internalRecording.value) return;
+					const buffer = event.data;
+					const dataEvent = {
+						buffer,
+						sampleRate: nextAudioContext.sampleRate,
+						sequence: sequence.value,
+						timestamp: performance.now()
+					};
+					sequence.value += 1;
+					chunks.value += 1;
+					options.onData(dataEvent);
+					if (((_socket$value2 = socket.value) === null || _socket$value2 === void 0 ? void 0 : _socket$value2.readyState) === WebSocket.OPEN) socket.value.send(buffer);
+				};
+				sourceNode.value.connect(nextWorkletNode);
+				startedAt.value = performance.now();
+				chunks.value = 0;
+				sequence.value = 0;
+				internalRecording.value = true;
+				if (((_socket$value3 = socket.value) === null || _socket$value3 === void 0 ? void 0 : _socket$value3.readyState) === WebSocket.OPEN && (speechConfig === null || speechConfig === void 0 ? void 0 : speechConfig.sendMetadata) !== false) socket.value.send(JSON.stringify({
+					type: "start",
+					format: "pcm-f32",
+					channels: 1,
+					sampleRate: nextAudioContext.sampleRate,
+					bufferSize
+				}));
+				speechConfig === null || speechConfig === void 0 || (_speechConfig$onRecor = speechConfig.onRecordingChange) === null || _speechConfig$onRecor === void 0 || _speechConfig$onRecor.call(speechConfig, true);
+				options.onStart({
+					source: "capture",
+					startedAt: startedAt.value,
+					stream: stream.value,
+					audioContext: nextAudioContext,
+					sampleRate: nextAudioContext.sampleRate
+				});
+			} catch (error) {
+				const errorEvent = {
+					error: error instanceof Error ? error : new Error(String(error)),
+					phase
+				};
+				captureError.value = errorEvent;
+				options.onError(errorEvent);
+				yield releaseResources();
+			} finally {
+				requesting.value = false;
+			}
+		});
+		return function startCapture() {
+			return _ref3.apply(this, arguments);
+		};
+	}();
+	const trigger = function() {
+		var _ref4 = _asyncToGenerator(function* (breakRecording = false) {
+			if (breakRecording && !recording.value) return;
+			if (controlled.value && typeof config.value === "object") {
+				var _config$value$onRecor2, _config$value2;
+				const nextRecording = !recording.value;
+				(_config$value$onRecor2 = (_config$value2 = config.value).onRecordingChange) === null || _config$value$onRecor2 === void 0 || _config$value$onRecor2.call(_config$value2, nextRecording);
+				const now = performance.now();
+				if (nextRecording) {
+					startedAt.value = now;
+					options.onStart({
+						source: "controlled",
+						startedAt: now
+					});
+				} else options.onEnd({
+					source: "controlled",
+					reason: "controlled",
+					startedAt: startedAt.value,
+					endedAt: now,
+					duration: now - startedAt.value,
+					chunks: 0
+				});
+				return;
+			}
+			if (internalRecording.value) yield stopCapture();
+			else yield startCapture();
+		});
+		return function trigger() {
+			return _ref4.apply(this, arguments);
+		};
+	}();
+	onMounted(() => {
+		var _navigator$mediaDevic;
+		supported.value = Boolean(typeof ((_navigator$mediaDevic = navigator.mediaDevices) === null || _navigator$mediaDevic === void 0 ? void 0 : _navigator$mediaDevic.getUserMedia) === "function" && typeof AudioContext !== "undefined" && typeof AudioWorkletNode !== "undefined");
+	});
+	watch(() => Boolean(config.value), (enabled) => {
+		if (!enabled) stopCapture();
+	});
+	watch(controlled, (nextControlled) => {
+		if (nextControlled) stopCapture();
+	});
+	onBeforeUnmount(_asyncToGenerator(function* () {
+		disposed = true;
+		if (internalRecording.value) yield stopCapture("unmount");
+		else yield releaseResources();
+		if (generatedWorkletUrl) URL.revokeObjectURL(generatedWorkletUrl);
+	}));
+	return {
+		available,
+		recording,
+		requesting,
+		statusText,
+		trigger
+	};
+}
+//#endregion
+export { useSpeech };

package/es/slider/index.d.ts

@@ -63,12 +63,12 @@ declare const Slider: {
         change: (_value: number | [number, number]) => any;
         "update:modelValue": (_value: number | [number, number]) => any;
     }, import("vue").PublicProps, {
+        range: boolean;
         disabled: boolean;
         direction: "horizontal" | "vertical";
         defaultValue: number | [number, number];
         modelValue: number | [number, number];
         max: number;
-        range: boolean;
         step: number;
         min: number;
         showTooltip: boolean;
@@ -136,12 +136,12 @@ declare const Slider: {
         onChange?: ((_value: number | [number, number]) => any) | undefined;
         "onUpdate:modelValue"?: ((_value: number | [number, number]) => any) | undefined;
     }>, {}, {}, {}, {}, {
+        range: boolean;
         disabled: boolean;
         direction: "horizontal" | "vertical";
         defaultValue: number | [number, number];
         modelValue: number | [number, number];
         max: number;
-        range: boolean;
         step: number;
         min: number;
         showTooltip: boolean;
@@ -209,12 +209,12 @@ declare const Slider: {
     change: (_value: number | [number, number]) => any;
     "update:modelValue": (_value: number | [number, number]) => any;
 }, string, {
+    range: boolean;
     disabled: boolean;
     direction: "horizontal" | "vertical";
     defaultValue: number | [number, number];
     modelValue: number | [number, number];
     max: number;
-    range: boolean;
     step: number;
     min: number;
     showTooltip: boolean;

package/es/slider/slider-input.vue.d.ts

@@ -46,8 +46,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     onStartChange?: ((_value?: number | undefined) => any) | undefined;
     onEndChange?: ((_value?: number | undefined) => any) | undefined;
 }>, {
-    disabled: boolean;
     range: boolean;
+    disabled: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/es/slider/slider.vue.d.ts

@@ -109,12 +109,12 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     onChange?: ((_value: number | [number, number]) => any) | undefined;
     "onUpdate:modelValue"?: ((_value: number | [number, number]) => any) | undefined;
 }>, {
+    range: boolean;
     disabled: boolean;
     direction: "horizontal" | "vertical";
     defaultValue: number | [number, number];
     modelValue: number | [number, number];
     max: number;
-    range: boolean;
     step: number;
     min: number;
     showTooltip: boolean;