@choice-ui/react 1.4.5 → 1.4.7

package/dist/components/alert-dialog/src/index.d.ts

@@ -1,4 +1,4 @@
 export { AlertDialog } from './alert-dialog';
 export type { AlertDialogProps } from './alert-dialog';
 export { AlertDialogProvider } from './context';
-export { useAlertDialog, useAlertDialogProvider } from './hooks';
+export { useAlertDialog, useAlertDialogProvider } from './hooks/use-alert-dialog';

package/dist/components/context-input/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { default as React__default, ComponentType } from 'react';
 import { IconButtonProps } from '../../icon-button/src';
-import { RenderElementProps } from 'slate-react';
+import { RenderElementProps, ReactEditor } from 'slate-react';
+import { Editor, Range, Descendant } from 'slate';
+import { HistoryEditor } from 'slate-history';
 import * as React$1 from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
@@ -122,4 +124,123 @@ interface ContextInputComponent extends React__default.ForwardRefExoticComponent
 }
 declare const ContextInput: ContextInputComponent;
 
-export { ContextInput, type ContextInputProps, type ContextInputRef, type ContextInputValue, type ContextMentionElement, type ContextMentionItemProps, type ContextMentionProps, type ContextMentionTrigger, CopyButton, InsertMentionsButton };
+type ContextEditor = Editor & ReactEditor & HistoryEditor;
+
+interface MentionSearchState {
+    index: number;
+    isSearching: boolean;
+    loading: boolean;
+    position: {
+        x: number;
+        y: number;
+    } | null;
+    query: string;
+    suggestions: ContextMentionItemProps[];
+    target: Range | null;
+    trigger: string;
+}
+interface UseMentionsProps {
+    editor: ContextEditor;
+    maxSuggestions?: number;
+    mentionPrefix?: string;
+    onMentionSelect?: (mention: ContextMentionItemProps, trigger: string) => void;
+    onSearchClose?: () => void;
+    triggers: ContextMentionTrigger[];
+}
+declare function useMentions({ editor, triggers, maxSuggestions, mentionPrefix, onMentionSelect, onSearchClose, }: UseMentionsProps): {
+    searchState: MentionSearchState;
+    checkMentionSearch: () => void;
+    insertMention: (mention: ContextMentionItemProps) => void;
+    handleKeyDown: (event: React$1.KeyboardEvent<Element>) => boolean;
+    closeMentionSearch: () => void;
+    selectMention: (index: number) => void;
+    selectNextMention: () => void;
+    selectPreviousMention: () => void;
+};
+
+interface UseContextInputProps {
+    autoFocus?: boolean;
+    editor?: ContextEditor;
+    onChange?: (value: ContextInputValue) => void;
+    value?: ContextInputValue;
+}
+declare const useContextInput: ({ value, onChange, editor, autoFocus }: UseContextInputProps) => {
+    slateValue: Descendant[];
+    handleChange: (newValue: Descendant[]) => void;
+};
+
+declare const useContextInputEditor: () => ContextEditor;
+
+/**
+ * Convert SlateJS node array to string
+ * Mention nodes are converted to {{#context#}}{{#id.text#}} format
+ */
+declare function convertSlateToText(nodes: Descendant[]): string;
+/**
+ * Convert string to SlateJS node array
+ * Supports parsing {{#context#}}{{#id.text#}} format to mention nodes
+ */
+declare function convertTextToSlate(text: string): Descendant[];
+/**
+ * Interface for mention resolver function
+ */
+interface MentionResolver {
+    (mentionId: string): Promise<{
+        label: string;
+        metadata?: Record<string, unknown>;
+        type: string;
+    }>;
+}
+/**
+ * Advanced version: supports async mention info resolution
+ */
+declare function convertTextToSlateWithResolver(text: string, mentionResolver?: MentionResolver): Promise<Descendant[]>;
+
+declare const extractTextWithMentions: (nodes: Descendant[]) => {
+    text: string;
+    mentionsData: {
+        element: ContextMentionElement;
+        endIndex: number;
+        startIndex: number;
+    }[];
+};
+declare const parseTextWithMentions: (text: string, mentions: MentionMatch[]) => Descendant[];
+
+declare const extractMentionContext: (text: string, startIndex: number, endIndex: number, contextLength?: number) => {
+    mentionText: string;
+    fullContext: string;
+};
+
+/**
+ * Check if a space should be inserted before the current position
+ * @param editor - SlateJS editor instance
+ * @returns Whether a leading space should be added
+ */
+declare function shouldInsertSpaceBefore(editor: Editor): boolean;
+/**
+ * Check if a space should be inserted after the current position
+ * @param editor - SlateJS editor instance
+ * @returns Whether a trailing space should be added
+ */
+declare function shouldInsertSpaceAfter(editor: Editor): boolean;
+/**
+ * Smartly insert space at current position (leading space)
+ * @param editor - SlateJS editor instance
+ * @returns Whether a space was inserted
+ */
+declare function insertSpaceBeforeIfNeeded(editor: Editor): boolean;
+/**
+ * Smartly insert space at current position (trailing space)
+ * @param editor - SlateJS editor instance
+ * @returns Whether a space was inserted
+ */
+declare function insertSpaceAfterIfNeeded(editor: Editor): boolean;
+/**
+ * Insert smart spacing for mention
+ * This function intelligently adds spaces before/after mention insertion based on context
+ * @param editor - SlateJS editor instance
+ * @param beforeInsertion - Callback to execute before content insertion
+ */
+declare function insertWithSmartSpacing(editor: Editor, beforeInsertion: () => void): void;
+
+export { ContextInput, type ContextInputProps, type ContextInputRef, type ContextInputValue, type ContextMentionElement, type ContextMentionItemProps, type ContextMentionProps, type ContextMentionTrigger, CopyButton, InsertMentionsButton, convertSlateToText, convertTextToSlate, convertTextToSlateWithResolver, extractMentionContext, extractTextWithMentions, insertSpaceAfterIfNeeded, insertSpaceBeforeIfNeeded, insertWithSmartSpacing, parseTextWithMentions, shouldInsertSpaceAfter, shouldInsertSpaceBefore, useContextInput, useContextInputEditor, useMentions };

