EditorAPI

const html = await api.editor.getContent();
console.log('Current content:', html);

await api.editor.setContent('<p>Hello, World!</p>');

await api.editor.insertContent('<strong>Bold text</strong>');

{
  start: { line: number, character: number },
  end: { line: number, character: number }
}

const range = {
  start: { line: 0, character: 0 },
  end: { line: 0, character: 10 }
};
const text = await api.editor.getTextInRange(range);

const range = {
  start: { line: 0, character: 0 },
  end: { line: 0, character: 5 }
};
await api.editor.replaceText(range, 'Hello');

{
  start: { line: number, character: number },
  end: { line: number, character: number },
  anchor: { line: number, character: number },
  active: { line: number, character: number },
  isEmpty: boolean,
  isSingleLine: boolean
}

const selections = await api.editor.getSelections();
console.log('Current selection:', selections[0]);

await api.editor.setSelection({
  start: { line: 0, character: 0 },
  end: { line: 0, character: 10 }
});

await api.editor.setSelections([
  {
    start: { line: 0, character: 0 },
    end: { line: 0, character: 10 }
  }
]);

{
  document: TextDocument,
  selection: Selection,
  selections: Selection[],
  visibleRanges: Range[],
  options: object,
  viewColumn: number,
  edit(callback): Promise<boolean>,
  insertSnippet(snippet): Promise<boolean>,
  setDecorations(decorationType, ranges): void,
  revealRange(range): void,
  show(): void,
  hide(): void
}

const editor = await api.editor.getActiveEditor();
if (editor) {
  console.log('Active document:', editor.document.fileName);
}

{
  uri: { toString(): string, path: string, scheme: string },
  fileName: string,
  isUntitled: boolean,
  languageId: string,
  version: number,
  isDirty: boolean,
  isClosed: boolean,
  eol: number,
  lineCount: number,
  getText(range?): string,
  lineAt(lineOrPosition): TextLine,
  offsetAt(position): number,
  positionAt(offset): Position,
  validateRange(range): Range,
  validatePosition(position): Position,
  save(): Promise<boolean>
}

const doc = await api.editor.getActiveDocument();
if (doc) {
  const text = doc.getText();
  console.log('Document content:', text);
}

const editors = await api.editor.getVisibleEditors();
console.log(`${editors.length} editors visible`);

const documents = await api.editor.getOpenDocuments();
documents.forEach(doc => {
  console.log('Open document:', doc.fileName);
});

const doc = await api.editor.openDocument('file:///path/to/file.md');

const doc = await api.editor.openDocument('file:///path/to/file.md');
const editor = await api.editor.showDocument(doc, {
  viewColumn: 1,
  preserveFocus: false
});

const doc = await api.editor.createUntitledDocument({
  language: 'markdown',
  content: '# New Document'
});

{
  provideCompletionItems(
    document: TextDocument,
    position: Position,
    token: CancellationToken,
    context: CompletionContext
  ): CompletionItem[] | Promise<CompletionItem[]>
}

const disposable = api.editor.registerCompletionProvider(
  'markdown',
  {
    provideCompletionItems(document, position) {
      return [
        {
          label: 'mySnippet',
          kind: 1, // Text
          insertText: 'My custom snippet',
          documentation: 'Inserts a custom snippet'
        }
      ];
    }
  },
  '@' // Trigger on @ character
);
 
// Later, to unregister:
disposable.dispose();

{
  provideHover(
    document: TextDocument,
    position: Position,
    token: CancellationToken
  ): Hover | Promise<Hover>
}

{
  contents: string | string[],
  range?: Range
}

const disposable = api.editor.registerHoverProvider('markdown', {
  provideHover(document, position) {
    const wordRange = document.getWordRangeAtPosition(position);
    const word = document.getText(wordRange);
 
    return {
      contents: [`Hover info for: $\\{word\\}`],
      range: wordRange
    };
  }
});

{
  provideDefinition(
    document: TextDocument,
    position: Position,
    token: CancellationToken
  ): Location | Location[] | Promise<Location | Location[]>
}

{
  uri: string,
  range: Range
}

const disposable = api.editor.registerDefinitionProvider('markdown', {
  provideDefinition(document, position) {
    // Example: Jump to wiki link target
    const word = document.getText(document.getWordRangeAtPosition(position));
 
    if (word.startsWith('[[') && word.endsWith(']]')) {
      const target = word.slice(2, -2);
      return {
        uri: `file:///workspace/${target}.md`,
        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
      };
    }
 
    return null;
  }
});

{
  provideCodeActions(
    document: TextDocument,
    range: Range,
    context: CodeActionContext,
    token: CancellationToken
  ): CodeAction[] | Promise<CodeAction[]>
}

