@sdata/web-vue 3.22.3 → 3.24.0

package/es/sender/types.d.ts

@@ -1,5 +1,7 @@
+import type { UnknownRecord } from 'type-fest';
 import type { CSSProperties, Component, VNodeChild } from 'vue';
 import type { TooltipProps } from '../tooltip';
+import type { RecorderCore, RecorderCoreInstance, RecorderCoreOptions } from './recorder-core';
 export type SenderSubmitType = 'enter' | 'shiftEnter';
 export type SenderInsertPosition = 'start' | 'end' | 'cursor';
 export type SenderSuffixPlacement = 'content' | 'footer';
@@ -7,59 +9,7 @@ export type SenderSemanticType = 'root' | 'prefix' | 'input' | 'suffix' | 'foote
 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 type SenderAllowSpeech = boolean | RecorderCoreOptions | UnknownRecord;
 export interface SenderSkillClosableConfig {
     closeIcon?: VNodeChild;
     onClose?: (event: MouseEvent) => void;
@@ -144,6 +94,9 @@ export interface SenderFocusOptions {
     key?: string;
 }
 export interface SenderRef {
+    readonly Recorder: RecorderCore;
+    readonly recorder: RecorderCoreInstance | null;
+    readonly recording: boolean;
     readonly inputElement: HTMLTextAreaElement | HTMLDivElement | null;
     readonly nativeElement: HTMLDivElement | null;
     focus: (options?: SenderFocusOptions) => void;
@@ -201,13 +154,8 @@ export interface SenderEmits {
     '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];
+    'speechEnd': [blob: Blob, duration: number, mime: string];
+    'speechError': [message: string, isUserNotAllow: boolean];
 }
 export type SenderHeaderSemanticType = 'header' | 'content';
 export interface SenderHeaderProps {

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

@@ -0,0 +1,16 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { SenderAllowSpeech } from './types';
+export interface UseRecorderOptions {
+    onStop?: (blob: Blob, duration: number, mime: string) => void;
+    onError?: (message: string, isUserNotAllow: boolean) => void;
+}
+export declare function useRecorder(allowSpeech: MaybeRefOrGetter<SenderAllowSpeech | undefined>, options?: UseRecorderOptions): {
+    Recorder: any;
+    available: import("vue").ComputedRef<boolean>;
+    recorder: import("vue").ShallowRef<any, any>;
+    recording: import("vue").ShallowRef<boolean, boolean>;
+    requesting: import("vue").ShallowRef<boolean, boolean>;
+    stopping: import("vue").ShallowRef<boolean, boolean>;
+    statusText: import("vue").ComputedRef<string>;
+    trigger: () => void;
+};

package/es/sender/use-recorder.js

@@ -0,0 +1,117 @@
+import { useI18n } from "../locale/index.js";
+import recorder_core_default from "./recorder-core.js";
+import { computed, onBeforeUnmount, onMounted, shallowRef, toValue, watch } from "vue";
+//#region components/sender/use-recorder.ts
+function useRecorder(allowSpeech, options = {}) {
+	const { t } = useI18n();
+	const config = computed(() => toValue(allowSpeech));
+	const supported = shallowRef(false);
+	const recording = shallowRef(false);
+	const requesting = shallowRef(false);
+	const stopping = shallowRef(false);
+	const permissionDenied = shallowRef(false);
+	const captureError = shallowRef();
+	const recorder = shallowRef();
+	let mounted = false;
+	let supportChecked = false;
+	let disposed = false;
+	const available = computed(() => Boolean(config.value) && supported.value && !permissionDenied.value);
+	const statusText = computed(() => {
+		if (requesting.value) return t("sender.speech.requestingPermission");
+		if (permissionDenied.value) return t("sender.speech.permissionDenied");
+		if (captureError.value) return t("sender.speech.microphoneUnavailable");
+		if (!supported.value) return t("sender.speech.unsupported");
+		if (recording.value) return t("sender.speech.stop");
+		return t("sender.speech.start");
+	});
+	const close = () => {
+		var _recorder$value;
+		(_recorder$value = recorder.value) === null || _recorder$value === void 0 || _recorder$value.close();
+		recorder.value = void 0;
+		recording.value = false;
+		requesting.value = false;
+		stopping.value = false;
+	};
+	const stop = () => {
+		const current = recorder.value;
+		if (!current || !recording.value || requesting.value || stopping.value) return;
+		stopping.value = true;
+		const finish = () => {
+			recording.value = false;
+			requesting.value = false;
+			stopping.value = false;
+			recorder.value = void 0;
+		};
+		current.stop((blob, duration, mime) => {
+			var _options$onStop;
+			if (disposed) return;
+			(_options$onStop = options.onStop) === null || _options$onStop === void 0 || _options$onStop.call(options, blob, duration, mime);
+			finish();
+		}, (message) => {
+			var _options$onError;
+			if (disposed) return;
+			(_options$onError = options.onError) === null || _options$onError === void 0 || _options$onError.call(options, message, false);
+			finish();
+		}, true);
+	};
+	const start = () => {
+		if (!available.value || requesting.value || recording.value || stopping.value) return;
+		requesting.value = true;
+		permissionDenied.value = false;
+		captureError.value = void 0;
+		const current = recorder_core_default(typeof config.value === "object" ? config.value : {});
+		recorder.value = current;
+		current.open(() => {
+			if (disposed || recorder.value !== current) {
+				current.close();
+				return;
+			}
+			current.start();
+			recording.value = true;
+			requesting.value = false;
+		}, (message, isUserNotAllow) => {
+			var _options$onError2;
+			current.close();
+			if (disposed || recorder.value !== current) return;
+			recorder.value = void 0;
+			permissionDenied.value = isUserNotAllow;
+			if (!isUserNotAllow) captureError.value = message;
+			recording.value = false;
+			requesting.value = false;
+			(_options$onError2 = options.onError) === null || _options$onError2 === void 0 || _options$onError2.call(options, message, isUserNotAllow);
+		});
+	};
+	const trigger = () => {
+		if (recording.value) stop();
+		else start();
+	};
+	const checkSupport = () => {
+		if (supportChecked) return;
+		supportChecked = true;
+		supported.value = recorder_core_default.Support();
+	};
+	onMounted(() => {
+		mounted = true;
+		if (config.value) checkSupport();
+	});
+	watch(() => Boolean(config.value), (enabled) => {
+		if (enabled && mounted) checkSupport();
+		else if (!enabled) close();
+	});
+	onBeforeUnmount(() => {
+		disposed = true;
+		close();
+	});
+	return {
+		Recorder: recorder_core_default,
+		available,
+		recorder,
+		recording,
+		requesting,
+		stopping,
+		statusText,
+		trigger
+	};
+}
+//#endregion
+export { useRecorder };

package/json/vetur-attributes.json

@@ -2433,6 +2433,101 @@
     "description": "Whether to hide the title",
     "type": "boolean"
   },
+  "sd-model-selector-content/title": {
+    "description": "Accessible dialog title",
+    "type": "string"
+  },
+  "sd-model-selector-content/width": {
+    "description": "Dialog width"
+  },
+  "sd-model-selector-content/render-to-body": {
+    "description": "Whether to render under body",
+    "type": "boolean"
+  },
+  "sd-model-selector-content/unmount-on-close": {
+    "description": "Whether to unmount content when closed",
+    "type": "boolean"
+  },
+  "sd-model-selector-content/mask-closable": {
+    "description": "Whether clicking the mask closes the dialog",
+    "type": "boolean"
+  },
+  "sd-model-selector-content/esc-to-close": {
+    "description": "Whether Escape closes the dialog",
+    "type": "boolean"
+  },
+  "sd-model-selector-group/heading": {
+    "description": "Group heading",
+    "type": "string"
+  },
+  "sd-model-selector-input/model-value": {
+    "description": "Search query",
+    "type": "string"
+  },
+  "sd-model-selector-input/input-attrs": {
+    "description": "Attributes forwarded to the underlying native input"
+  },
+  "sd-model-selector-item/select": {
+    "description": "Emitted when selected"
+  },
+  "sd-model-selector-item/value": {
+    "description": "Item value",
+    "type": "string"
+  },
+  "sd-model-selector-item/label": {
+    "description": "Search label; rendered text is used when omitted",
+    "type": "string"
+  },
+  "sd-model-selector-item/keywords": {
+    "description": "Additional search keywords"
+  },
+  "sd-model-selector-item/disabled": {
+    "description": "Whether the item is disabled",
+    "type": "boolean"
+  },
+  "sd-model-selector-item/selected": {
+    "description": "Whether the item is selected",
+    "type": "boolean"
+  },
+  "sd-model-selector-item/shortcut": {
+    "description": "Shortcut for selecting this item, using the VueUse useMagicKeys format, such as Alt+Shift+1",
+    "type": "string"
+  },
+  "sd-model-selector-logo/provider": {
+    "description": "Provider id; unknown ids use the local fallback logo"
+  },
+  "sd-model-selector-logo/alt": {
+    "description": "Alternative text",
+    "type": "string"
+  },
+  "sd-model-selector-logo/width": {
+    "description": "Logo width"
+  },
+  "sd-model-selector-logo/height": {
+    "description": "Logo height"
+  },
+  "sd-model-selector-trigger/disabled": {
+    "description": "Whether the trigger is disabled",
+    "type": "boolean"
+  },
+  "sd-model-selector/visible-change": {
+    "description": "Emitted when visibility changes"
+  },
+  "sd-model-selector/select": {
+    "description": "Emitted when the user selects a model"
+  },
+  "sd-model-selector/default-visible": {
+    "description": "Whether the model selector is visible by default",
+    "type": "boolean"
+  },
+  "sd-model-selector/close-on-select": {
+    "description": "Whether to close after selecting a model",
+    "type": "boolean"
+  },
+  "sd-model-selector/reset-query-on-close": {
+    "description": "Whether to reset the query when closed",
+    "type": "boolean"
+  },
   "sd-overflow-list/change": {
     "description": "Triggered when the overflow quantity changes"
   },
@@ -3038,7 +3133,7 @@
     "description": "Structured slot configuration"
   },
   "sd-sender/allow-speech": {
-    "description": "AudioWorklet capture, streaming transport, or controlled recording configuration"
+    "description": "Whether recording is enabled; an object value is passed to recorder-core as-is"
   },
   "sd-sender/auto-size": {
     "description": "Textarea auto-size configuration"

package/json/vetur-tags.json

@@ -993,6 +993,81 @@
       "hide-title"
     ]
   },
