@blueking/chat-x 0.0.1-beta.3 → 0.0.1-beta.5

package/dist/components/chat-message/message-render/message-render.vue.d.ts

@@ -0,0 +1,21 @@
+import { type VNode } from 'vue';
+import type { Message, MessageStatus } from '../../../ag-ui/types';
+import type { MessageToolsProps } from '../../message-tools/message-tools.vue';
+type __VLS_Slots = {
+    default: (props: {
+        content: string;
+        status: MessageStatus;
+    }) => VNode;
+};
+type __VLS_Props = Pick<MessageToolsProps, 'onAction'> & {
+    message: Partial<Message>;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/chat-message/reasoning-message/reasoning-message.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ReasoningMessage } from '../../../ag-ui/types/messages';
+type __VLS_Props = Partial<ReasoningMessage>;
+type __VLS_ModelProps = {
+    'collapsed'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:collapsed": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/chat-message/tool-message/tool-message.vue.d.ts

@@ -0,0 +1,4 @@
+import type { ToolMessage } from '../../../ag-ui/types/messages';
+declare const __VLS_export: import("vue").DefineComponent<Partial<ToolMessage>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Partial<ToolMessage>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/chat-message/user-message/user-message.vue.d.ts

@@ -0,0 +1,6 @@
+import { type MessageToolsProps } from '../../message-tools/message-tools.vue';
+import type { UserMessage } from '../../../ag-ui/types/messages';
+type __VLS_Props = Partial<UserMessage> & Pick<MessageToolsProps, 'onAction'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/index.d.ts

@@ -0,0 +1,11 @@
+import AiSelection from './ai-selection/ai-selection.vue';
+import ShortcutBtn from './ai-shortcut/shortcut-btn/shortcut-btn.vue';
+import ShortcutBtns from './ai-shortcut/shortcut-btns/shortcut-btns.vue';
+import ShortcutRender from './ai-shortcut/shortcut-render/shortcut-render.vue';
+import ContentRender from './chat-content/content-render/content-render.vue';
+import ChatInput from './chat-input/chat-input.vue';
+import MessageContainer from './chat-message/message-container/message-container.vue';
+import MessageRender from './chat-message/message-render/message-render.vue';
+import MessageTools from './message-tools/message-tools.vue';
+import MessageUserFeedback from './message-tools/user-feedback/user-feedback.vue';
+export { AiSelection, ChatInput, ContentRender, MessageContainer, MessageRender, MessageTools, MessageUserFeedback, ShortcutBtn, ShortcutBtns, ShortcutRender, };

package/dist/components/markdown-token/code-content/code-content.vue.d.ts

@@ -0,0 +1,15 @@
+import type { Token } from '../../../markdown-it';
+type __VLS_Props = {
+    token: Token[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    mounted: (payload: {
+        el: HTMLElement | null;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMounted?: ((payload: {
+        el: HTMLElement | null;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/markdown-token/image-content/image-content.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    alt?: string;
+    src: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/markdown-token/index.d.ts

@@ -0,0 +1,5 @@
+import CodeContent from './code-content/code-content.vue';
+import ImageContent from './image-content/image-content.vue';
+import LatexContent from './latex-content/latex-content.vue';
+import MermaidContent from './mermaid-content/mermaid-content.vue';
+export { CodeContent, ImageContent, LatexContent, MermaidContent };

package/dist/components/markdown-token/latex-content/latex-content.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from '../../../markdown-it';
+import 'katex/dist/katex.min.css';
+type __VLS_Props = {
+    token: Token[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/markdown-token/mermaid-content/mermaid-content.vue.d.ts

@@ -0,0 +1,15 @@
+import type { Token } from '../../../markdown-it';
+type __VLS_Props = {
+    token: Token[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    mounted: (payload: {
+        el: HTMLElement | null;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMounted?: ((payload: {
+        el: HTMLElement | null;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,18 @@
+import { type TippyOptions } from 'vue-tippy';
+import type { IToolBtn } from '../../types';
+export type MessageToolsProps = {
+    messageTools?: IToolBtn[];
+    onAction?: (tool: IToolBtn) => Promise<string[] | void>;
+    tippyOptions?: Partial<Omit<TippyOptions, 'content' | 'getReferenceClientRect' | 'triggerTarget'>>;
+    updateTools?: IToolBtn[];
+};
+declare const __VLS_export: import("vue").DefineComponent<MessageToolsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    feedback: (tool: IToolBtn, reasonList: string[], otherReason: string) => any;
+}, string, import("vue").PublicProps, Readonly<MessageToolsProps> & Readonly<{
+    onFeedback?: ((tool: IToolBtn, reasonList: string[], otherReason: string) => any) | undefined;
+}>, {
+    messageTools: IToolBtn[];
+    updateTools: IToolBtn[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/message-tools/user-feedback/user-feedback.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    reasonList: string[];
+    title: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    cancel: () => any;
+    submit: (reasonList: string[], otherReason: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onSubmit?: ((reasonList: string[], otherReason: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/tool-call/desc-panel/desc-panel.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    desc?: string;
+    title: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/tool-call/toolcall-render/toolcall-render.vue.d.ts

@@ -0,0 +1,10 @@
+import { MessageStatus } from '../../../ag-ui/types/constants';
+import type { ToolCall } from '../../../ag-ui/types/messages';
+type __VLS_Props = {
+    duration?: number;
+    status?: MessageStatus;
+    toolCall?: ToolCall;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/index.d.ts

@@ -0,0 +1,8 @@
+export * from './use-animation-text';
+export * from './use-clipboard';
+export * from './use-command-selection';
+export * from './use-container-scroll';
+export * from './use-global-config';
+export * from './use-menu-keydown';
+export * from './use-observer-visible-list';
+export * from './use-parent-scrolling';

package/dist/composables/use-animation-text.d.ts

@@ -0,0 +1,16 @@
+import { type MaybeRef } from 'vue';
+export interface AnimationConfig {
+    easing?: string;
+    fadeDuration?: number;
+}
+export interface UseAnimationTextOptions {
+    animationConfig?: AnimationConfig;
+    text: string;
+}
+export declare const useAnimationText: (text: MaybeRef<string>, options?: AnimationConfig) => {
+    chunks: import("vue").Ref<string[], string[]>;
+    animationStyle: import("vue").ComputedRef<{
+        animation: string;
+        color: string;
+    }>;
+};

package/dist/composables/use-clipboard.d.ts

@@ -0,0 +1,3 @@
+export declare const useClipboard: () => {
+    copy: (text: string) => Promise<void>;
+};

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-container-scroll.d.ts

@@ -0,0 +1,15 @@
+import { type ComputedRef, type MaybeRef } from 'vue';
+export declare const CONTAINER_SCROLL_TOKEN: unique symbol;
+export type ContainerScrollData = {
+    isScrollBottom: boolean;
+    scrollBottomHeight: number;
+    toScrollBottom: () => void;
+    toScrollTop: () => void;
+};
+export declare const useContainerScrollProvider: (containerRef: MaybeRef<HTMLElement | null>, bottomRef: MaybeRef<HTMLElement | null>) => {
+    isScrollBottom: import("vue").ShallowRef<boolean, boolean>;
+    scrollBottomHeight: import("vue").ShallowRef<number, number>;
+    toScrollBottom: () => void;
+    toScrollTop: () => void;
+};
+export declare const useContainerScrollConsumer: () => ComputedRef<ContainerScrollData> | undefined;

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,10 @@
+import { type ShallowRef, type TemplateRef } from 'vue';
+import type { ShortcutBtn } from '../components';
+export declare const useObserverVisibleList: <T>(containerRef: TemplateRef<HTMLElement>, itemRefs: ShallowRef<(HTMLElement | null)[]>, params: {
+    gap: number;
+    items: T[];
+    moreItemRef?: TemplateRef<InstanceType<typeof ShortcutBtn>>;
+}) => {
+    visibleItems: ShallowRef<T[], T[]>;
+    calculateVisibleMenuItems: () => Promise<void>;
+};

package/dist/composables/use-parent-scrolling.d.ts

@@ -0,0 +1,16 @@
+import { type MaybeRef } from 'vue';
+/**
+ * 递归获取滚动父级
+ * @param node - 节点
+ * @returns 滚动父级
+ */
+export declare const getScrollParent: (node: HTMLElement | null | ParentNode) => HTMLElement | null;
+/**
+ * 监听父级滚动
+ * @param domRef - 节点
+ * @returns 是否滚动
+ */
+export declare const useParentScrolling: (domRef: MaybeRef<HTMLElement | null>) => {
+    isScrolling: import("vue").ShallowRef<boolean, boolean>;
+    scrollParent: import("vue").ShallowRef<HTMLElement | null, HTMLElement | null>;
+};

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;
+};
+export declare const OverflowTips: ObjectDirective<OverflowElement, Partial<Props> & {
+    disabled?: boolean;
+    text?: string;
+}>;
+export {};

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>;