{
  title: string,
  kind?: string, // 'quickfix', 'refactor', etc.
  edit?: WorkspaceEdit,
  command?: Command,
  diagnostics?: Diagnostic[]
}

const disposable = api.editor.registerCodeActionProvider(
  'markdown',
  {
    provideCodeActions(document, range, context) {
      const text = document.getText(range);
 
      if (text.includes('TODO')) {
        return [
          {
            title: 'Convert TODO to task',
            kind: 'quickfix',
            command: {
              command: 'myPlugin.convertTodo',
              arguments: [range]
            }
          }
        ];
      }
 
      return [];
    }
  },
  {
    providedCodeActionKinds: ['quickfix']
  }
);

{
  provideDocumentFormattingEdits(
    document: TextDocument,
    options: FormattingOptions,
    token: CancellationToken
  ): TextEdit[] | Promise<TextEdit[]>
}

{
  tabSize: number,
  insertSpaces: boolean
}

{
  range: Range,
  newText: string
}

const disposable = api.editor.registerDocumentFormattingProvider('markdown', {
  provideDocumentFormattingEdits(document, options) {
    const text = document.getText();
    const formatted = formatMarkdown(text);
 
    return [
      {
        range: {
          start: { line: 0, character: 0 },
          end: { line: document.lineCount - 1, character: 9999 }
        },
        newText: formatted
      }
    ];
  }
});

{
  provideFoldingRanges(
    document: TextDocument,
    context: FoldingContext,
    token: CancellationToken
  ): FoldingRange[] | Promise<FoldingRange[]>
}

{
  start: number, // Line number
  end: number,   // Line number
  kind?: string  // 'comment', 'imports', 'region'
}

