@blueking/chat-x 0.0.1-beta.1

package/dist/components/message-tools/tool-btn.vue.d.ts

@@ -0,0 +1,8 @@
+import type { IToolBtn } from '../../types';
+declare const __VLS_export: import("vue").DefineComponent<IToolBtn, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (data: IToolBtn) => any;
+}, string, import("vue").PublicProps, Readonly<IToolBtn> & Readonly<{
+    onClick?: ((data: IToolBtn) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/index.d.ts

@@ -0,0 +1,4 @@
+export * from './use-command-selection';
+export * from './use-global-config';
+export * from './use-menu-keydown';
+export * from './use-observer-visible-list';

package/dist/composables/use-command-selection.d.ts

@@ -0,0 +1,11 @@
+import type { EditorCommand } from '../edix';
+export declare const useCommandSelection: () => {
+    commandSelection: import("vue").ShallowRef<{
+        column: number;
+        line: number;
+    }, {
+        column: number;
+        line: number;
+    }>;
+    GetCursorPosition: EditorCommand<[]>;
+};

package/dist/composables/use-global-config.d.ts

@@ -0,0 +1,11 @@
+import { type ComputedRef } from 'vue';
+export declare const MESSAGE_SLOT_ID = "ai-blueking-message-slot";
+export declare const AI_BLUEKING_MESSAGE_SLOT_ID: unique symbol;
+export declare const getMessageSlotId: () => ComputedRef<string> | undefined;
+export declare const useGlobalConfig: () => {
+    messageSlotId: ComputedRef<string>;
+    readonly rawMessageSlotId: string;
+};
+export declare const useMessageSlotId: () => {
+    messageSlotId: import("vue").ShallowRef<string | undefined, string | undefined>;
+};

package/dist/composables/use-menu-keydown.d.ts

@@ -0,0 +1,8 @@
+import { type ShallowRef } from 'vue';
+export declare const useMenuKeydown: <T>(props: {
+    items: ShallowRef<T[]>;
+    menuRef: Readonly<ShallowRef<HTMLElement | null>>;
+    onSelect: (item: T) => void;
+}) => {
+    activeIndex: ShallowRef<number, number>;
+};

package/dist/composables/use-observer-visible-list.d.ts

@@ -0,0 +1,9 @@
+import { type ShallowRef, type TemplateRef } from 'vue';
+export declare const useObserverVisibleList: <T>(containerRef: TemplateRef<HTMLElement>, itemRefs: ShallowRef<(HTMLElement | null)[]>, params: {
+    gap: number;
+    items: T[];
+    moreItemWidth: number;
+}) => {
+    visibleItems: ShallowRef<T[], T[]>;
+    calculateVisibleMenuItems: () => Promise<void>;
+};

package/dist/directives/index.d.ts

@@ -0,0 +1 @@
+export * from './overflow-tips';

package/dist/directives/overflow-tips.d.ts

@@ -0,0 +1,15 @@
+import type { ObjectDirective } from 'vue';
+import { type Props } from 'tippy.js';
+import { type noop } from '../types';
+import 'tippy.js/dist/tippy.css';
+type MouseEnterFunc = (e?: MouseEvent) => void;
+type OverflowElement = HTMLElement & {
+    mouseEnterFunc?: MouseEnterFunc;
+    mouseLeaveFunc?: MouseEnterFunc;
+    unObserverFunc?: typeof noop;
+};
+declare const OverflowTips: ObjectDirective<OverflowElement, Partial<Props> & {
+    disabled?: boolean;
+    text?: string;
+}>;
+export default OverflowTips;

package/dist/edix/commands.d.ts

@@ -0,0 +1,6 @@
+import { Transaction } from './doc/edit.js';
+import { type DocFragment, type SelectionSnapshot } from './doc/types.js';
+export type EditorCommand<A extends unknown[]> = (doc: DocFragment, selection: SelectionSnapshot, ...args: A) => Transaction | void;
+export declare const Delete: EditorCommand<[]>;
+export declare const InsertText: EditorCommand<[text: string]>;
+export declare const ReplaceAll: EditorCommand<[text: string]>;

package/dist/edix/doc/edit.d.ts

@@ -0,0 +1,55 @@
+import type { DocFragment, DocLine, DocNode, Position, SelectionSnapshot, Writeable } from './types.js';
+declare const TYPE_DELETE = 1;
+type DeleteOperation = Readonly<{
+    _end: Position;
+    _start: Position;
+    _type: typeof TYPE_DELETE;
+}>;
+declare const TYPE_INSERT = 2;
+type InsertOperation = Readonly<{
+    _fragment: DocFragment;
+    _pos: Position;
+    _type: typeof TYPE_INSERT;
+}>;
+declare const TYPE_SELECT = 3;
+export type Operation = EditOperation | SelectOperataion;
+type EditOperation = DeleteOperation | InsertOperation;
+type SelectOperataion = Readonly<{
+    _anchor: Position | undefined;
+    _focus: Position | undefined;
+    _type: typeof TYPE_SELECT;
+}>;
+export declare class Transaction extends Array<Operation> {
+    static from(tr: ReadonlyArray<Operation>): Transaction;
+    delete(start: Position, end: Position): this;
+    insert(start: Position, fragment: DocFragment): this;
+    select(anchor?: Position, focus?: Position): this;
+    transform(position: Position): Position;
+}
+/**
+ * @internal
+ */
+export declare const isDocEqual: (docA: DocFragment, docB: DocFragment) => boolean;
+/**
+ * @internal
+ */
+export declare const isTextNode: (node: DocNode) => node is Readonly<{
+    text: string;
+}>;
+/**
+ * @internal
+ */
+export declare const getLineSize: (line: DocLine) => number;
+/**
+ * @internal
+ */
+export declare const merge: (a: DocLine, b: DocLine) => DocLine;
+/**
+ * @internal
+ */
+export declare const sliceDoc: (doc: DocFragment, start: Position, end: Position) => DocFragment;
+/**
+ * @internal
+ */
+export declare const applyTransaction: (doc: Writeable<DocFragment>, selection: Writeable<SelectionSnapshot>, tr: Transaction) => void;
+export {};

package/dist/edix/doc/position.d.ts

@@ -0,0 +1,19 @@
+import type { Position, PositionRange } from './types.js';
+/**
+ * @internal
+ * 0 : same
+ * 1 : A is before B (forward)
+ * -1: A is after B (backward)
+ */
+export declare const compareLine: ([lineA]: Position, [lineB]: Position) => -1 | 0 | 1;
+/**
+ * @internal
+ * 0 : same
+ * 1 : A is before B (forward)
+ * -1: A is after B (backward)
+ */
+export declare const comparePosition: (posA: Position, posB: Position) => -1 | 0 | 1;
+/**
+ * @internal
+ */
+export declare const range: ([a, b]: readonly [Position, Position]) => PositionRange;

package/dist/edix/doc/types.d.ts

@@ -0,0 +1,15 @@
+export type DocFragment = readonly DocLine[];
+export type DocLine = readonly DocNode[];
+export type DocNode = TextNode | VoidNode;
+export type Position = readonly [line: number, offset: number];
+export type PositionRange = readonly [start: Position, end: Position];
+export type SelectionSnapshot = readonly [anchor: Position, focus: Position];
+export type TextNode = Readonly<{
+    text: string;
+}>;
+export type VoidNode = Readonly<{
+    data: Record<string, unknown>;
+}>;
+export type Writeable<T> = {
+    -readonly [key in keyof T]: T[key];
+};

package/dist/edix/doc/utils.d.ts

@@ -0,0 +1,9 @@
+import { type DocFragment, type VoidNode } from './types.js';
+/**
+ * @internal
+ */
+export declare const docToString: (doc: DocFragment, voidToString?: (node: VoidNode) => string) => string;
+/**
+ * @internal
+ */
+export declare const stringToDoc: (text: string) => DocFragment;

package/dist/edix/dom/default.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const defaultIsBlockNode: (node: Element) => boolean;

package/dist/edix/dom/index.d.ts

@@ -0,0 +1,42 @@
+import { type ParserConfig } from './parser.js';
+import type { DocFragment, Position, PositionRange, SelectionSnapshot } from '../doc/types.js';
+export { defaultIsBlockNode } from './default.js';
+/**
+ * @internal
+ */
+export declare const getCurrentDocument: (node: Element) => Document;
+/**
+ * @internal
+ */
+export declare const getDOMSelection: (element: Element) => Selection;
+/**
+ * @internal
+ */
+export declare const getSelectionRangeInEditor: (selection: Selection, root: Element) => Range | void;
+/**
+ * @internal
+ */
+export declare const setSelectionToDOM: (document: Document, root: Element, [anchor, focus]: SelectionSnapshot, config: ParserConfig) => boolean;
+/**
+ * @internal
+ */
+export declare const serializeRange: (root: Element, config: ParserConfig, { startOffset, startContainer, endOffset, endContainer }: AbstractRange) => PositionRange;
+/**
+ * @internal
+ */
+export declare const getEmptySelectionSnapshot: () => SelectionSnapshot;
+/**
+ * @internal
+ */
+export declare const takeSelectionSnapshot: (root: Element, config: ParserConfig) => SelectionSnapshot;
+/**
+ * @internal
+ */
+export declare const readDom: (root: Node, config: ParserConfig, serializeVoid: (node: Element) => Record<string, unknown> | void, option?: {
+    _end: [Node, number];
+    _start: [Node, number] | undefined;
+}) => DocFragment;
+/**
+ * @internal
+ */
+export declare const getPointedCaretPosition: (document: Document, root: Element, { clientX, clientY }: MouseEvent, config: ParserConfig) => Position | void;

package/dist/edix/dom/parser.d.ts

@@ -0,0 +1,63 @@
+export interface ParserConfig {
+    /**
+     * @internal
+     */
+    _document: Document;
+    /**
+     * @internal
+     */
+    _isBlock: (node: Element) => boolean;
+}
+interface ParserOption {
+    _endNode?: Node;
+    _excludeEnd?: boolean;
+    _startNode?: Node;
+}
+/** @internal */
+export declare const TOKEN_TEXT = 1;
+/** @internal */
+export declare const TOKEN_VOID = 2;
+/** @internal */
+export declare const TOKEN_SOFT_BREAK = 3;
+/** @internal */
+export declare const TOKEN_BLOCK = 4;
+declare const TOKEN_EMPTY_BLOCK_ANCHOR = 5;
+declare const TOKEN_INVALID_SOFT_BREAK = 6;
+/**
+ * @internal
+ */
+export type TokenType = typeof TOKEN_BLOCK | typeof TOKEN_EMPTY_BLOCK_ANCHOR | typeof TOKEN_INVALID_SOFT_BREAK | typeof TOKEN_SOFT_BREAK | typeof TOKEN_TEXT | typeof TOKEN_VOID;
+/**
+ * @internal
+ */
+export declare const isTextNode: (node: Node) => node is Text;
+/**
+ * @internal
+ */
+export declare const isElementNode: (node: Node) => node is Element;
+/**
+ * @internal
+ */
+export declare const isCommentNode: (node: Node) => node is Comment;
+/**
+ * @internal
+ */
+export declare const isVoidNode: (node: Element) => boolean;
+/**
+ * @internal
+ */
+export declare const getDomNode: <T extends TokenType | void>() => T extends typeof TOKEN_TEXT ? Text : T extends TokenType ? Element : Element | Text;
+/**
+ * @internal
+ */
+export declare const getNodeSize: () => number;
+/**
+ * @internal
+ */
+export declare const moveToBlock: (index: number) => void;
+declare const readNext: () => TokenType | void;
+/**
+ * @internal
+ */
+export declare const parse: <T>(scopeFn: (read: typeof readNext) => T, root: Node, { _document: document, _isBlock: isBlock }: ParserConfig, option?: ParserOption) => T;
+export {};

package/dist/edix/editor.d.ts

@@ -0,0 +1,55 @@
+import type { EditorCommand } from './commands.js';
+import type { DocSchema } from './schema/index.js';
+/**
+ * Methods of editor instance.
+ */
+export interface Editor {
+    /**
+     * Dispatches editing command.
+     * @param fn command function
+     * @param args arguments of command
+     */
+    command: <A extends unknown[]>(fn: EditorCommand<A>, ...args: A) => void;
+    /**
+     * A function to make DOM editable.
+     * @returns A function to stop subscribing DOM changes and restores previous DOM state.
+     */
+    input: (element: HTMLElement) => () => void;
+    /**
+     * Changes editor's read-only state.
+     * @param value `true` to read-only. `false` to editable.
+     */
+    readonly: (value: boolean) => void;
+}
+/**
+ * Options of {@link createEditor}.
+ */
+export interface EditorOptions<T> {
+    /**
+     * Initial document state.
+     */
+    doc: T;
+    /**
+     * TODO
+     */
+    schema: DocSchema<T>;
+    /**
+     * TODO
+     */
+    isBlock?: (node: HTMLElement) => boolean;
+    /**
+     * Callback invoked when document state changes.
+     */
+    onChange: (doc: T) => void;
+    /**
+     * Callback invoked when `keydown` events are dispatched.
+     *
+     * Return `true` if you want to cancel the editor's default behavior.
+     */
+    onKeyDown?: (keyboard: KeyboardPayload) => boolean | void;
+}
+export type KeyboardPayload = Pick<KeyboardEvent, 'altKey' | 'code' | 'ctrlKey' | 'key' | 'metaKey' | 'shiftKey'>;
+/**
+ * A function to initialize editor.
+ */
+export declare const createEditor: <T>({ schema: { single: isSingleline, js: docToJS, doc: jsToDoc, copy, paste }, doc: initialDoc, isBlock, onChange, onKeyDown: onKeyDownCallback, }: EditorOptions<T>) => Editor;

package/dist/edix/history.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+export declare const createHistory: <T>(initialValue: T) => {
+    get: () => NonNullable<T>;
+    set: (history: T) => void;
+    undo: () => T | undefined;
+    redo: () => T | undefined;
+    push: (history: T) => void;
+};

package/dist/edix/index.d.ts

@@ -0,0 +1,6 @@
+export type { EditorCommand } from './commands';
+export { Delete, InsertText, ReplaceAll } from './commands';
+export * from './doc/utils';
+export * from './editor';
+export * from './schema';
+export * from './utils';

package/dist/edix/mutation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export declare const createMutationObserver: (element: Element, onMutationIgnored: () => void) => {
+    _record(enable: boolean): void;
+    _flush: () => MutationRecord[];
+    _dispose(): void;
+};

package/dist/edix/plugins/singleline.d.ts

@@ -0,0 +1,5 @@
+import { Transaction } from '../doc/edit.js';
+/**
+ * @internal
+ */
+export declare const singleline: (tr: Transaction) => Transaction;

package/dist/edix/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plain.js';
+export * from './structured.js';
+export type { DocSchema, InferDoc, InferNode } from './types.js';

package/dist/edix/schema/plain.d.ts

@@ -0,0 +1,7 @@
+import type { DocSchema } from './types.js';
+/**
+ * Defines plain text schema.
+ */
+export declare const plainSchema: ({ multiline, }?: {
+    multiline?: boolean;
+}) => DocSchema<string>;

package/dist/edix/schema/structured.d.ts

@@ -0,0 +1,35 @@
+import type { DocSchema } from './types.js';
+export interface EditableVoidSerializer<T> {
+    data: (node: HTMLElement) => T;
+    is: (node: HTMLElement) => boolean;
+    plain: (data: T) => string;
+}
+export declare const voidNode: <const D>({ is, data, plain, }: {
+    data: (node: HTMLElement) => D;
+    is: (node: HTMLElement) => boolean;
+    plain?: (data: D) => string;
+}) => EditableVoidSerializer<D>;
+type ExtractVoidData<T> = T extends EditableVoidSerializer<infer D> ? D : never;
+type ExtractVoidNode<T> = Prettify<{
+    [K in keyof T]: {
+        data: ExtractVoidData<T[K]>;
+        type: K;
+    };
+}[keyof T]>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Defines structured text schema.
+ */
+export declare const schema: <V extends Record<string, EditableVoidSerializer<any>> = {}, M extends boolean = false>({ multiline, void: voids, }: {
+    multiline?: M;
+    void?: V;
+}) => DocSchema<M extends true ? (ExtractVoidNode<V> | {
+    text: string;
+    type: "text";
+})[][] : (ExtractVoidNode<V> | {
+    text: string;
+    type: "text";
+})[]>;
+export {};

package/dist/edix/schema/types.d.ts

@@ -0,0 +1,13 @@
+import type { DocFragment } from '../doc/types.js';
+import type { ParserConfig } from '../dom/parser.js';
+export interface DocSchema<T> {
+    single: boolean;
+    copy: (dataTransfer: DataTransfer, doc: DocFragment, element: Element) => void;
+    doc: (state: T) => DocFragment;
+    js: (doc: DocFragment) => T;
+    paste: (dataTransfer: DataTransfer, config: ParserConfig) => DocFragment;
+}
+export type InferDoc<T> = T extends DocSchema<infer N> ? N : never;
+export type InferNode<T> = T extends DocSchema<infer N> ? ExtractItem<N> : never;
+type ExtractItem<T> = T extends (infer I)[] ? ExtractItem<I> : T;
+export {};

package/dist/edix/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export declare const min: (...values: number[]) => number;
+/**
+ * @internal
+ */
+export declare const microtask: (fn: () => void) => void;

package/dist/icons/ai.d.ts

@@ -0,0 +1,3 @@
+export declare const AIBluekingIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/icons/content.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 文档图标
+ */
+export declare const DocumentIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const PreviewIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const TargetIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const RemoveIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/icons/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ai';
+export * from './content';
+export * from './messages';
+export * from './shortcuts';
+export * from './tools';

package/dist/icons/messages.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 发送消息图标
+ */
+export declare const SendMessageIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+/**
+ * 加载中消息图标
+ */
+export declare const LoadingMessageIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+/**
+ * 思考图标
+ */
+export declare const ThinkingIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+/**
+ * 折叠图标
+ */
+export declare const CollapsedIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const ErrorIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const ContentLoadingIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/icons/shortcuts.d.ts

@@ -0,0 +1,6 @@
+export declare const CloseIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const MoreIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

package/dist/icons/tools.d.ts

@@ -0,0 +1,45 @@
+export declare const CopyIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const CiteIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const RebuildIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const ShareIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const LikeIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const UnLikeIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const DeleteIcon: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const ToolIconsMap: {
+    readonly copy: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly cite: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly rebuild: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly share: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly like: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly unlike: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    readonly delete: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+};
+export type ToolIcons = keyof typeof ToolIconsMap;