feat: Добавление команды быстрой навигации по метаданным и интерфейса выбора объектов метаданных (#16)

package.json

@@ -109,6 +109,11 @@
 			{
 				"command": "metadataViewer.clearFilter",
 				"title": "%1c-metadata-viewer.clearFilter.title%"
+			},
+			{
+				"command": "metadataViewer.quickNavigateMetadata",
+				"title": "Перейти к объекту метаданных",
+				"category": "1C"
 			}
 		],
 		"menus": {
@@ -218,6 +223,14 @@
 					}
 				}
 			}
+		],
+		"keybindings": [
+			{
+				"command": "metadataViewer.quickNavigateMetadata",
+				"key": "ctrl+alt+m",
+				"mac": "cmd+alt+m",
+				"when": "editorTextFocus || editorFocus || viewFocus || true"
+			}
 		]
 	},
 	"scripts": {

src/commands/quickNavigateMetadata.ts

@@ -0,0 +1,326 @@
+import * as vscode from 'vscode';
+import { MetadataView } from '../metadataView';
+import { MetadataItem } from '../model/metadataItem';
+import { TreeItem } from '../ConfigurationFormats/utils';
+
+export class QuickNavigateMetadataCommand {
+    private metadataView: MetadataView;
+
+    constructor(metadataView: MetadataView) {
+        this.metadataView = metadataView;
+    }
+
+    public async execute() {
+        // Получаем все метаданные из просмотрщика
+        const allMetadata = await this.getAllMetadataItems();
+
+        if (!allMetadata || allMetadata.length === 0) {
+            vscode.window.showInformationMessage('Метаданные не найдены. Убедитесь, что открыт проект 1С.');
+            return;
+        }
+
+        // Создаем интерфейс быстрого выбора
+        const quickPick = vscode.window.createQuickPick<MetadataQuickPickItem>();
+        quickPick.placeholder = 'Введите часть названия объекта метаданных (например, "общего назначения")';
+        quickPick.matchOnDescription = true;
+        quickPick.matchOnDetail = true;
+
+        // Начальный список всех элементов
+        const allItems = allMetadata.map(item => this.createQuickPickItem(item));
+        quickPick.items = allItems;
+
+        // Обработчик изменения текста поиска
+        quickPick.onDidChangeValue(() => {
+            if (quickPick.value.length > 0) {
+                const searchTerms = quickPick.value.toLowerCase().split(' ');
+                quickPick.items = allItems.filter(item => {
+                    return this.matchesSearchTerms(item, searchTerms);
+                });
+            } else {
+                quickPick.items = allItems;
+            }
+        });
+
+        // Обработчик выбора элемента
+        quickPick.onDidAccept(async () => {
+            const selectedItem = quickPick.selectedItems[0];
+            if (selectedItem) {
+                quickPick.hide();
+
+                // Находим элемент метаданных, который был выбран
+                const metadataItem = selectedItem.metadata;
+
+                // Открываем элемент в просмотрщике метаданных
+                await this.openMetadataItem(metadataItem);
+            }
+        });
+
+        // Показываем интерфейс быстрого выбора
+        quickPick.show();
+    }
+
+    private async getAllMetadataItems(): Promise<MetadataItem[]> {
+        // Получаем все элементы метаданных
+        const treeItems = await this.getTreeItems();
+        return this.convertTreeItemsToMetadataItems(treeItems);
+    }
+
+    private async getTreeItems(): Promise<TreeItem[]> {
+        // Проверяем наличие dataProvider в metadataView
+        if (!this.metadataView.dataProvider) {
+            return [];
+        }
+
+        // Получаем корневые элементы через dataProvider
+        const rootItems = await this.metadataView.dataProvider.getChildren();
+        if (!rootItems || rootItems.length === 0) {
+            return [];
+        }
+
+        // Ищем конфигурации (обычно первый элемент)
+        const configurationsItem = rootItems[0];
+        if (!configurationsItem) {
+            return [];
+        }
+
+        // Получаем дочерние элементы конфигураций
+        const configChildren = await this.metadataView.dataProvider.getChildren(configurationsItem);
+        return configChildren || [];
+    }
+
+    private convertTreeItemsToMetadataItems(items: TreeItem[], parent?: MetadataItem): MetadataItem[] {
+        const result: MetadataItem[] = [];
+
+        items.forEach(item => {
+            // Преобразуем TreeItem в MetadataItem
+            const metadataItem: MetadataItem = {
+                id: item.id || '',
+                name: typeof item.label === 'string' ? item.label : item.label?.label || '',
+                type: item.contextValue || '',
+                file: item.path,
+                parent: parent
+            };
+
+            result.push(metadataItem);
+
+            // Рекурсивно обрабатываем дочерние элементы
+            if (item.children && item.children.length > 0) {
+                const childItems = this.convertTreeItemsToMetadataItems(item.children, metadataItem);
+                metadataItem.children = childItems;
+                result.push(...childItems);
+            }
+        });
+
+        return result;
+    }
+
+    private createQuickPickItem(metadata: MetadataItem): MetadataQuickPickItem {
+        // Формируем путь для отображения
+        const path = this.getMetadataPath(metadata);
+
+        return {
+            label: metadata.name,
+            description: path,
+            detail: metadata.type,
+            metadata: metadata
+        };
+    }
+
+    private getMetadataPath(metadata: MetadataItem): string {
+        // Формируем путь в виде "Тип\Имя\Подтип"
+        let current: MetadataItem | undefined = metadata;
+        const pathParts: string[] = [];
+
+        while (current) {
+            pathParts.unshift(current.name);
+            current = current.parent;
+        }
+
+        return pathParts.join('\\');
+    }
+
+    private matchesSearchTerms(item: MetadataQuickPickItem, searchTerms: string[]): boolean {
+        // Собираем все возможные варианты названия
+        const itemLabel = item.label.toLowerCase();
+        const itemDescription = item.description?.toLowerCase() || '';
+        const itemDetail = item.detail?.toLowerCase() || '';
+
+        // Разбиваем название метаданных на части (например, "ОбщегоНазначенияБТС" -> "общего", "назначения", "бтс")
+        const nameParts: string[] = [];
+
+        // Разбиваем CamelCase строки
+        const splitCamelCase = (text: string): string[] => {
+            // Преобразуем кириллицу из CamelCase в отдельные слова
+            return text.replace(/([а-яА-Я])(?=[А-Я])/g, '$1 ').toLowerCase().split(' ');
+        };
+
+        // Получаем части имени из различных источников
+        const labelParts = splitCamelCase(item.label);
+        nameParts.push(...labelParts);
+
+        // Добавляем полное имя метаданных (например "CommonModule.ОбщегоНазначения")
+        if (itemDescription.includes('\\')) {
+            const parts = itemDescription.split('\\');
+            for (const part of parts) {
+                // Разбиваем каждую часть пути на слова
+                nameParts.push(...splitCamelCase(part));
+
+                // Добавляем также полные пути для поиска
+                nameParts.push(part);
+            }
+        }
+
+        // Добавляем тип метаданных (для поиска по типу)
+        if (itemDetail) {
+            nameParts.push(itemDetail);
+        }
+
+        // Собираем все строки для поиска
+        const textToSearch = [
+            // Полное название элемента
+            itemLabel,
+            // Все части для сопоставления с сокращениями
+            ...nameParts,
+            // Полный путь
+            itemDescription,
+            // Тип
+            itemDetail
+        ].join(' ').toLowerCase();
+
+        // Проверяем, содержится ли каждый поисковый термин в строке для поиска
+        // или соответствует ли он началу какой-либо части названия (для сокращений)
+        return searchTerms.every(term => {
+            // Прямое вхождение в какую-либо строку поиска
+            if (textToSearch.includes(term)) {
+                return true;
+            }
+
+            // Проверка на сокращения (например "общ" -> "общего")
+            // Ищем части, которые начинаются с поискового термина
+            for (const part of nameParts) {
+                if (part.startsWith(term)) {
+                    return true;
+                }
+            }
+
+            // Также проверяем совпадение с транслитерацией
+            // Например, "obsh" -> "общего"
+            const translitMap: {[key: string]: string} = {
+                'a': 'а', 'b': 'б', 'v': 'в', 'g': 'г', 'd': 'д', 'e': 'е', 'yo': 'ё', 'zh': 'ж',
+                'z': 'з', 'i': 'и', 'j': 'й', 'k': 'к', 'l': 'л', 'm': 'м', 'n': 'н', 'o': 'о',
+                'p': 'п', 'r': 'р', 's': 'с', 't': 'т', 'u': 'у', 'f': 'ф', 'h': 'х', 'ts': 'ц',
+                'ch': 'ч', 'sh': 'ш', 'sch': 'щ', 'y': 'ы', 'yu': 'ю', 'ya': 'я'
+            };
+
+            // Преобразуем латинский поисковый термин в кириллицу для поиска
+            let translitTerm = term;
+            for (const [latin, cyrillic] of Object.entries(translitMap)) {
+                translitTerm = translitTerm.replace(new RegExp(latin, 'g'), cyrillic);
+            }
+
+            if (translitTerm !== term && textToSearch.includes(translitTerm)) {
+                return true;
+            }
+
+            return false;
+        });
+    }
+
+    private async openMetadataItem(metadata: MetadataItem): Promise<void> {
+        // Если у элемента есть путь к файлу, открываем его
+        if (metadata.file) {
+            try {
+                const document = await vscode.workspace.openTextDocument(metadata.file);
+                await vscode.window.showTextDocument(document);
+            } catch (error) {
+                console.error(`Ошибка при открытии файла ${metadata.file}:`, error);
+            }
+        }
+
+        // Находим соответствующий TreeItem в дереве
+        // Используем dataProvider для обхода дерева
+        const treeItem = await this.findTreeItemById(metadata.id);
+
+        if (treeItem) {
+            // Выполняем команду для открытия соответствующего модуля
+            // в зависимости от типа элемента метаданных
+            await this.executeCommandForTreeItem(treeItem);
+
+            // Выделяем элемент в дереве метаданных
+            await this.revealTreeItem(treeItem);
+        }
+    }
+
+    private async findTreeItemById(id: string): Promise<TreeItem | undefined> {
+        if (!this.metadataView.dataProvider) {
+            return undefined;
+        }
+
+        // Получаем корневые элементы
+        const rootItems = await this.metadataView.dataProvider.getChildren();
+        if (!rootItems || rootItems.length === 0) {
+            return undefined;
+        }
+
+        // Ищем элемент по ID с помощью рекурсивной функции
+        return this.findTreeItemByIdRecursive(rootItems, id);
+    }
+
+    private async findTreeItemByIdRecursive(items: TreeItem[], id: string): Promise<TreeItem | undefined> {
+        for (const item of items) {
+            if (item.id === id) {
+                return item;
+            }
+
+            if (item.children && item.children.length > 0) {
+                const found = await this.findTreeItemByIdRecursive(item.children, id);
+                if (found) {
+                    return found;
+                }
+            } else if (this.metadataView.dataProvider) {
+                // Если у элемента нет детей в памяти, попробуем получить их через dataProvider
+                const children = await this.metadataView.dataProvider.getChildren(item);
+                if (children && children.length > 0) {
+                    const found = await this.findTreeItemByIdRecursive(children, id);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    private async executeCommandForTreeItem(item: TreeItem): Promise<void> {
+        // Выполняем соответствующую команду в зависимости от типа элемента
+        if (item.command) {
+            if (typeof item.command === 'string') {
+                await vscode.commands.executeCommand(item.command);
+            } else if (item.command.command) {
+                await vscode.commands.executeCommand(item.command.command, ...(item.command.arguments || []));
+            }
+        } else if (item.contextValue) {
+            // Определяем, какую команду выполнить на основе contextValue
+            if (item.contextValue.includes('form')) {
+                await vscode.commands.executeCommand('metadataViewer.openForm', item);
+            } else if (item.contextValue.includes('object')) {
+                await vscode.commands.executeCommand('metadataViewer.openObjectModule', item);
+            } else if (item.contextValue.includes('manager')) {
+                await vscode.commands.executeCommand('metadataViewer.openManagerModule', item);
+            } else if (item.contextValue.includes('module')) {
+                await vscode.commands.executeCommand('metadataViewer.openModule', item);
+            }
+        }
+    }
+
+    private async revealTreeItem(item: TreeItem): Promise<void> {
+        // Прокручиваем дерево к выбранному элементу
+        await vscode.commands.executeCommand('metadataView.reveal', item);
+    }
+}
+
+// Интерфейс для элементов быстрого выбора
+interface MetadataQuickPickItem extends vscode.QuickPickItem {
+    metadata: MetadataItem;
+} 

src/extension.ts

@@ -5,6 +5,7 @@ import { MetadataView } from './metadataView';
 import * as fs from 'fs';
 import { FormPreviewer } from './formPreviewer';
 import { TreeItem } from './ConfigurationFormats/utils';
+import { QuickNavigateMetadataCommand } from './commands/quickNavigateMetadata';
 
 export function activate(context: vscode.ExtensionContext) {
 	vscode.commands.registerCommand('metadataViewer.openAppModule', (node: TreeItem) => {
@@ -136,7 +137,17 @@ export function activate(context: vscode.ExtensionContext) {
 		OpenFile(filePath);
 	});
 
-	new MetadataView(context);
+	const metadataView = new MetadataView(context);
+
+	// Регистрация команды быстрой навигации по метаданным
+	context.subscriptions.push(
+		vscode.commands.registerCommand('metadataViewer.quickNavigateMetadata', () => {
+			const command = new QuickNavigateMetadataCommand(metadataView);
+			command.execute().catch(error => {
+				vscode.window.showErrorMessage(`Ошибка выполнения команды: ${error.message}`);
+			});
+		})
+	);
 }
 
 function OpenFile(filePath: string) {

src/metadataView.ts

@@ -59,7 +59,7 @@ export class MetadataView {
   panel: vscode.WebviewPanel | undefined = undefined;
   // Фильтр нужен по каждой конфигурации отдельно
   subsystemFilter: { id: string; objects: string[] }[] = [];
-  dataProvider: NodeWithIdTreeDataProvider | null = null;
+  public dataProvider: NodeWithIdTreeDataProvider | null = null;
 
 	constructor(context: vscode.ExtensionContext) {
     this.rootPath = (vscode.workspace.workspaceFolders && (vscode.workspace.workspaceFolders.length > 0))