@bitrix24/b24ui-nuxt 2.1.10 → 2.1.12

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/runtime/dictionary/icons.d.ts

@@ -40,5 +40,6 @@ declare const _default: {
     arrowUp: import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}>;
     stop: import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}>;
     reload: import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}>;
+    drag: import("vue").FunctionalComponent<import("vue").HTMLAttributes & import("vue").VNodeProps, {}, any, {}>;
 };
 export default _default;

package/dist/runtime/dictionary/icons.js

@@ -8,7 +8,6 @@ import DoubleShevronsRightIcon from "@bitrix24/b24icons-vue/actions/DoubleShevro
 import DoubleShevronsLeftIcon from "@bitrix24/b24icons-vue/actions/DoubleShevronsLeftIcon";
 import CrossMIcon from "@bitrix24/b24icons-vue/outline/CrossMIcon";
 import DotsIcon from "@bitrix24/b24icons-vue/button/DotsIcon";
-import OpenIn50Icon from "@bitrix24/b24icons-vue/actions/OpenIn50Icon";
 import Refresh6Icon from "@bitrix24/b24icons-vue/actions/Refresh6Icon";
 import Minus30Icon from "@bitrix24/b24icons-vue/actions/Minus30Icon";
 import Plus30Icon from "@bitrix24/b24icons-vue/actions/Plus30Icon";
@@ -32,6 +31,8 @@ import ArrowTopLIcon from "@bitrix24/b24icons-vue/outline/ArrowTopLIcon";
 import StopLIcon from "@bitrix24/b24icons-vue/outline/StopLIcon";
 import RefreshIcon from "@bitrix24/b24icons-vue/outline/RefreshIcon";
 import SendIcon from "@bitrix24/b24icons-vue/main/SendIcon";
