API-Referenz

Vollständige Referenz aller SDK-Klassen und Methoden, die Extension-Entwicklern zur Verfügung stehen.

Die Studio-Klasse

Die Studio-Klasse ist der zentrale Einstiegspunkt. Sie wird der onLoad-Funktion als Parameter übergeben:

import { Studio } from '@5minds/processcube_studio_sdk';
 
export function onLoad(studio: Studio): void {
  // Zugriff auf alle APIs über studio.*
}

Funktionsbereiche

Kommandos & Eingabe

Editoren & Dokumente

Menüs & Bars

Einstellungen & Dialoge

Dateien & Netzwerk

Engine & Solution

Such- & Symbol-Index

Events & Lifecycle

Umgebung & Utilities

CommandMediator

Registriert und führt Commands aus. Commands sind die zentrale Einheit für Aktionen im Studio.

Methoden

register(name, callback, enabledPredicate?)

Registriert einen Command, der programmatisch ausgeführt werden kann.

studio.commands.register(
  'meineExt.tuEtwas',
  (arg1: string, arg2: number) => {
    // Command-Logik
  },
  () => {
    // Optional: Wann ist der Command aktiviert?
    return studio.editors.getFocusedEditorDocument() != null;
  },
);

registerInCommandSearch(name, description, callback, enabledPredicate?)

Wie register, aber der Command erscheint zusätzlich in der Command Palette (Cmd+Shift+P).

studio.commands.registerInCommandSearch(
  'meineExt.tuEtwas',
  'Meine Extension: Tu etwas',   // Label in der Command Palette
  () => { /* ... */ },
);

executeCommand<T>(name, ...args)

Führt einen registrierten Command aus und gibt das Ergebnis zurück.

const result = studio.commands.executeCommand<string>('meineExt.tuEtwas', 'arg1', 42);

tryToExecuteCommand<T>(name, ...args)

Wie executeCommand, aber wirft keine Exception wenn der Command nicht existiert.

const result = studio.commands.tryToExecuteCommand<string>('meineExt.tuEtwas');
if (result.success) {
  console.log(result.value);
}

isCommandEnabled(name, ...args)

Prüft, ob ein Command aktuell aktiviert ist.

isRegistered(name)

Prüft, ob ein Command registriert ist.

getCommands()

Gibt alle registrierten Commands zurück.

EditorMediator

Verwaltet Editor-Dokumente und Dokumenttypen.

Methoden

registerDocumentType(id, definition)

Registriert einen neuen Dokumenttyp.

studio.editors.registerDocumentType('mein-typ', {
  uriMatch: /\.myext$/,
  modelKey: 'MeinModel',
  modelConstructor: MeinModel,
  rendererKey: 'MeinRenderer',
  rendererConstructor: MeinRenderer,
  icon: 'mein-icon',
  inspectorKey: 'MeinInspector',            // Optional
  inspectorConstructor: MeinInspector,       // Optional
});

createNewEditorDocument(uri, initialData)

Erstellt ein neues Dokument mit einer URI und Initialdaten.

createNewEditorDocumentAsBuffer(docType, initialData?)

Erstellt ein neues Buffer-Dokument (ungespeichert).

focusOrOpenEditorDocument(docOrUri, label?)

Öffnet ein Dokument oder fokussiert es, falls bereits geöffnet.

closeEditorDocument(doc)

Schließt ein Dokument. Fragt bei ungespeicherten Änderungen nach.

saveEditorDocument(doc)

Speichert ein Dokument.

getFocusedEditorDocument()

Gibt das aktuell fokussierte Dokument zurück (oder null).

getOpenEditorDocuments()

Gibt alle geöffneten Dokumente zurück.

getEditorDocumentByUri(uri)

Findet ein offenes Dokument anhand seiner URI.

getEditorDocumentModel<T>(doc)

Gibt das Model eines Dokuments zurück.

MenuMediator

Registriert und verwaltet Menüs.

Methoden

registerMenu(menuId, factoryFn)

Registriert ein neues Menü.

studio.menus.registerMenu('meineExt/mein-menu', (args) => {
  return [
    { type: 'command', id: 'item1', label: 'Eintrag 1', command: 'cmd1' },
    { type: 'divider' },
    { type: 'command', id: 'item2', label: 'Eintrag 2', command: 'cmd2' },
  ];
});

registerMenuModifier(menuId, modifierFn)

Erweitert ein bestehendes Menü.

studio.menus.registerMenuModifier('std/context-menu', (menu, studio) => {
  return studio.menus.appendToMenu(menu, [
    { type: 'command', id: 'mein-item', label: 'Mein Eintrag', command: 'cmd' },
  ]);
});

appendToMenu(menu, items) / prependToMenu(menu, items)

Fügt Einträge am Ende bzw. Anfang des Menüs ein.

insertAfterMenuItem(menu, id, items) / insertBeforeMenuItem(menu, id, items)

Fügt Einträge nach bzw. vor einem bestimmten Eintrag ein.

getMenu(menuId, args?)

