@bitrix24/b24ui-nuxt 2.1.10 → 2.1.11

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitrix24/b24ui-nuxt",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "docs": "https://bitrix24.github.io/b24ui/guide/installation-nuxt-app.html",
   "configKey": "b24ui",
   "compatibility": {

package/dist/module.mjs

@@ -1,6 +1,6 @@
 import { defu } from 'defu';
 import { defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addComponentsDir, addImportsDir, installModule } from '@nuxt/kit';
-import { d as defaultOptions, v as version, n as name, a as getDefaultConfig, b as addTemplates } from './shared/b24ui-nuxt.BCphUjPy.mjs';
+import { d as defaultOptions, v as version, n as name, a as getDefaultConfig, b as addTemplates } from './shared/b24ui-nuxt.Dh5A-7HA.mjs';
 import 'node:url';
 import 'scule';
 import 'knitwork';

package/dist/runtime/composables/index.d.ts

@@ -6,3 +6,4 @@ export * from './useOverlay';
 export * from './useResizable';
 export * from './useScrollspy';
 export * from './useToast';
+export * from './useSpeechRecognition';

package/dist/runtime/composables/index.js

@@ -6,3 +6,4 @@ export * from "./useOverlay.js";
 export * from "./useResizable.js";
 export * from "./useScrollspy.js";
 export * from "./useToast.js";
+export * from "./useSpeechRecognition.js";

package/dist/runtime/composables/useSpeechRecognition.d.ts

@@ -0,0 +1,122 @@
+import type { Ref, DeepReadonly } from 'vue';
+/**
+ * Speech recognition Web API types
+ * @see /bitrix/js/im/v2/component/textarea/src/components/audio-input/classes/audio-manager.js
+ */
+export type SpeechRecognitionErrorCode = 'aborted' | 'audio-capture' | 'bad-grammar' | 'language-not-supported' | 'network' | 'no-speech' | 'not-allowed' | 'service-not-allowed';
+interface SpeechGrammar {
+    src: string;
+    weight: number;
+}
+interface SpeechGrammarList {
+    readonly length: number;
+    addFromString: (string: string, weight?: number) => void;
+    addFromURI: (src: string, weight?: number) => void;
+    item: (index: number) => SpeechGrammar;
+    [index: number]: SpeechGrammar;
+}
+export interface SpeechRecognitionErrorEvent extends Event {
+    readonly error: SpeechRecognitionErrorCode;
+    readonly message: string;
+}
+interface SpeechRecognitionEvent extends Event {
+    readonly resultIndex: number;
+    readonly results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionEventMap {
+    audioend: Event;
+    audiostart: Event;
+    end: Event;
+    error: SpeechRecognitionErrorEvent;
+    nomatch: SpeechRecognitionEvent;
+    result: SpeechRecognitionEvent;
+    soundend: Event;
+    soundstart: Event;
+    speechend: Event;
+    speechstart: Event;
+    start: Event;
+}
+export interface SpeechRecognition extends EventTarget {
+    continuous: boolean;
+    grammars: SpeechGrammarList;
+    interimResults: boolean;
+    lang: string;
+    maxAlternatives: number;
+    onaudioend: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onaudiostart: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onend: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onerror: ((this: SpeechRecognition, ev: SpeechRecognitionErrorEvent) => any) | null;
+    onnomatch: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
+    onresult: ((this: SpeechRecognition, ev: SpeechRecognitionEvent) => any) | null;
+    onsoundend: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onsoundstart: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onspeechend: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onspeechstart: ((this: SpeechRecognition, ev: Event) => any) | null;
+    onstart: ((this: SpeechRecognition, ev: Event) => any) | null;
+    abort: () => void;
+    start: () => void;
+    stop: () => void;
+    addEventListener: (<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | AddEventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void);
+    removeEventListener: (<K extends keyof SpeechRecognitionEventMap>(type: K, listener: (this: SpeechRecognition, ev: SpeechRecognitionEventMap[K]) => any, options?: boolean | EventListenerOptions) => void) & ((type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions) => void);
+}
+export interface SpeechRecognitionOptions {
+    /** Recognition language (default: 'en-US') */
+    lang?: string;
+    /** Continuous recognition (default: true) */
+    continuous?: boolean;
+    /** Interim results (default: true) */
+    interimResults?: boolean;
+    /** Максимальное количество альтернатив (по умолчанию: 1) */
+    maxAlternatives?: number;
+}
+export interface SpeechRecognitionResult {
+    /** Recognized text */
+    text: string;
+}
+export interface SpeechRecognitionState {
+    /** Whether speech recognition is available in the browser */
+    isAvailable: boolean;
+    /** Whether recognition is currently active */
+    isListening: boolean;
+    /** All recognized text (accumulated if continuous mode) */
+    lastRecognizedText: string;
+}
+export interface SpeechRecognitionControls {
+    /** Start recognition */
+    start: () => Promise<boolean>;
+    /** Stop recognition */
+    stop: () => Promise<boolean>;
+    /** Toggle recognition state */
+    toggle: () => Promise<boolean>;
+    /** Set recognition language */
+    setLanguage: (lang: string) => boolean;
+}
+export interface SpeechRecognitionEvents {
+    /** Called when recognition starts */
+    onStart?: () => void;
+    /** Called when recognition ends */
+    onEnd?: () => void;
+    /** Called on error */
+    onError?: (error: string) => void;
+    /** Called when a result is received */
+    onResult?: (result: SpeechRecognitionResult) => void;
+}
+/**
+ * Universal composable for speech recognition
+ * Can be used with any input components (Input, Textarea, etc.)
+ */
+export declare function useSpeechRecognition(options?: SpeechRecognitionOptions, events?: SpeechRecognitionEvents): {
+    state: DeepReadonly<Ref<SpeechRecognitionState>>;
+    isAvailable: import("vue").ComputedRef<boolean>;
+    isListening: import("vue").ComputedRef<boolean>;
+    start: () => Promise<boolean>;
+    stop: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    setLanguage: (lang: string) => boolean;
+    recognizer: SpeechRecognition | undefined;
+};
+/**
+ * Return type of useSpeechRecognition
+ */
+export type UseSpeechRecognitionReturn = ReturnType<typeof useSpeechRecognition>;
+export {};

package/dist/runtime/composables/useSpeechRecognition.js

@@ -0,0 +1,166 @@
+import { ref, computed, onMounted, onBeforeUnmount, readonly } from "vue";
+export function useSpeechRecognition(options = {}, events = {}) {
+  const {
+    lang = "en-US",
+    continuous = true,
+    interimResults = true,
+    maxAlternatives = 1
+  } = options;
+  const {
+    onStart,
+    onEnd,
+    onError,
+    onResult
+  } = events;
+  const state = ref({
+    isAvailable: false,
+    isListening: false,
+    lastRecognizedText: ""
+  });
+  let recognizer;
+  const isAvailable = computed(() => state.value.isAvailable);
+  const isListening = computed(() => state.value.isListening);
+  const init = () => {
+    if (typeof window === "undefined") {
+      onError?.("Speech recognition is not available in this environment");
+      return false;
+    }
+    const SpeechRecognition = window && (window.SpeechRecognition || window.webkitSpeechRecognition);
+    if (!SpeechRecognition) {
+      state.value.isAvailable = false;
+      onError?.("Speech recognition is not supported in this browser");
+      return false;
+    }
+    try {
+      recognizer = new SpeechRecognition();
+      recognizer.lang = lang;
+      recognizer.continuous = continuous;
+      recognizer.interimResults = interimResults;
+      recognizer.maxAlternatives = maxAlternatives;
+      setupEventHandlers();
+      state.value.isAvailable = true;
+      return true;
+    } catch (error) {
+      onError?.(error instanceof Error ? error.message : "Failed to initialize speech recognition");
+      state.value.isAvailable = false;
+      return false;
+    }
+  };
+  const setupEventHandlers = () => {
+    if (!recognizer) return;
+    recognizer.onstart = () => {
+      state.value.isListening = true;
+      onStart?.();
+    };
+    recognizer.onerror = (event) => {
+      state.value.isListening = false;
+      onError?.(event.error);
+    };
+    recognizer.onend = () => {
+      state.value.isListening = false;
+      onEnd?.();
+    };
+    recognizer.onresult = (event) => {
+      const recognizedText = _getRecognizedText(event);
+      const nextText = _getNewText(recognizedText);
+      if (nextText !== "") {
+        onResult?.({ text: nextText });
+      }
+      state.value.lastRecognizedText = recognizedText;
+    };
+  };
+  const _getRecognizedText = (event) => {
+    let recognizedChunk = "";
+    Object.values(event.results).forEach((result) => {
+      if (result.isFinal) {
+        return;
+      }
+      const [alternative] = result;
+      const { transcript } = alternative;
+      recognizedChunk += transcript;
+    });
+    return recognizedChunk;
+  };
+  const _getNewText = (fullText) => {
+    let additionalText = "";
+    const lastChunkLength = state.value.lastRecognizedText.length;
+    if (fullText.length > lastChunkLength) {
+      additionalText = fullText.slice(lastChunkLength);
+    }
+    return additionalText;
+  };
+  const start = async () => {
+    if (!state.value.isAvailable) {
+      return false;
+    }
+    if (state.value.isListening) {
+      return false;
+    }
+    if (!recognizer) {
+      if (!init()) {
+        return false;
+      }
+    }
+    try {
+      recognizer.start();
+      return true;
+    } catch (error) {
+      onError?.(error instanceof Error ? error.message : "Failed to start speech recognition");
+      return false;
+    }
+  };
+  const stop = async () => {
+    if (!state.value.isListening || !recognizer) {
+      return false;
+    }
+    try {
+      recognizer.stop();
+      return true;
+    } catch (error) {
+      onError?.(error instanceof Error ? error.message : "Failed to stop speech recognition");
+      return false;
+    }
+  };
+  const toggle = async () => {
+    if (state.value.isListening) {
+      return stop();
+    } else {
+      return start();
+    }
+  };
+  const setLanguage = (lang2) => {
+    if (!recognizer) {
+      return false;
+    }
+    try {
+      recognizer.lang = lang2;
+      return true;
+    } catch (error) {
+      onError?.(error instanceof Error ? error.message : "Failed to set language");
+      return false;
+    }
+  };
+  onMounted(() => {
+    init();
+  });
+  onBeforeUnmount(() => {
+    if (state.value.isListening) {
+      stop();
+    }
+    recognizer = void 0;
+  });
+  return {
+    // State (readonly)
+    state: readonly(state),
+    // Computed properties
+    isAvailable,
+    isListening,
+    // Controls
+    start,
+    stop,
+    toggle,
+    setLanguage,
+    // Recognizer instance (for advanced usage)
+    recognizer
+  };
+}

package/dist/shared/{b24ui-nuxt.BCphUjPy.mjs → b24ui-nuxt.Dh5A-7HA.mjs}

@@ -8,7 +8,7 @@ import { globSync } from 'tinyglobby';
 import { defuFn } from 'defu';
 
 const name = "@bitrix24/b24ui-nuxt";
-const version = "2.1.10";
+const version = "2.1.11";
 
 function getDefaultConfig(theme) {
   return {
@@ -3836,6 +3836,7 @@ const inputDate = () => {
       separatorIcon: "shrink-0 size-4 text-(--ui-color-base-6)"
     },
     variants: {
+      ...fieldGroupVariant,
       size: {
         xss: {
           base: (prev) => [prev, "gap-0.20", "px-1"].join(" "),
@@ -4890,6 +4891,7 @@ const inputTime = () => {
       ].join(" ")
     },
     variants: {
+      ...fieldGroupVariant,
       size: {
         xss: {
           base: (prev) => [prev, "gap-0.20", "px-1"].join(" "),

package/dist/unplugin.mjs

@@ -3,7 +3,7 @@ import { join, normalize } from 'pathe';
 import { createUnplugin } from 'unplugin';
 import { defu } from 'defu';
 import tailwind from '@tailwindcss/vite';
-import { g as getTemplates, d as defaultOptions, a as getDefaultConfig } from './shared/b24ui-nuxt.BCphUjPy.mjs';
+import { g as getTemplates, d as defaultOptions, a as getDefaultConfig } from './shared/b24ui-nuxt.Dh5A-7HA.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import MagicString from 'magic-string';

package/dist/vite.mjs

@@ -4,7 +4,7 @@ import 'pathe';
 import 'unplugin';
 import 'defu';
 import '@tailwindcss/vite';
-import './shared/b24ui-nuxt.BCphUjPy.mjs';
+import './shared/b24ui-nuxt.Dh5A-7HA.mjs';
 import 'scule';
 import 'knitwork';
 import '@nuxt/kit';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitrix24/b24ui-nuxt",
   "description": "Bitrix24 UI-Kit for developing web applications REST API for NUXT & VUE",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bitrix24/b24ui.git"