const disposable = api.editor.registerFoldingRangeProvider('markdown', {
  provideFoldingRanges(document) {
    const ranges = [];
    const text = document.getText();
    const lines = text.split('\n');
 
    // Find markdown headers for folding
    for (let i = 0; i < lines.length; i++) {
      if (lines[i].startsWith('#')) {
        const level = lines[i].match(/^#+/)[0].length;
        let end = i + 1;
 
        // Find next header of same or higher level
        for (let j = i + 1; j < lines.length; j++) {
          if (lines[j].startsWith('#')) {
            const nextLevel = lines[j].match(/^#+/)[0].length;
            if (nextLevel <= level) break;
          }
          end = j;
        }
 
        if (end > i + 1) {
          ranges.push({ start: i, end: end, kind: 'region' });
        }
      }
    }
 
    return ranges;
  }
});

{
  provideDocumentLinks(
    document: TextDocument,
    token: CancellationToken
  ): DocumentLink[] | Promise<DocumentLink[]>,
 
  resolveDocumentLink?(
    link: DocumentLink,
    token: CancellationToken
  ): DocumentLink | Promise<DocumentLink>
}

{
  range: Range,
  target?: string,
  tooltip?: string
}

const disposable = api.editor.registerDocumentLinkProvider('markdown', {
  provideDocumentLinks(document) {
    const links = [];
    const text = document.getText();
    const regex = /\[\[([^\]]+)\]\]/g;
    let match;
 
    while ((match = regex.exec(text)) !== null) {
      const linkText = match[1];
      const start = document.positionAt(match.index);
      const end = document.positionAt(match.index + match[0].length);
 
      links.push({
        range: { start, end },
        target: `file:///workspace/${linkText}.md`,
        tooltip: `Go to $\\{linkText\\}`
      });
    }
 
    return links;
  }
});

const completionProviders = api.editor.getProviders('completion');
console.log(`${completionProviders.length} completion providers registered`);

// Called automatically during plugin deactivation
api.editor.unregisterAllProviders('my-plugin-id');

{
  name: string,                    // Required: Unique node name
  group?: string,                  // 'block' | 'inline'
  content?: string,                // Content expression
  marks?: string,                  // Allowed marks
  inline?: boolean,
  atom?: boolean,
  selectable?: boolean,
  draggable?: boolean,
  attributes?: object,             // Attribute definitions
  parseHTML?: Array<object>,       // HTML parsing rules
  renderHTML?: Function,           // HTML rendering function
  commands?: object,               // Editor commands
  inputRules?: Array<object>,      // Input rules
  pasteRules?: Array<object>,      // Paste rules
  keyboardShortcuts?: object,      // Keyboard shortcuts
  nodeView?: Function,             // Custom node view
  onBeforeCreate?: Function,
  onCreate?: Function,
  onUpdate?: Function,
  onDestroy?: Function
}

const disposable = api.editor.registerNode('myPlugin', {
  name: 'callout',
  group: 'block',
  content: 'block+',
  attributes: {
    type: {
      default: 'info'
    }
  },
  parseHTML: [
    {
      tag: 'div[data-callout]',
      getAttrs: (dom) => ({
        type: dom.getAttribute('data-callout')
      })
    }
  ],
  renderHTML: ({ HTMLAttributes }) => {
    return ['div', { ...HTMLAttributes, 'data-callout': HTMLAttributes.type }, 0];
  },
  commands: {
    setCallout: (attributes) => ({ commands }) => {
      return commands.setNode('callout', attributes);
    }
  }
});

{
  name: string,                    // Required: Unique mark name
  inclusive?: boolean,
  excludes?: string,
  group?: string,
  spanning?: boolean,
  attributes?: object,
  parseHTML?: Array<object>,
  renderHTML?: Function,
  commands?: object,
  inputRules?: Array<object>,
  keyboardShortcuts?: object
}

const disposable = api.editor.registerMark('myPlugin', {
  name: 'colored',
  attributes: {
    color: {
      default: 'red'
    }
  },
  parseHTML: [
    {
      tag: 'span[data-color]',
      getAttrs: (dom) => ({
        color: dom.getAttribute('data-color')
      })
    }
  ],
  renderHTML: ({ HTMLAttributes }) => {
    return ['span', {
      style: `color: $\\{HTMLAttributes.color\\}`,
      'data-color': HTMLAttributes.color
    }, 0];
  },
  commands: {
    setColor: (color) => ({ commands }) => {
      return commands.setMark('colored', { color });
    }
  }
});

{
  name: string,                    // Required: Unique extension name
  priority?: number,               // Extension priority (default: 100)
  options?: object,                // Extension options
  commands?: object,               // Editor commands
  keyboardShortcuts?: object,      // Keyboard shortcuts
  inputRules?: Array<object>,      // Input rules
  proseMirrorPlugins?: Array<Function>, // ProseMirror plugins
  onBeforeCreate?: Function,
  onCreate?: Function,
  onUpdate?: Function,
  onDestroy?: Function
}

const disposable = api.editor.registerExtension('myPlugin', {
  name: 'wordCount',
  onCreate({ editor }) {
    this.wordCount = 0;
  },
  onUpdate({ editor }) {
    const text = editor.state.doc.textContent;
    this.wordCount = text.split(/\s+/).filter(w => w.length > 0).length;
    console.log('Word count:', this.wordCount);
  }
});

{
  id: string,                      // Required: Unique command ID
  title: string,                   // Required: Display title
  description?: string,            // Command description
  icon?: string,                   // Icon name or SVG
  group?: string,                  // Group name (default: pluginId)
  order?: number,                  // Sort order (default: 100)
  keywords?: string[],             // Search keywords
  handler: Function,               // Required: Command handler
  when?: string | Function         // Conditional expression
}

(editor: Editor) => void

const disposable = api.editor.registerSlashCommand('myPlugin', {
  id: 'insertCallout',
  title: 'Callout',
  description: 'Insert a callout block',
  icon: 'info',
  group: 'blocks',
  order: 50,
  keywords: ['info', 'note', 'callout', 'alert'],
  handler: (editor) => {
    editor.chain()
      .focus()
      .insertContent('<div data-callout="info"><p>Note</p></div>')
      .run();
  }
});

{
  id: string,                      // Required: Unique rule ID
  pattern: RegExp,                 // Required: Pattern to match
  handler: Function,               // Required: Handler function
  priority?: number,               // Priority (default: 100)
  when?: string | Function         // Conditional expression
}

const ruleId = api.editor.registerInputRule('myPlugin', {
  id: 'autoEmoji',
  pattern: /:smile:$/,
  handler: ({ state, range, match }) => {
    const tr = state.tr;
    tr.insertText('😊', range.from, range.to);
    return tr;
  }
});

{
  key: string,                     // Required: Key combination (e.g., 'Mod-k')
  handler: Function,               // Required: Handler function
  when?: string | Function,        // Conditional expression
  priority?: number                // Priority (default: 100)
}

const shortcutId = api.editor.registerKeyboardShortcut('myPlugin', {
  key: 'Mod-k',
  handler: (editor) => {
    // Insert a link
    const url = prompt('Enter URL:');
    if (url) {
      editor.chain()
        .focus()
        .setLink({ href: url })
        .run();
    }
    return true;
  }
});

{
  id: string,                      // Required: Unique item ID
  type?: string,                   // 'button' | 'dropdown' | 'separator'
  title: string,                   // Required: Display title
  icon?: string,                   // Icon name or SVG
  group?: string,                  // Group name (default: 'editor')
  order?: number,                  // Sort order (default: 100)
  handler?: Function,              // Click handler (for button)
  isActive?: Function,             // Check if button is active
  isDisabled?: Function,           // Check if button is disabled
  items?: Array<object>,           // Dropdown items
  when?: string | Function         // Conditional expression
}

const itemId = api.editor.registerToolbarItem('myPlugin', {
  id: 'insertCallout',
  type: 'button',
  title: 'Insert Callout',
  icon: 'info',
  group: 'insert',
  order: 50,
  handler: (editor) => {
    editor.chain()
      .focus()
      .insertContent('<div data-callout="info"><p>Note</p></div>')
      .run();
  },
  isDisabled: (editor) => !editor.can().insertContent('text')
});

{
  name: string,                    // Required: Node name to render
  component?: ReactComponent,      // React component
  renderHTML?: Function,           // HTML rendering function
  interactive?: boolean,           // Default: true
  draggable?: boolean,             // Default: false
  selectable?: boolean             // Default: true
}

const viewId = api.editor.registerNodeView('myPlugin', {
  name: 'callout',
  component: CalloutComponent,
  interactive: true,
  draggable: false
});

{
  name: string,                    // Required: Command name
  handler: Function,               // Required: Command handler
  description?: string             // Command description
}

const commandId = api.editor.registerEditorCommand('myPlugin', {
  name: 'insertTimestamp',
  description: 'Insert current timestamp',
  handler: (editor) => {
    const timestamp = new Date().toISOString();
    editor.chain()
      .focus()
      .insertContent(timestamp)
      .run();
  }
});

{
  name: string,                    // Required: Format name
  displayName: string,             // Required: Display name
  extensions?: string[],           // File extensions
  mimeTypes?: string[],            // MIME types
  import?: Function,               // Import handler
  export?: Function                // Export handler
}

const formatId = api.editor.registerFormat('myPlugin', {
  name: 'org',
  displayName: 'Org Mode',
  extensions: ['.org'],
  mimeTypes: ['text/org'],
  import: (content) => {
    // Convert Org Mode to HTML
    return convertOrgToHTML(content);
  },
  export: (html) => {
    // Convert HTML to Org Mode
    return convertHTMLToOrg(html);
  }
});

(editor: TextEditor | undefined) => void

const disposable = api.editor.onDidChangeActiveTextEditor((editor) => {
  if (editor) {
    console.log('Active editor changed:', editor.document.fileName);
  } else {
    console.log('No active editor');
  }
});

(event: TextEditorSelectionChangeEvent) => void

{
  textEditor: TextEditor,
  selections: Selection[],
  kind: number // 1 = Keyboard, 2 = Mouse, 3 = Command
}

const disposable = api.editor.onDidChangeTextEditorSelection((event) => {
  const selection = event.selections[0];
  console.log('Selection changed:', selection.start, selection.end);
});

(event: TextDocumentChangeEvent) => void

{
  document: TextDocument,
  contentChanges: TextDocumentContentChangeEvent[],
  reason: number | undefined
}

const disposable = api.editor.onDidChangeTextDocument((event) => {
  console.log('Document changed:', event.document.fileName);
  console.log('Changes:', event.contentChanges.length);
});

(event: TextEditorVisibleRangesChangeEvent) => void

{
  textEditor: TextEditor,
  visibleRanges: Range[]
}

const disposable = api.editor.onDidChangeTextEditorVisibleRanges((event) => {
  console.log('Visible ranges changed');
});

const extensions = api.editor.getAllExtensions();
console.log(`${extensions.length} extensions registered`);

const groups = api.editor.getSlashCommands();
groups.forEach(group => {
  console.log(`${group.group}: ${group.commands.length} commands`);
});

const items = api.editor.getToolbarItems('editor');
console.log(`${items.length} toolbar items in editor group`);

{
  nodes: number,
  marks: number,
  extensions: number,
  slashCommands: number,
  inputRules: number,
  keyboardShortcuts: number,
  toolbarItems: number,
  nodeViews: number,
  editorCommands: number,
  formats: number,
  providers: number,
  totalPlugins: number,
  averageLoadTime: number,
  errorStats: object,
  quarantinedPlugins: string[]
}

const stats = api.editor.getStats();
console.log('Editor API Statistics:', stats);
console.log(`Total extensions: $\\{stats.nodes + stats.marks + stats.extensions\\}`);
console.log(`Average load time: ${stats.averageLoadTime}ms`);

// Called automatically during plugin deactivation
api.editor.unregisterPlugin('my-plugin-id');

if (api.editor.hasPluginExtensions('my-plugin-id')) {
  console.log('Plugin has active extensions');
}

const contributions = api.editor.getPluginContributions('my-plugin-id');
contributions.forEach(contrib => {
  console.log(`${contrib.type}: $\\{contrib.id\\}`);
});