+  "sd-model-selector-content": {
+    "attributes": [
+      "title",
+      "width",
+      "render-to-body",
+      "unmount-on-close",
+      "mask-closable",
+      "esc-to-close"
+    ]
+  },
+  "sd-model-selector-dialog": {
+    "attributes": []
+  },
+  "sd-model-selector-empty": {
+    "attributes": []
+  },
+  "sd-model-selector-group": {
+    "attributes": [
+      "heading"
+    ]
+  },
+  "sd-model-selector-input": {
+    "attributes": [
+      "model-value",
+      "input-attrs"
+    ]
+  },
+  "sd-model-selector-item": {
+    "attributes": [
+      "select",
+      "value",
+      "label",
+      "keywords",
+      "disabled",
+      "selected",
+      "shortcut"
+    ]
+  },
+  "sd-model-selector-list": {
+    "attributes": []
+  },
+  "sd-model-selector-logo-group": {
+    "attributes": []
+  },
+  "sd-model-selector-logo": {
+    "attributes": [
+      "provider",
+      "alt",
+      "width",
+      "height"
+    ]
+  },
+  "sd-model-selector-name": {
+    "attributes": []
+  },
+  "sd-model-selector-separator": {
+    "attributes": []
+  },
+  "sd-model-selector-shortcut": {
+    "attributes": []
+  },
+  "sd-model-selector-trigger": {
+    "attributes": [
+      "disabled"
+    ]
+  },
+  "sd-model-selector": {
+    "attributes": [
+      "visible-change",
+      "select",
+      "default-visible",
+      "close-on-select",
+      "reset-query-on-close"
+    ]
+  },
   "sd-overflow-list": {
     "attributes": [
       "change",