+import DragLIcon from "@bitrix24/b24icons-vue/outline/DragLIcon";
+import GoToLIcon from "@bitrix24/b24icons-vue/outline/GoToLIcon";
 export default {
   arrowLeft: ArrowToTheLeftIcon,
   arrowRight: ArrowToTheRightIcon,
@@ -44,7 +45,7 @@ export default {
   chevronUp: ChevronTopLIcon,
   close: CrossMIcon,
   ellipsis: DotsIcon,
-  external: OpenIn50Icon,
+  external: GoToLIcon,
   file: FileIcon,
   loading: LoaderWaitIcon,
   refresh: Refresh6Icon,
@@ -67,5 +68,6 @@ export default {
   arrowDown: ArrowDownLIcon,
   arrowUp: ArrowTopLIcon,
   stop: StopLIcon,
-  reload: RefreshIcon
+  reload: RefreshIcon,
+  drag: DragLIcon
 };

package/dist/runtime/types/editor.d.ts

@@ -0,0 +1,69 @@
+import type { Editor } from '@tiptap/vue-3';
+import type { Strategy, Placement, OffsetOptions, FlipOptions, ShiftOptions, SizeOptions, AutoPlacementOptions, HideOptions, InlineOptions } from '@floating-ui/dom';
+export interface FloatingUIOptions {
+    strategy?: Strategy;
+    placement?: Placement;
+    offset?: OffsetOptions | boolean;
+    flip?: FlipOptions | boolean;
+    shift?: ShiftOptions | boolean;
+    size?: SizeOptions | boolean;
+    autoPlacement?: AutoPlacementOptions | boolean;
+    hide?: HideOptions | boolean;
+    inline?: InlineOptions | boolean;
+}
+export interface EditorHandler {
+    canExecute: (editor: Editor, cmd?: any) => boolean;
+    execute: (editor: Editor, cmd?: any) => any;
+    isActive: (editor: Editor, cmd?: any) => boolean;
+    isDisabled?: (editor: Editor, cmd?: any) => boolean;
+}
+export type EditorCustomHandlers = Record<string, EditorHandler>;
+export type EditorHandlers<H extends EditorCustomHandlers = EditorCustomHandlers> = {
+    mark: EditorHandler;
+    textAlign: EditorHandler;
+    heading: EditorHandler;
+    link: EditorHandler;
+    image: EditorHandler;
+    blockquote: EditorHandler;
+    bulletList: EditorHandler;
+    orderedList: EditorHandler;
+    codeBlock: EditorHandler;
+    horizontalRule: EditorHandler;
+    paragraph: EditorHandler;
+    undo: EditorHandler;
+    redo: EditorHandler;
+    clearFormatting: EditorHandler;
+    duplicate: EditorHandler;
+    delete: EditorHandler;
+    moveUp: EditorHandler;
+    moveDown: EditorHandler;
+    suggestion: EditorHandler;
+    mention: EditorHandler;
+    emoji: EditorHandler;
+} & H;
+export type EditorItem<H extends EditorCustomHandlers = EditorCustomHandlers> = {
+    kind: 'mark';
+    mark: 'bold' | 'italic' | 'strike' | 'code' | 'underline';
+} | {
+    kind: 'textAlign';
+    align: 'left' | 'center' | 'right' | 'justify';
+} | {
+    kind: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+} | {
+    kind: 'link';
+    href?: string;
+} | {
+    kind: 'image';
+    src?: string;
+} | {
+    kind: 'duplicate' | 'delete' | 'moveUp' | 'moveDown';
+    pos: number;
+} | {
+    kind: 'clearFormatting' | 'suggestion';
+    pos?: number;
+} | {
+    kind: 'blockquote' | 'bulletList' | 'orderedList' | 'codeBlock' | 'horizontalRule' | 'paragraph' | 'undo' | 'redo' | 'mention' | 'emoji';
+} | {
+    kind: keyof H;
+};

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

@@ -29,6 +29,12 @@ export * from '../components/DashboardSearch.vue';
 export * from '../components/DashboardSearchButton.vue';
 export * from '../components/DescriptionList.vue';
 export * from '../components/DropdownMenu.vue';
+export * from '../components/Editor.vue';
+export * from '../components/EditorDragHandle.vue';
+export * from '../components/EditorEmojiMenu.vue';
+export * from '../components/EditorMentionMenu.vue';
+export * from '../components/EditorSuggestionMenu.vue';
+export * from '../components/EditorToolbar.vue';
 export * from '../components/Empty.vue';
 export * from '../components/Error.vue';
 export * from '../components/FieldGroup.vue';
@@ -92,6 +98,7 @@ export * from '../components/color-mode/ColorModeSelect.vue';
 export * from '../components/color-mode/ColorModeSwitch.vue';
 export * from '../components/locale/LocaleSelect.vue';
 export * from './content';
+export * from './editor';
 export * from './form';
 export * from './icons';
 export * from './locale';

package/dist/runtime/types/index.js

@@ -29,6 +29,12 @@ export * from "../components/DashboardSearch.vue";
 export * from "../components/DashboardSearchButton.vue";
 export * from "../components/DescriptionList.vue";
 export * from "../components/DropdownMenu.vue";
+export * from "../components/Editor.vue";
+export * from "../components/EditorDragHandle.vue";
+export * from "../components/EditorEmojiMenu.vue";
+export * from "../components/EditorMentionMenu.vue";
+export * from "../components/EditorSuggestionMenu.vue";
+export * from "../components/EditorToolbar.vue";
 export * from "../components/Empty.vue";
 export * from "../components/Error.vue";
 export * from "../components/FieldGroup.vue";
@@ -92,6 +98,7 @@ export * from "../components/color-mode/ColorModeSelect.vue";
 export * from "../components/color-mode/ColorModeSwitch.vue";
 export * from "../components/locale/LocaleSelect.vue";
 export * from "./content.js";
+export * from "./editor.js";
 export * from "./form.js";
 export * from "./icons.js";
 export * from "./locale.js";

package/dist/runtime/utils/editor.d.ts

@@ -0,0 +1,69 @@
+import type { Editor, Mark } from '@tiptap/vue-3';
+import type { Middleware } from '@floating-ui/dom';
+import type { EditorHandlers, EditorCustomHandlers, EditorItem, FloatingUIOptions } from '../types/editor';
+export declare function isMarkInSchema(mark: string | Mark, editor: Editor | null): boolean;
+export declare function isNodeTypeSelected(editor: Editor | null, nodeTypes: string[]): boolean;
+export declare function isExtensionAvailable(editor: Editor | null, extensionName: string): boolean;
+export declare function createToggleHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createSetHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createSimpleHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: () => boolean;
+    isDisabled: undefined;
+};
+export declare function createMarkHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor, cmd: any) => boolean;
+};
+export declare function createTextAlignHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => any;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createHeadingHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createLinkHandler(): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createImageHandler(): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createListHandler(listType: 'bulletList' | 'orderedList'): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createMoveHandler(direction: 'up' | 'down'): {
+    canExecute: (editor: Editor, cmd: any) => boolean;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: () => boolean;
+    isDisabled: undefined;
+};
+export declare function createHandlers(): EditorHandlers;
+export declare function mapEditorItems(editor: Editor, items: (Partial<EditorItem> & Record<string, any>)[] | (Partial<EditorItem> & Record<string, any>)[][], customHandlers?: EditorCustomHandlers): any[] | any[][];
+export declare function buildFloatingUIMiddleware(options: FloatingUIOptions): Middleware[];