patent-editor 0.1.0

package/dist/lib.d.ts

@@ -0,0 +1,573 @@
+import { default as default_2 } from 'react';
+import { Editor } from '@tiptap/react';
+import { EditorOptions } from '@tiptap/react';
+import { Extension } from '@tiptap/react';
+import { JSONContent } from '@tiptap/react';
+import { Mark } from '@tiptap/react';
+import { Node as Node_2 } from '@tiptap/react';
+import { Node as Node_3 } from '@tiptap/pm/model';
+import { PluginKey } from '@tiptap/pm/state';
+import { StoreApi } from 'zustand';
+import { UseBoundStore } from 'zustand';
+
+export declare function acceptAllPatches(editor: Editor): void;
+
+export declare function acceptPatch(editor: Editor, patchId: string): boolean;
+
+export declare type AIAction = 'generate';
+
+export declare interface AIChatReference {
+    text: string;
+    source?: string;
+    from?: number;
+    to?: number;
+}
+
+export declare interface AIContext {
+    scope: 'selection' | 'section' | 'document';
+    sectionType?: PatentSectionType;
+    targetSectionPos?: number;
+    userInput?: string;
+    selectedText?: string;
+    dependencyContext?: {
+        sectionType: PatentSectionType;
+        content: string;
+    }[];
+    surroundingText?: string;
+    language: EditorLanguage;
+}
+
+export declare interface AIPatch {
+    id: string;
+    type: 'insert' | 'replace' | 'delete';
+    from: number;
+    to: number;
+    content: string;
+    originalText?: string;
+    reason?: string;
+    status: 'pending' | 'accepted' | 'rejected';
+}
+
+export declare interface AIPatchData {
+    op: 'replace' | 'insert' | 'delete';
+    target: AIPatchTarget;
+    search?: string;
+    content: string;
+    reason?: string;
+    from?: number;
+    to?: number;
+}
+
+export declare interface AIPatchTarget {
+    type: 'section' | 'ref' | 'search';
+    sectionType?: PatentSectionType;
+    refIndex?: number;
+    searchText?: string;
+}
+
+export declare interface AIRequest {
+    action: AIAction;
+    sectionType?: PatentSectionType;
+    instruction?: string;
+    content?: string;
+    dependencyContext?: {
+        sectionType: string;
+        content: string;
+    }[];
+    language: EditorLanguage;
+}
+
+export declare type AIResponseEvent = {
+    type: 'delta';
+    content: string;
+} | {
+    type: 'patch';
+    patch: AIPatchData;
+} | {
+    type: 'done';
+    usage?: {
+        tokens: number;
+    };
+} | {
+    type: 'error';
+    message: string;
+};
+
+export declare interface AIServiceAdapter {
+    request(req: AIRequest): Promise<ReadableStream<AIResponseEvent>>;
+    abort(): void;
+}
+
+export declare type AIStatus = 'idle' | 'streaming' | 'loading' | 'error';
+
+declare interface AIStreamingState {
+    status: AIStatus;
+    activeSectionType: string | null;
+    requestId: string | null;
+    abortFn: (() => void) | null;
+}
+
+/**
+ * Apply document-level diff decorations to a read-only editor.
+ *
+ * @param editor  - The TipTap editor instance (should be loaded with the "current" document)
+ * @param originalText - Plain text of the original document, extracted using the same
+ *                       separator rules as ProseMirror's textBetween (\0 separators).
+ */
+export declare function applyDocDiffDecorations(editor: Editor, originalText: string): void;
+
+declare const applyTransactionBatch: (editor: Editor, operations: BatchOperation[]) => boolean;
+
+export declare type AutoSaveStatus = 'idle' | 'saving' | 'saved' | 'error';
+
+declare type BatchOperation = {
+    type: 'insertNode';
+    payload: InsertNodeInput;
+} | {
+    type: 'updateNodeAttrs';
+    payload: UpdateNodeAttrsInput;
+} | {
+    type: 'removeNode';
+    payload: RemoveNodeInput;
+} | {
+    type: 'wrapSelection';
+    payload: WrapSelectionInput;
+};
+
+export declare function buildAIContext(editor: Editor, options?: {
+    scope?: AIContext['scope'];
+    sectionType?: PatentSectionType;
+    targetSectionPos?: number;
+    userInput?: string;
+}): AIContext;
+
+/**
+ * Build structured JSONContent for claims from text,
+ * suitable for use with editor.commands.insertContent() or diff comparison.
+ */
+export declare function buildClaimsJSONContent(text: string): Array<{
+    type: string;
+    attrs: Record<string, unknown>;
+    content?: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;
+
+export declare const buildPatentDocument: (patentType?: PatentType) => JSONContent;
+
+declare interface ChatMessage {
+    messageId: string;
+    role: 'user' | 'assistant';
+    content: string;
+    references?: AIChatReference[];
+    patches?: AIPatchData[];
+    usage?: {
+        tokens: number;
+    };
+    status: 'processing' | 'done' | 'error';
+    createdAt: string;
+}
+export { ChatMessage as AIChatMessage }
+export { ChatMessage }
+
+export declare interface ChatMessageRequest {
+    content: string;
+    references?: AIChatReference[];
+    language: EditorLanguage;
+}
+
+export declare interface ChatMessageResponse {
+    messageId: string;
+    sessionId: string;
+    status: 'processing' | 'done' | 'error';
+}
+
+export declare interface ChatReference {
+    id: string;
+    text: string;
+    from?: number;
+    to?: number;
+    sectionType?: string;
+}
+
+export declare interface ChatSession {
+    sessionId: string;
+    patentId?: string;
+    title: string;
+    lastMessage?: string;
+    messageCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare interface ChatSessionAPI {
+    createSession(patentId?: string, title?: string, language?: EditorLanguage): Promise<ChatSession>;
+    listSessions(patentId?: string, page?: number, pageSize?: number): Promise<{
+        total: number;
+        items: ChatSession[];
+    }>;
+    getMessages(sessionId: string, page?: number, pageSize?: number): Promise<{
+        total: number;
+        items: ChatMessage[];
+    }>;
+    deleteSession(sessionId: string): Promise<void>;
+    sendMessage(sessionId: string, req: ChatMessageRequest): Promise<ChatMessageResponse>;
+    subscribeStream(sessionId: string, messageId: string): Promise<ReadableStream<AIResponseEvent>>;
+    abort(): void;
+}
+
+export declare interface ClaimSnapshot {
+    claimId: string;
+    number: number;
+    dependsOn: number[];
+    dependsOnClaimIds: string[];
+    body: string;
+    pos: number;
+}
+
+export declare function clearPatches(): void;
+
+declare interface CommandCompletionResult {
+    name: string;
+    success: boolean;
+    durationMs: number;
+    error?: unknown;
+}
+
+declare interface CommandExecutionContext {
+    editor: Editor;
+    selection: CommandSelection | null;
+    store: unknown;
+}
+
+declare interface CommandExecutionOptions {
+    transaction?: boolean;
+    rollbackOnFail?: boolean;
+    onComplete?: (result: CommandCompletionResult) => void;
+}
+
+declare type CommandExecutionResult = boolean | Promise<boolean>;
+
+declare interface CommandSelection {
+    from: number;
+    to: number;
+}
+
+export declare function createChatSessionAPI(baseUrl: string, headers?: Record<string, string>): ChatSessionAPI;
+
+export declare const createCommandExecutor: (editor: Editor) => {
+    execCommand: (name: string, payload?: unknown, options?: CommandExecutionOptions) => Promise<boolean>;
+    canExecCommand: (name: string, payload?: unknown) => boolean;
+    isCommandActive: (name: string) => boolean;
+    listCommands: () => string[];
+    insertNode: (input: Parameters<typeof insertNode>[1]) => boolean;
+    updateNodeAttrs: (input: Parameters<typeof updateNodeAttrs>[1]) => boolean;
+    removeNode: (input: Parameters<typeof removeNode>[1]) => boolean;
+    wrapSelection: (input: Parameters<typeof wrapSelection>[1]) => boolean;
+    applyTransactionBatch: (operations: Parameters<typeof applyTransactionBatch>[1]) => boolean;
+    findNodeByType: (typeName: Parameters<typeof findNodeByType>[1], scope?: Parameters<typeof findNodeByType>[2]) => NodeMatch;
+    findAncestorNode: (predicate: Parameters<typeof findAncestorNode>[1]) => NodeMatch;
+    findCurrentBlock: () => NodeMatch;
+    findNodesByPredicate: (predicate: Parameters<typeof findNodesByPredicate>[1], scope?: Parameters<typeof findNodesByPredicate>[2]) => NodeMatch[];
+};
+
+export declare const createEditorConfig: (options?: Partial<EditorOptions>) => Partial<EditorOptions>;
+
+export declare function createMockAIService(): AIServiceAdapter;
+
+export declare function createMockChatSessionAPI(): ChatSessionAPI;
+
+export declare function createSSEAdapter(baseUrl: string, headers?: Record<string, string>): AIServiceAdapter;
+
+declare type EditorCommand = (context: CommandExecutionContext, payload?: unknown) => CommandExecutionResult;
+
+declare interface EditorCommandDefinition {
+    execute: EditorCommand;
+    canExecute?: (context: CommandExecutionContext, payload?: unknown) => boolean;
+    isActive?: (context: CommandExecutionContext) => boolean;
+    description?: string;
+    category?: string;
+    shortcut?: string;
+}
+
+export declare type EditorLanguage = 'zh' | 'en';
+
+declare interface EditorPlugin {
+    name: string;
+    version: string;
+    extensions?: Extension[] | Node_2[] | Mark[];
+    commands?: Record<string, EditorCommand | EditorCommandDefinition>;
+    toolbarItems?: ToolbarItem[];
+    keymaps?: Record<string, string>;
+    onStateChange?: (editor: Editor) => void;
+    onSelectionChange?: (editor: Editor) => void;
+    dependsOn?: string[];
+    priority?: number;
+    init?: (editor: Editor) => void;
+    destroy?: (editor: Editor) => void;
+}
+
+declare interface EditorState {
+    editor: Editor | null;
+    document: JSONContent | null;
+    selection: {
+        from: number;
+        to: number;
+    } | null;
+    editorLanguage: EditorLanguage;
+    autoSaveStatus: AutoSaveStatus;
+    lastSavedAt: Date | null;
+    ai: AIStreamingState;
+    aiService: AIServiceAdapter | null;
+    chatSessionAPI: ChatSessionAPI | null;
+    chatSessionId: string | null;
+    rightPanel: RightPanelState;
+    setEditor: (editor: Editor) => void;
+    setDocument: (document: JSONContent) => void;
+    setSelection: (selection: {
+        from: number;
+        to: number;
+    }) => void;
+    setEditorLanguage: (language: EditorLanguage) => void;
+    setAutoSaveStatus: (status: AutoSaveStatus) => void;
+    setLastSavedAt: (date: Date | null) => void;
+    setAIStatus: (status: AIStatus, sectionType?: string | null) => void;
+    setAIAbort: (abortFn: (() => void) | null) => void;
+    resetAI: () => void;
+    setAIService: (adapter: AIServiceAdapter | null) => void;
+    setChatSessionAPI: (api: ChatSessionAPI | null) => void;
+    setChatSessionId: (id: string | null) => void;
+    setActiveSection: (sectionType: string, sectionPos: number) => void;
+    openDraftingPanel: (sectionType: string, sectionPos: number, regenerate?: boolean) => void;
+    openChatPanel: () => void;
+    setRightPanelTab: (tab: RightPanelTab) => void;
+    closeRightPanel: () => void;
+    addChatReference: (ref: Omit<ChatReference, 'id'>) => void;
+    removeChatReference: (id: string) => void;
+    clearChatReferences: () => void;
+    setPendingChatMessage: (msg: string | null) => void;
+}
+
+export declare const EditorView: default_2.FC<EditorViewProps>;
+
+declare interface EditorViewProps {
+    initialContent?: JSONContent;
+    onChange?: (content: JSONContent) => void;
+    className?: string;
+    readOnly?: boolean;
+    onEditorReady?: (editor: Editor) => void;
+    onSelectionOptimize?: (selection: {
+        text: string;
+        from: number;
+        to: number;
+        sectionType?: string;
+    }) => void;
+}
+
+export declare function exportToPdf(editor: Editor): Promise<void>;
+
+export declare function exportToWord(editor: Editor, language: EditorLanguage): Promise<void>;
+
+export declare const extractClaimsFromEditor: (editor: Editor) => ClaimSnapshot[];
+
+declare const findAncestorNode: (editor: Editor, predicate: string | ((node: Node_3) => boolean)) => NodeMatch | null;
+
+declare const findNodeByType: (editor: Editor, typeName: string, scope?: NodeQueryScope) => NodeMatch | null;
+
+declare const findNodesByPredicate: (editor: Editor, predicate: (node: Node_3, pos: number) => boolean, scope?: NodeQueryScope) => NodeMatch[];
+
+export declare function findSectionAtCursor(editor: Editor): SectionInfo | null;
+
+export declare function getAllSections(editor: Editor): SectionInfo[];
+
+export declare function getMissingSectionDeps(targetSection: PatentSectionType, completedSections: Set<PatentSectionType>): PatentSectionType[];
+
+export declare function getPatches(): AIPatch[];
+
+declare const insertNode: (editor: Editor, input: InsertNodeInput) => boolean;
+
+declare interface InsertNodeInput {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: JSONBlockContent;
+    position?: number;
+}
+
+declare type JSONBlockContent = JSONContent | JSONContent[];
+
+declare interface NodeMatch {
+    node: Node_3;
+    pos: number;
+}
+
+declare interface NodeQueryScope {
+    from?: number;
+    to?: number;
+}
+
+export declare function onPatchChange(listener: () => void): () => void;
+
+export declare const PatchDiffPluginKey: PluginKey<any>;
+
+export declare const PatentEditor: default_2.ForwardRefExoticComponent<PatentEditorProps & default_2.RefAttributes<PatentEditorRef>>;
+
+export declare interface PatentEditorProps {
+    initialContent?: JSONContent;
+    patentType?: PatentType;
+    onChange?: (content: JSONContent) => void;
+    className?: string;
+    readOnly?: boolean;
+    language?: EditorLanguage;
+    aiService?: AIServiceAdapter;
+    chatSessionAPI?: ChatSessionAPI;
+    aiBaseUrl?: string;
+    aiHeaders?: Record<string, string>;
+    onSelectionOptimize?: (selection: {
+        text: string;
+        from: number;
+        to: number;
+        sectionType?: string;
+    }) => void;
+}
+
+export declare interface PatentEditorRef {
+    getContent: () => JSONContent | null;
+    setContent: (content: JSONContent) => void;
+    getEditor: () => any;
+    execCommand: (name: string, payload?: unknown) => Promise<unknown>;
+    focus: () => void;
+}
+
+export declare type PatentSectionType = 'technical_field' | 'background_art' | 'summary' | 'drawing_description' | 'detailed_description' | 'claims' | 'abstract' | 'abstract_drawing' | 'drawing_figures' | 'design_product_name' | 'design_usage' | 'design_description' | 'design_views' | 'design_brief';
+
+export declare type PatentType = 'invention' | 'utility_model' | 'design';
+
+declare type PluginLifecycleStage = 'register' | 'init' | 'stateSync' | 'destroy';
+
+declare class PluginManager {
+    private plugins;
+    private lifecycleOrder;
+    private logLifecycle;
+    private getOrderedPlugins;
+    private registerPluginCommands;
+    register(plugin: EditorPlugin): void;
+    getExtensions(): (Extension | Node_2 | Mark)[];
+    initializePlugins(editor: Editor): void;
+    notifySelectionChange(editor: Editor): void;
+    notifyStateChange(editor: Editor): void;
+    executeCommand(name: string, context: CommandExecutionContext, payload?: unknown, options?: CommandExecutionOptions): Promise<boolean>;
+    canExecuteCommand(name: string, context: CommandExecutionContext, payload?: unknown): boolean;
+    isCommandActive(name: string, context: CommandExecutionContext): boolean;
+    getCommandNames(): string[];
+    getLifecycleOrder(): PluginLifecycleStage[];
+    getCommandMeta(name: string): EditorCommandDefinition;
+    getToolbarItems(): ToolbarItem[];
+    destroyPlugins(editor: Editor): void;
+}
+
+export declare const pluginManager: PluginManager;
+
+export declare function rejectAllPatches(editor: Editor): void;
+
+export declare function rejectPatch(editor: Editor, patchId: string): boolean;
+
+/**
+ * Remove the doc-diff decoration plugin from the editor.
+ */
+export declare function removeDocDiffDecorations(editor: Editor): void;
+
+declare const removeNode: (editor: Editor, input: RemoveNodeInput) => boolean;
+
+declare interface RemoveNodeInput {
+    type?: string;
+    position?: number;
+}
+
+/**
+ * Resolve an AIPatchData (with semantic target) into absolute from/to positions.
+ * Returns an AIPatch ready for decoration, or null if resolution fails.
+ */
+export declare function resolvePatchTarget(editor: Editor, patchData: AIPatchData, refs: AIChatReference[], patchIndex: number, alreadyResolved?: AIPatch[]): AIPatch | null;
+
+declare interface RightPanelState {
+    visible: boolean;
+    activeTab: RightPanelTab;
+    activeSectionType: string | null;
+    activeSectionPos: number | null;
+    regenerate: boolean;
+    chatReferences: ChatReference[];
+    pendingChatMessage: string | null;
+}
+
+export declare type RightPanelTab = 'drafting' | 'chat';
+
+export declare const sectionContextDeps: Record<PatentSectionType, PatentSectionType[]>;
+
+declare interface SectionInfo {
+    sectionType: PatentSectionType;
+    pos: number;
+    content: string;
+}
+
+export declare function setPatches(patches: AIPatch[]): void;
+
+export declare type StreamWriteMode = 'cursor' | 'section';
+
+export declare interface StreamWriterOptions {
+    mode: StreamWriteMode;
+    targetSectionPos?: number;
+    onStart?: () => void;
+    onChunk?: (text: string) => void;
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+    onAbort?: () => void;
+}
+
+declare interface ToolbarItem {
+    id: string;
+    label: string;
+    command: string;
+    group?: 'text' | 'structure' | 'technical' | 'patent' | string;
+    tooltip?: string;
+    shortcut?: string;
+    icon?: string;
+    enableWhen?: (context: CommandExecutionContext) => boolean;
+}
+
+declare const updateNodeAttrs: (editor: Editor, input: UpdateNodeAttrsInput) => boolean;
+
+declare interface UpdateNodeAttrsInput {
+    type?: string;
+    position?: number;
+    attrs: Record<string, unknown>;
+}
+
+export declare const useEditorStore: UseBoundStore<StoreApi<EditorState>>;
+
+export declare function validatePatentDocument(editor: Editor, language: EditorLanguage): ValidationIssue[];
+
+export declare interface ValidationIssue {
+    id: string;
+    severity: ValidationSeverity;
+    message: string;
+    sectionType?: string;
+    pos?: number;
+}
+
+export declare type ValidationSeverity = 'error' | 'warning' | 'suggestion';
+
+declare const wrapSelection: (editor: Editor, input: WrapSelectionInput) => boolean;
+
+declare interface WrapSelectionInput {
+    type: string;
+    attrs?: Record<string, unknown>;
+}
+
+export declare function writeStream(editor: Editor, reader: ReadableStreamDefaultReader<string>, options: StreamWriterOptions): Promise<void>;
+
+export declare function writeStreamFromSSE(editor: Editor, url: string, body: object, options: StreamWriterOptions): Promise<{
+    abort: () => void;
+}>;
+
+export { }