package/dist/components/context-input/src/index.d.ts

@@ -1,3 +1,5 @@
 export { ContextInput } from './context-input';
 export { InsertMentionsButton, CopyButton } from './components';
+export { useContextInput, useMentions, useContextInputEditor } from './hooks';
+export { shouldInsertSpaceBefore, shouldInsertSpaceAfter, insertSpaceBeforeIfNeeded, insertSpaceAfterIfNeeded, insertWithSmartSpacing, convertSlateToText, convertTextToSlate, convertTextToSlateWithResolver, extractTextWithMentions, parseTextWithMentions, extractMentionContext, } from './utils';
 export type { ContextInputProps, ContextInputValue, ContextMentionElement, ContextInputRef, ContextMentionProps, ContextMentionItemProps, ContextMentionTrigger, } from './types';

package/dist/components/context-input/src/utils/mention-spacing.js

@@ -1,4 +1,4 @@
-import { Transforms, Editor } from "slate";
+import { Editor, Transforms } from "slate";
 function shouldInsertSpaceBefore(editor) {
   const { selection } = editor;
   if (!selection) {
@@ -16,6 +16,23 @@ function shouldInsertSpaceBefore(editor) {
   }
   return false;
 }
+function shouldInsertSpaceAfter(editor) {
+  const { selection } = editor;
+  if (!selection) {
+    return true;
+  }
+  try {
+    const after = Editor.after(editor, selection.anchor, { unit: "character" });
+    if (after) {
+      const afterRange = Editor.range(editor, selection.anchor, after);
+      const afterText = Editor.string(editor, afterRange);
+      return afterText !== "" && afterText !== " " && afterText !== "\n";
+    }
+  } catch {
+    return true;
+  }
+  return true;
+}
 function insertSpaceBeforeIfNeeded(editor) {
   if (shouldInsertSpaceBefore(editor)) {
     Transforms.insertText(editor, " ");
@@ -23,6 +40,13 @@ function insertSpaceBeforeIfNeeded(editor) {
   }
   return false;
 }
+function insertSpaceAfterIfNeeded(editor) {
+  if (shouldInsertSpaceAfter(editor)) {
+    Transforms.insertText(editor, " ");
+    return true;
+  }
+  return false;
+}
 function insertWithSmartSpacing(editor, beforeInsertion) {
   const needsSpaceBefore = shouldInsertSpaceBefore(editor);
   if (needsSpaceBefore) {
@@ -32,7 +56,9 @@ function insertWithSmartSpacing(editor, beforeInsertion) {
   Transforms.insertText(editor, " ");
 }
 export {
+  insertSpaceAfterIfNeeded,
   insertSpaceBeforeIfNeeded,
   insertWithSmartSpacing,
+  shouldInsertSpaceAfter,
   shouldInsertSpaceBefore
 };

package/dist/components/context-input/src/utils/slate-converters.js

@@ -98,7 +98,73 @@ function isMentionElement(node) {
   const nodeAny = node;
   return nodeAny.type === "mention";
 }
+async function convertTextToSlateWithResolver(text, mentionResolver) {
+  if (!text || text.trim() === "") {
+    return [{ type: "paragraph", children: [{ text: "" }] }];
+  }
+  const lines = text.split("\n");
+  const resolvedLines = await Promise.all(
+    lines.map((line) => parseLineToNodesWithResolver(line, mentionResolver))
+  );
+  return resolvedLines.map((children) => ({
+    type: "paragraph",
+    children
+  }));
+}
+async function parseLineToNodesWithResolver(line, mentionResolver) {
+  const mentionRegex = /\{\{#([^}]+?)(?:\.text)?#\}\}/g;
+  const nodes = [];
+  let lastIndex = 0;
+  const matches = [];
+  let match;
+  while ((match = mentionRegex.exec(line)) !== null) {
+    matches.push({ ...match });
+  }
+  for (const match2 of matches) {
+    const [fullMatch, mentionId] = match2;
+    const matchStart = match2.index;
+    const matchEnd = match2.index + fullMatch.length;
+    if (matchStart > lastIndex) {
+      const textBefore = line.slice(lastIndex, matchStart);
+      if (textBefore) {
+        nodes.push({ text: textBefore });
+      }
+    }
+    let mentionInfo = {
+      label: `User ${mentionId}`,
+      type: "user"
+    };
+    if (mentionResolver) {
+      try {
+        mentionInfo = await mentionResolver(mentionId);
+      } catch (error) {
+        console.warn(`Failed to resolve mention ${mentionId}:`, error);
+      }
+    }
+    const mentionNode = {
+      type: "mention",
+      mentionType: mentionInfo.type,
+      mentionId,
+      mentionLabel: mentionInfo.label,
+      mentionData: mentionInfo.metadata || {},
+      children: [{ text: "" }]
+    };
+    nodes.push(mentionNode);
+    lastIndex = matchEnd;
+  }
+  if (lastIndex < line.length) {
+    const textAfter = line.slice(lastIndex);
+    if (textAfter) {
+      nodes.push({ text: textAfter });
+    }
+  }
+  if (nodes.length === 0) {
+    nodes.push({ text: line });
+  }
+  return nodes;
+}
 export {
   convertSlateToText,
-  convertTextToSlate
+  convertTextToSlate,
+  convertTextToSlateWithResolver
 };

package/dist/index.js

@@ -81,6 +81,13 @@ import { useDragAndDrop } from "./components/conditions/src/hooks/use-drag-and-d
 import { ContextInput } from "./components/context-input/src/context-input.js";
 import { InsertMentionsButton } from "./components/context-input/src/components/insert-mentions-button.js";
 import { CopyButton } from "./components/context-input/src/components/copy-button.js";
+import { useContextInput } from "./components/context-input/src/hooks/use-context-input.js";
+import { useMentions } from "./components/context-input/src/hooks/use-mentions.js";
+import { useContextInputEditor } from "./components/context-input/src/hooks/use-context-input-editor.js";
+import { insertSpaceAfterIfNeeded, insertSpaceBeforeIfNeeded, insertWithSmartSpacing, shouldInsertSpaceAfter, shouldInsertSpaceBefore } from "./components/context-input/src/utils/mention-spacing.js";
+import { convertSlateToText, convertTextToSlate, convertTextToSlateWithResolver } from "./components/context-input/src/utils/slate-converters.js";
+import { extractTextWithMentions, parseTextWithMentions } from "./components/context-input/src/utils/text-extraction.js";
+import { extractMentionContext } from "./components/context-input/src/utils/context-extraction.js";
 import { ContextMenu } from "./components/context-menu/src/context-menu.js";
 import { Dialog } from "./components/dialog/src/dialog.js";
 import { Dropdown } from "./components/dropdown/src/dropdown.js";
@@ -461,6 +468,9 @@ export {
   commentsService,
   commonDateFormats,
   commonTimeFormats,
+  convertSlateToText,
+  convertTextToSlate,
+  convertTextToSlateWithResolver,
   convertTwoDigitYear,
   createCondition,
   createConditionGroup,
@@ -482,6 +492,8 @@ export {
   emojis,
   englishMonths,
   extractDigits,
+  extractMentionContext,
+  extractTextWithMentions,
   findChildByType,
   findClosestValidTime,
   findCondition,
@@ -546,6 +558,9 @@ export {
   handleShortcuts,
   inferMonthFromValue,
   inferSelectionMode,
+  insertSpaceAfterIfNeeded,
+  insertSpaceBeforeIfNeeded,
+  insertWithSmartSpacing,
   isArray,
   isBrowser,
   isCalendarValueEqual,
@@ -592,6 +607,7 @@ export {
   parseMonthName,
   parseNaturalLanguage,
   parseRelativeDate,
+  parseTextWithMentions,
   parseYYMMDD,
   parseYYYYMMDD,
   parserConfig,
@@ -603,6 +619,8 @@ export {
   renderSecondValueInput,
   renderValueInput,
   resolveLocale,
+  shouldInsertSpaceAfter,
+  shouldInsertSpaceBefore,
   slateToMarkdown,
   smartCorrectDate,
   smartCorrectYear,
@@ -627,6 +645,8 @@ export {
   useConfigData,
   useConstRef,
   useContainerData,
+  useContextInput,
+  useContextInputEditor,
   useDateInput,
   useDirection,
   useDisableScroll,
@@ -646,6 +666,7 @@ export {
   useLayoutData,
   useLazyRef,
   useLoader,
+  useMentions,
   useMenuBaseRefs,
   useMenuChildren,
   useMenuFloating,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@choice-ui/react",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "A desktop-first React UI component library built for professional desktop applications with comprehensive documentation",
   "sideEffects": false,
   "type": "module",