Gibt ein Menü zurück (ruft die Factory auf).

PaneMediator

Registriert Seitenpanels.

Methoden

registerPaneGroup(area, groupId, panes)

Registriert eine Gruppe von Panes in einem Bereich.

studio.panes.registerPaneGroup('left', 'meineExt/gruppe', [
  studio.panes.getPaneViaPaneProvider('pane-id', 'provider-id', module),
]);

Bereiche: 'left' | 'right' | 'bottom'

registerPaneProvider(providerId, module)

Registriert einen Pane Provider.

getPaneViaPaneProvider(paneId, providerId, module)

Erstellt ein Pane-Objekt über einen Provider.

appendToPaneGroup(area, groupId, panes) / prependToPaneGroup(area, groupId, panes)

Fügt Panes zu einer bestehenden Gruppe hinzu.

DialogManager

Zeigt modale Dialoge an.

Methoden

open(options, validationCallback?)

Öffnet einen Dialog mit Custom-Content.

const result = await studio.dialog.open({
  title: 'Bestätigung',
  message: 'Möchten Sie fortfahren?',
  actions: [
    { label: 'Abbrechen', value: 'cancel' },
    { label: 'OK', value: 'ok', primary: true },
  ],
});

prompt(title, placeholder?)

Zeigt einen einfachen Text-Eingabe-Dialog.

const name = await studio.dialog.prompt('Wie heißt das Projekt?', 'Projektname');

showOpenFile() / showOpenDirectory() / showSaveFile(options?)

Zeigt native Datei-/Ordner-Dialoge.

NotificationManager

Zeigt Toast-Benachrichtigungen an.

Methoden

open(options)

Zeigt eine Notification an.

// Einfacher Text
studio.notifications.open('Operation erfolgreich!');
 
// Mit Optionen
const id = studio.notifications.open({
  message: 'Datei gespeichert',
  type: 'success',
  duration: 3000,
});

update(id, options) / close(...ids)

Aktualisiert oder schließt Notifications.

SettingsMediator

Liest und schreibt Benutzer-Einstellungen.

Methoden

registerDefaults(config)

Registriert Standardwerte für Einstellungen.

studio.settings.registerDefaults({
  'meineExtension.autoSave': true,
  'meineExtension.theme': 'standard',
  'meineExtension.maxItems': 100,
});

get(key) / set(key, value) / has(key)

Liest, setzt und prüft Einstellungen.

const autoSave = studio.settings.get('meineExtension.autoSave');
studio.settings.set('meineExtension.theme', 'dunkel');

FileHandlingService

Datei-I/O-Operationen.

Methoden

load(uri) / save(uri, content)

Laden und Speichern von Dateien.

isDirectory(uri) / listDirectory(uri) / traverseDirectory(uri, callback, excludedPatterns?)

Verzeichnis-Operationen.

createDirectory(uri) / deleteFilesAndDirectories(uris) / renameFileOrDirectory(from, to)

Verzeichnis- und Datei-Verwaltung.

doesFileOrDirectoryExist(uri)

Prüft, ob eine Datei oder ein Verzeichnis existiert.

watchDirectory(uri, callback, ignoredPatterns?) / watchFile(uri, callback)

File-Watcher für Änderungen.

getFilename(uri) / getFileExtension(uri) / joinPaths(left, right)

Pfad-Utilities.

EngineManager

Verwaltet Verbindungen zu ProcessCube-Engines.

Methoden

createConnection(uri) / disconnectEngine(uri)

Engine-Verbindungen herstellen und trennen.

getConnectedEngines() / getUnconnectedEngines() / getConnectionHistory()

Engines auflisten.

checkIfEngineIsReachable(url) / getEngineInfo(uri)

Engine-Status prüfen.

getIdentityForRequest(uri)

Gibt die Identität für API-Anfragen an eine Engine zurück.

ActivityBarMediator

Methoden

registerActivityBarItem(area, id, factoryFn)

Registriert ein Activity Bar Item.

Bereiche: 'top' | 'bottom'

toggleActivity(id)

Toggelt die Sichtbarkeit einer Activity.

setActivityBarItemVisibility(id, visible)

Setzt die Sichtbarkeit direkt.

StatusBarMediator

Methoden

registerStatusBarItem(area, id, factoryFn)

Registriert ein Status Bar Item.

Bereiche: 'left' | 'right'

StudioEventService

Event-basierte Kommunikation zwischen Komponenten.

Methoden

on(event, callback) / once(event, callback)

Event-Listener registrieren.

emit(event, ...args)

Event auslösen.

// Auf ein Event hören
studio.events.on('myExtension.dataChanged', (data) => {
  console.log('Daten geändert:', data);
});
 
// Event auslösen
studio.events.emit('myExtension.dataChanged', { key: 'value' });

Environment

Informationen über die Laufzeitumgebung.

Properties

SDK-Komponenten

Das SDK stellt React-Komponenten für häufige UI-Aufgaben bereit:

import { MonacoEditor, DurationPicker, FormInput } from '@5minds/processcube_studio_sdk';