iwgt 2.4.9 → 2.4.11

package/dist/tools/index.js

@@ -12,6 +12,8 @@ import liquidFilters from '../data/references/liquid-filters.json' with { type:
 import commonjsApiComplete from '../data/references/commonjs-api-complete.json' with { type: 'json' };
 import collectionsMenuPatterns from '../data/references/collections-menu-patterns.json' with { type: 'json' };
 import librariesApiReference from '../data/references/libraries-api-reference.json' with { type: 'json' };
+import insalesPermanentLinks from '../data/insales-permanent-links.json' with { type: 'json' };
+import javascriptGuide from '../data/references/javascript-guide.json' with { type: 'json' };
 /**
  * Получить список блок-темплейтов с фильтрацией
  */
@@ -31,17 +33,15 @@ export function getBlockTemplates(args = {}) {
     }
     return {
         total: templates.length,
-        category: category || 'all',
         templates: templates.map((t) => ({
             handle: t.handle,
             name: t.name,
+            description: t.description,
             keywords: t.keywords,
-            fields: t.fields.map((f) => ({
-                name: f.name,
-                handle: f.handle,
-                kind: f.kind,
-            })),
-        })),
+            category: t.category,
+            type: t.type,
+            usage: t.usage
+        }))
     };
 }
 /**
@@ -50,12 +50,10 @@ export function getBlockTemplates(args = {}) {
  */
 export function getAvailableIcons(args = {}) {
     const { search, category } = args;
-    const iconsData = iconsRegistry;
-    const defaultIcons = iconsData.iconSets?.default?.icons || [];
-    let icons = defaultIcons;
+    const data = iconsRegistry;
+    let icons = data.icons || [];
     if (category) {
-        const categoryIcons = iconsData.categories?.[category] || [];
-        icons = icons.filter((icon) => categoryIcons.includes(icon.name));
+        icons = icons.filter((icon) => icon.category === category);
     }
     if (search) {
         const searchLower = search.toLowerCase();
@@ -64,46 +62,35 @@ export function getAvailableIcons(args = {}) {
     }
     return {
         total: icons.length,
-        description: 'Иконки используются через иконочный шрифт, который уже подключен в шаблоне',
-        usage: {
-            liquid: 'В Liquid шаблонах: <i class="icon icon-название"></i>',
-            html: 'В HTML/JS: <i class="icon icon-название"></i>',
-            example: '<i class="icon icon-cart"></i> <!-- выведет иконку корзины -->',
-            note: 'Фильтра | icon НЕ СУЩЕСТВУЕТ в InSales. Используйте только HTML классы.'
-        },
         icons: icons.map((icon) => ({
             name: icon.name,
+            class: `icon-${icon.name}`,
             keywords: icon.keywords,
-            htmlClass: `<i class="icon icon-${icon.name}"></i>`,
-            className: `icon icon-${icon.name}`,
-        })),
+            category: icon.category,
+            usage: `<i class="icon icon-${icon.name}"></i>`
+        }))
     };
 }
 /**
  * Получить информацию о категории виджетов
  */
-export function getCategoryInfo(args) {
+export function getCategoryInfo(args = {}) {
     const { category } = args;
     if (!category) {
-        const categories = Object.keys(categorySettings);
         return {
-            available_categories: categories,
-            message: "Укажите category для получения детальной информации",
+            error: 'Не указана категория'
         };
     }
-    const categoryData = categorySettings[category];
+    const data = categorySettings;
+    const categoryData = data.categories?.[category];
     if (!categoryData) {
         return {
-            error: `Категория "${category}" не найдена`,
-            available_categories: Object.keys(categorySettings),
+            error: `Категория '${category}' не найдена`
         };
     }
     return {
         category,
-        libraries: categoryData.libraries,
-        common_settings: categoryData.commonSettings,
-        examples: categoryData.examples || [],
-        block_templates: (categoryBlockTemplates[category] || []).map((t) => t.handle),
+        ...categoryData
     };
 }
 /**
@@ -111,339 +98,79 @@ export function getCategoryInfo(args) {
  */
 export function getLibrariesInfo(args = {}) {
     const { category } = args;
+    const data = librariesRegistry;
+    let libraries = data.libraries || [];
     if (category) {
-        const categoryData = categorySettings[category];
-        if (!categoryData) {
-            return { error: `Категория "${category}" не найдена` };
-        }
-        const categoryLibraries = categoryData.libraries;
-        const librariesData = librariesRegistry.libraries || [];
-        const libraries = librariesData.filter((lib) => categoryLibraries.includes(lib.name));
-        return {
-            category,
-            libraries: libraries.map((lib) => ({
-                name: lib.name,
-                description: lib.description,
-                documentation: lib.documentation,
-            })),
-        };
+        libraries = libraries.filter((lib) => lib.category === category);
     }
-    const librariesData = librariesRegistry.libraries || [];
     return {
-        libraries: librariesData.map((lib) => ({
+        total: libraries.length,
+        libraries: libraries.map((lib) => ({
             name: lib.name,
+            handle: lib.handle,
             description: lib.description,
-            documentation: lib.documentation,
-            categories: lib.categories,
-        })),
+            category: lib.category,
+            type: lib.type,
+            usage: lib.usage
+        }))
     };
 }
-/**
- * Получить справочник Liquid переменных
- */
-export function getLiquidVariables(args = {}) {
-    const { category, search } = args;
-    const data = liquidVariables;
-    if (!category && !search) {
-        return {
-            categories: data.categories.map(cat => ({
-                name: cat.name,
-                count: cat.variables.length,
-            })),
-            total_variables: data.categories.reduce((sum, cat) => sum + cat.variables.length, 0),
-            message: "Укажите category или search для получения переменных",
-        };
-    }
-    if (category) {
-        const cat = data.categories.find(c => c.name.toLowerCase() === category.toLowerCase());
-        if (!cat) {
-            return {
-                error: `Категория "${category}" не найдена`,
-                available_categories: data.categories.map(c => c.name),
-            };
-        }
-        return {
-            category: cat.name,
-            count: cat.variables.length,
-            variables: cat.variables,
-        };
-    }
-    if (search) {
-        const searchLower = search.toLowerCase();
-        const results = [];
-        data.categories.forEach(cat => {
-            cat.variables.forEach(v => {
-                if (v.name.toLowerCase().includes(searchLower) ||
-                    v.description?.toLowerCase().includes(searchLower)) {
-                    results.push({
-                        ...v,
-                        category: cat.name,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            count: results.length,
-            variables: results,
-        };
-    }
-}
 /**
  * Получить справочник Liquid фильтров
  */
 export function getLiquidFilters(args = {}) {
     const { category, search } = args;
     const data = liquidFilters;
-    if (!category && !search) {
-        return {
-            categories: data.categories.map(cat => ({
-                name: cat.name,
-                count: cat.filters.length,
-            })),
-            total_filters: data.categories.reduce((sum, cat) => sum + cat.filters.length, 0),
-            message: "Укажите category или search для получения фильтров",
-        };
-    }
+    let filters = data.filters || [];
     if (category) {
-        const cat = data.categories.find(c => c.name.toLowerCase() === category.toLowerCase());
-        if (!cat) {
-            return {
-                error: `Категория "${category}" не найдена`,
-                available_categories: data.categories.map(c => c.name),
-            };
-        }
-        return {
-            category: cat.name,
-            count: cat.filters.length,
-            filters: cat.filters,
-        };
+        filters = filters.filter((filter) => filter.category === category);
     }
     if (search) {
         const searchLower = search.toLowerCase();
-        const results = [];
-        data.categories.forEach(cat => {
-            cat.filters.forEach(f => {
-                if (f.name.toLowerCase().includes(searchLower) ||
-                    f.description?.toLowerCase().includes(searchLower)) {
-                    results.push({
-                        ...f,
-                        category: cat.name,
-                    });
-                }
-            });
-        });
-        return {
-            search,
-            count: results.length,
-            filters: results,
-        };
+        filters = filters.filter((filter) => filter.name.toLowerCase().includes(searchLower) ||
+            filter.description?.toLowerCase().includes(searchLower));
     }
+    return {
+        total: filters.length,
+        categories: data.categories || [],
+        filters: filters.map((filter) => ({
+            name: filter.name,
+            description: filter.description,
+            category: filter.category,
+            syntax: filter.syntax,
+            examples: filter.examples
+        }))
+    };
 }
 /**
- * Получить справочник CommonJS API v2 для InSales
- * ОБНОВЛЕНО: использует commonjs-api-complete.json с акцентом на глобальные переменные
+ * Получить справочник CommonJS API
  */
 export function getCommonJSAPI(args = {}) {
     const { category, module, search } = args;
-    const completeData = commonjsApiComplete;
-    // Без параметров - критическая информация и обзор
-    if (!category && !module && !search) {
-        return {
-            version: completeData.version,
-            title: completeData.title,
-            description: completeData.description,
-            critical_info: completeData.critical_info,
-            installation: completeData.installation,
-            global_modules: Object.keys(completeData.global_modules).map(name => ({
-                name,
-                description: completeData.global_modules[name].description,
-                global_access: completeData.global_modules[name].global_access,
-                declarative: completeData.global_modules[name].declarative || false,
-                has_data_attributes: Object.keys(completeData.global_modules[name].data_attributes || {}).length > 0,
-                methods_count: Object.keys(completeData.global_modules[name].methods || {}).length,
-                events_count: Object.keys(completeData.global_modules[name].events || {}).length,
-            })),
-            ui_components: Object.keys(completeData.ui_components || {}).map(key => ({
-                name: completeData.ui_components[key].name,
-                description: completeData.ui_components[key].description,
-                declarative: completeData.ui_components[key].declarative,
-                no_js_needed: completeData.ui_components[key].no_js_needed,
-            })),
-            quick_reference: completeData.quick_reference,
-            message: "⚠️ ВСЕ модули доступны ГЛОБАЛЬНО! НЕ используйте import. Укажите module или search для детальной информации."
-        };
+    const data = commonjsApiComplete;
+    let modules = data.modules || [];
+    if (module) {
+        modules = modules.filter((mod) => mod.name === module);
     }
-    // Поиск по категории (для UI компонентов)
     if (category) {
-        const categoryMap = {
-            'product': ['Cart', 'Products', 'ajax_products', 'ajax_product', 'accessories'],
-            'cart': ['Cart'],
-            'lists': ['Compare', 'FavoritesProducts'],
-            'search': ['AjaxSearch'],
-            'forms': ['feedback_form', 'reviews_form', 'comments_form'],
-            'events': ['EventBus'],
-            'helpers': ['Shop', 'Template', 'ajaxAPI'],
-            'checkout': ['quick_checkout']
-        };
-        const modulesInCategory = categoryMap[category] || [];
-        const results = {
-            category,
-            global_modules: [],
-            ui_components: [],
-        };
-        modulesInCategory.forEach((modName) => {
-            if (completeData.global_modules[modName]) {
-                results.global_modules.push({
-                    name: modName,
-                    ...completeData.global_modules[modName]
-                });
-            }
-            if (completeData.ui_components[modName]) {
-                results.ui_components.push({
-                    key: modName,
-                    ...completeData.ui_components[modName]
-                });
-            }
-        });
-        return results;
-    }
-    // Поиск по модулю
-    if (module) {
-        // Сначала ищем в глобальных модулях
-        if (completeData.global_modules[module]) {
-            const mod = completeData.global_modules[module];
-            return {
-                type: 'global_module',
-                name: module,
-                ...mod,
-                usage_note: mod.declarative ?
-                    "💡 Этот модуль поддерживает декларативную работу через data-атрибуты. Используйте их вместо JavaScript где возможно." :
-                    "⚠️ Этот модуль требует JavaScript для работы.",
-                best_practices: completeData.best_practices,
-            };
-        }
-        // Затем ищем в UI компонентах
-        if (completeData.ui_components[module]) {
-            const comp = completeData.ui_components[module];
-            return {
-                type: 'ui_component',
-                key: module,
-                ...comp,
-                usage_note: comp.no_js_needed ?
-                    "✅ Этот компонент работает ПОЛНОСТЬЮ без JavaScript!" :
-                    "⚠️ Этот компонент требует инициализации через JavaScript.",
-            };
-        }
-        return {
-            error: `Модуль "${module}" не найден`,
-            available_global_modules: Object.keys(completeData.global_modules),
-            available_ui_components: Object.keys(completeData.ui_components || {}),
-        };
+        modules = modules.filter((mod) => mod.category === category);
     }
-    // Поиск по ключевому слову
     if (search) {
         const searchLower = search.toLowerCase();
-        const results = {
-            global_modules: [],
-            data_attributes: [],
-            methods: [],
-            events: [],
-            ui_components: [],
-            patterns: [],
-        };
-        // Поиск в глобальных модулях
-        Object.entries(completeData.global_modules).forEach(([name, mod]) => {
-            // Поиск по имени и описанию модуля
-            if (name.toLowerCase().includes(searchLower) ||
-                mod.description?.toLowerCase().includes(searchLower)) {
-                results.global_modules.push({
-                    name,
-                    description: mod.description,
-                    global_access: mod.global_access,
-                    declarative: mod.declarative,
-                });
-            }
-            // Поиск по data-атрибутам
-            if (mod.data_attributes) {
-                Object.entries(mod.data_attributes).forEach(([attrName, attr]) => {
-                    if (attrName.toLowerCase().includes(searchLower) ||
-                        attr.description?.toLowerCase().includes(searchLower)) {
-                        results.data_attributes.push({
-                            name: attrName,
-                            module: name,
-                            ...attr,
-                        });
-                    }
-                });
-            }
-            // Поиск по методам
-            if (mod.methods) {
-                Object.entries(mod.methods).forEach(([methodName, method]) => {
-                    if (methodName.toLowerCase().includes(searchLower) ||
-                        method.description?.toLowerCase().includes(searchLower)) {
-                        results.methods.push({
-                            name: methodName,
-                            module: name,
-                            ...method,
-                        });
-                    }
-                });
-            }
-            // Поиск по событиям
-            if (mod.events) {
-                Object.entries(mod.events).forEach(([eventName, event]) => {
-                    if (eventName.toLowerCase().includes(searchLower) ||
-                        event.description?.toLowerCase().includes(searchLower)) {
-                        results.events.push({
-                            name: eventName,
-                            module: name,
-                            ...event,
-                        });
-                    }
-                });
-            }
-        });
-        // Поиск в UI компонентах
-        if (completeData.ui_components) {
-            Object.entries(completeData.ui_components).forEach(([key, comp]) => {
-                if (key.toLowerCase().includes(searchLower) ||
-                    comp.name?.toLowerCase().includes(searchLower) ||
-                    comp.description?.toLowerCase().includes(searchLower)) {
-                    results.ui_components.push({
-                        key,
-                        ...comp,
-                    });
-                }
-            });
-        }
-        // Поиск в паттернах
-        if (completeData.common_patterns) {
-            Object.entries(completeData.common_patterns).forEach(([key, pattern]) => {
-                if (key.toLowerCase().includes(searchLower) ||
-                    pattern.title?.toLowerCase().includes(searchLower)) {
-                    results.patterns.push({
-                        key,
-                        ...pattern,
-                    });
-                }
-            });
-        }
-        const totalResults = results.global_modules.length +
-            results.data_attributes.length +
-            results.methods.length +
-            results.events.length +
-            results.ui_components.length +
-            results.patterns.length;
-        return {
-            search,
-            total_results: totalResults,
-            results,
-            note: totalResults === 0 ?
-                "Ничего не найдено. Попробуйте другой запрос или используйте module для просмотра конкретного модуля." :
-                `Найдено ${totalResults} результатов. Используйте data-атрибуты вместо JavaScript где возможно!`,
-        };
+        modules = modules.filter((mod) => mod.name.toLowerCase().includes(searchLower) ||
+            mod.description?.toLowerCase().includes(searchLower) ||
+            mod.methods?.some((m) => m.name.toLowerCase().includes(searchLower)));
     }
+    return {
+        total: modules.length,
+        modules: modules.map((mod) => ({
+            name: mod.name,
+            description: mod.description,
+            category: mod.category,
+            methods: mod.methods || [],
+            events: mod.events || []
+        }))
+    };
 }
 /**
  * Получить паттерны меню категорий
@@ -451,207 +178,254 @@ export function getCommonJSAPI(args = {}) {
 export function getCollectionsMenuPatterns(args = {}) {
     const { patternId, category } = args;
     const data = collectionsMenuPatterns;
-    // Без параметров - общая информация
-    if (!patternId && !category) {
-        return {
-            title: data.title,
-            description: data.description,
-            patterns: data.patterns.map((p) => ({
-                id: p.id,
-                name: p.name,
-                description: p.description,
-                useCase: p.useCase,
-                structure: p.structure,
-                features: p.features,
-            })),
-            total_patterns: data.patterns.length,
-            message: "Укажите patternId для получения полного кода паттерна",
-        };
-    }
-    // Поиск конкретного паттерна
+    let patterns = data.patterns || [];
     if (patternId) {
-        const pattern = data.patterns.find((p) => p.id === patternId);
-        if (!pattern) {
+        const pattern = patterns.find((p) => p.id === patternId);
+        if (pattern) {
             return {
-                error: `Паттерн "${patternId}" не найден`,
-                available_patterns: data.patterns.map((p) => p.id),
+                pattern: {
+                    id: pattern.id,
+                    name: pattern.name,
+                    description: pattern.description,
+                    category: pattern.category,
+                    code: pattern.code,
+                    settings: pattern.settings
+                }
             };
         }
-        return {
-            pattern: {
-                id: pattern.id,
-                name: pattern.name,
-                description: pattern.description,
-                useCase: pattern.useCase,
-                structure: pattern.structure,
-                cacheKeyPattern: pattern.cacheKeyPattern,
-                requiredSettings: pattern.requiredSettings,
-                liquidCode: pattern.liquidCode,
-                features: pattern.features,
-            },
-            commonPatterns: data.commonPatterns,
-            collectionMethods: data.collectionMethods,
-            dataAttributes: data.dataAttributes,
-            bestPractices: data.bestPractices,
-        };
+        return { error: `Паттерн '${patternId}' не найден` };
     }
-    // Фильтрация по категории (по useCase)
     if (category) {
-        const categoryLower = category.toLowerCase();
-        const matchingPatterns = data.patterns.filter((p) => p.useCase.toLowerCase().includes(categoryLower) ||
-            p.description.toLowerCase().includes(categoryLower));
-        return {
-            category,
-            count: matchingPatterns.length,
-            patterns: matchingPatterns.map((p) => ({
-                id: p.id,
-                name: p.name,
-                description: p.description,
-                useCase: p.useCase,
-                structure: p.structure,
-                features: p.features,
-            })),
-        };
+        patterns = patterns.filter((pattern) => pattern.category === category);
     }
+    return {
+        total: patterns.length,
+        patterns: patterns.map((pattern) => ({
+            id: pattern.id,
+            name: pattern.name,
+            description: pattern.description,
+            category: pattern.category
+        }))
+    };
 }
 /**
- * Получить справочник API библиотек
- * Объединяет информацию из libraries-registry и libraries-api-reference
+ * Получить API библиотек
  */
 export function getLibrariesAPI(args = {}) {
     const { library, search, category } = args;
-    const apiData = librariesApiReference;
-    const registryData = librariesRegistry;
-    // Без параметров - список всех библиотек с API документацией
-    if (!library && !search && !category) {
-        return {
-            title: apiData.title,
-            description: apiData.description,
-            libraries_with_api: apiData.libraries.map((lib) => ({
-                name: lib.name,
-                handle: lib.handle,
-                type: lib.type,
-                description: lib.description,
-                dependencies: lib.dependencies,
-                categories: lib.categories,
-            })),
-            total_libraries: apiData.libraries.length,
-            message: "Укажите library для получения полной документации по API, или search для поиска",
-            available_libraries: apiData.libraries.map((lib) => lib.handle),
-        };
-    }
-    // Поиск конкретной библиотеки
+    const data = librariesApiReference;
+    let libraries = data.libraries || [];
     if (library) {
-        const lib = apiData.libraries.find((l) => l.handle === library || l.name.toLowerCase() === library.toLowerCase());
-        if (!lib) {
+        const lib = libraries.find((l) => l.handle === library || l.name === library);
+        if (lib) {
             return {
-                error: `Библиотека "${library}" не найдена в API справочнике`,
-                available_libraries: apiData.libraries.map((l) => ({
-                    handle: l.handle,
-                    name: l.name,
-                })),
-                note: "Некоторые библиотеки могут не иметь подробной API документации",
+                library: {
+                    name: lib.name,
+                    handle: lib.handle,
+                    description: lib.description,
+                    type: lib.type,
+                    category: lib.category,
+                    options: lib.options || [],
+                    methods: lib.methods || [],
+                    examples: lib.examples || []
+                }
             };
         }
-        // Полная информация о библиотеке
-        return {
-            library: {
-                name: lib.name,
-                handle: lib.handle,
-                version: lib.version,
-                type: lib.type,
-                description: lib.description,
-                categories: lib.categories,
-                dependencies: lib.dependencies,
-            },
-            usage: lib.usage,
-            options: lib.options,
-            methods: lib.methods,
-            events: lib.events,
-            cssClasses: lib.cssClasses,
-            examples: lib.examples,
-            bestPractices: lib.bestPractices,
-            notes: lib.notes,
-        };
+        return { error: `Библиотека '${library}' не найдена` };
+    }
+    if (category) {
+        libraries = libraries.filter((lib) => lib.category === category);
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        libraries = libraries.filter((lib) => lib.name.toLowerCase().includes(searchLower) ||
+            lib.handle.toLowerCase().includes(searchLower) ||
+            lib.description?.toLowerCase().includes(searchLower));
+    }
+    return {
+        total: libraries.length,
+        libraries: libraries.map((lib) => ({
+            name: lib.name,
+            handle: lib.handle,
+            description: lib.description,
+            type: lib.type,
+            category: lib.category
+        }))
+    };
+}
+/**
+ * Получить справочник Liquid переменных
+ */
+export function getLiquidVariables(args = {}) {
+    const { category, search } = args;
+    const data = liquidVariables;
+    let variables = data.variables || [];
+    if (category) {
+        variables = variables.filter((variable) => variable.category === category);
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        variables = variables.filter((variable) => variable.name.toLowerCase().includes(searchLower) ||
+            variable.description?.toLowerCase().includes(searchLower));
+    }
+    return {
+        total: variables.length,
+        categories: data.categories || [],
+        variables: variables.map((variable) => ({
+            name: variable.name,
+            description: variable.description,
+            category: variable.category,
+            type: variable.type,
+            examples: variable.examples
+        }))
+    };
+}
+/**
+ * Получить постоянные ссылки InSales
+ */
+export function getInsalesPermanentLinks(args = {}) {
+    const { search } = args;
+    const data = insalesPermanentLinks;
+    let links = data.links || {};
+    if (search) {
+        const searchLower = search.toLowerCase();
+        const filteredLinks = {};
+        Object.keys(links).forEach(key => {
+            const link = links[key];
+            if (key.toLowerCase().includes(searchLower) ||
+                link.description?.toLowerCase().includes(searchLower) ||
+                link.usage?.toLowerCase().includes(searchLower)) {
+                filteredLinks[key] = link;
+            }
+        });
+        links = filteredLinks;
+    }
+    return {
+        description: data.description,
+        total: Object.keys(links).length,
+        links,
+        notes: data.notes
+    };
+}
+/**
+ * Получить руководство по JavaScript для виджетов
+ */
+export function getJavaScriptGuide(args = {}) {
+    const { section, search, pattern, error, api_module } = args;
+    const data = javascriptGuide;
+    if (section) {
+        const sectionData = data.sections?.[section];
+        if (sectionData) {
+            return {
+                section,
+                ...sectionData
+            };
+        }
+        return { error: `Раздел '${section}' не найден` };
+    }
+    if (pattern) {
+        const patterns = data.sections?.patterns?.patterns || [];
+        const foundPattern = patterns.find((p) => p.id === pattern);
+        if (foundPattern) {
+            return {
+                pattern: foundPattern
+            };
+        }
+        return { error: `Паттерн '${pattern}' не найден` };
+    }
+    if (error) {
+        const errors = data.sections?.common_errors?.errors || [];
+        const foundError = errors.find((e) => e.id === error);
+        if (foundError) {
+            return {
+                error: foundError
+            };
+        }
+        return { error: `Ошибка '${error}' не найдена` };
+    }
+    if (api_module) {
+        const modules = data.sections?.global_apis?.modules || [];
+        const foundModule = modules.find((m) => m.name === api_module);
+        if (foundModule) {
+            return {
+                module: foundModule
+            };
+        }
+        return { error: `Модуль API '${api_module}' не найден` };
     }
-    // Поиск по ключевому слову
     if (search) {
         const searchLower = search.toLowerCase();
         const results = {
-            libraries: [],
-            options: [],
-            methods: [],
-            examples: [],
+            sections: {},
+            patterns: [],
+            errors: [],
+            modules: [],
+            attributes: []
         };
-        apiData.libraries.forEach((lib) => {
-            // Поиск по библиотекам
-            if (lib.name.toLowerCase().includes(searchLower) ||
-                lib.handle.toLowerCase().includes(searchLower) ||
-                lib.description?.toLowerCase().includes(searchLower)) {
-                results.libraries.push({
-                    name: lib.name,
-                    handle: lib.handle,
-                    description: lib.description,
-                    type: lib.type,
-                });
+        // Поиск по разделам
+        Object.keys(data.sections || {}).forEach(sectionKey => {
+            const section = data.sections[sectionKey];
+            if (section.title?.toLowerCase().includes(searchLower) ||
+                section.description?.toLowerCase().includes(searchLower)) {
+                results.sections[sectionKey] = section;
+            }
+        });
+        // Поиск по паттернам
+        const patterns = data.sections?.patterns?.patterns || [];
+        patterns.forEach((pattern) => {
+            if (pattern.title?.toLowerCase().includes(searchLower) ||
+                pattern.description?.toLowerCase().includes(searchLower) ||
+                pattern.code?.toLowerCase().includes(searchLower)) {
+                results.patterns.push(pattern);
+            }
+        });
+        // Поиск по ошибкам
+        const errors = data.sections?.common_errors?.errors || [];
+        errors.forEach((error) => {
+            if (error.title?.toLowerCase().includes(searchLower) ||
+                error.description?.toLowerCase().includes(searchLower)) {
+                results.errors.push(error);
+            }
+        });
+        // Поиск по модулям API
+        const modules = data.sections?.global_apis?.modules || [];
+        modules.forEach((module) => {
+            if (module.name?.toLowerCase().includes(searchLower) ||
+                module.description?.toLowerCase().includes(searchLower)) {
+                results.modules.push(module);
+            }
+        });
+        // Поиск по data-атрибутам
+        const attributes = data.sections?.data_attributes?.attributes || [];
+        attributes.forEach((attr) => {
+            if (attr.name?.toLowerCase().includes(searchLower) ||
+                attr.description?.toLowerCase().includes(searchLower)) {
+                results.attributes.push(attr);
             }
-            // Поиск по опциям
-            lib.options?.forEach((opt) => {
-                if (opt.name.toLowerCase().includes(searchLower) ||
-                    opt.description?.toLowerCase().includes(searchLower)) {
-                    results.options.push({
-                        ...opt,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
-                }
-            });
-            // Поиск по методам
-            lib.methods?.forEach((method) => {
-                if (method.name.toLowerCase().includes(searchLower) ||
-                    method.description?.toLowerCase().includes(searchLower)) {
-                    results.methods.push({
-                        ...method,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
-                }
-            });
-            // Поиск по примерам
-            lib.examples?.forEach((example) => {
-                if (example.title?.toLowerCase().includes(searchLower) ||
-                    example.description?.toLowerCase().includes(searchLower)) {
-                    results.examples.push({
-                        ...example,
-                        library: lib.name,
-                        library_handle: lib.handle,
-                    });
-                }
-            });
         });
         return {
             search,
-            libraries_count: results.libraries.length,
-            options_count: results.options.length,
-            methods_count: results.methods.length,
-            examples_count: results.examples.length,
-            results,
-        };
-    }
-    // Фильтрация по категории
-    if (category) {
-        const categoryLibraries = apiData.libraries.filter((lib) => lib.categories?.includes(category));
-        return {
-            category,
-            count: categoryLibraries.length,
-            libraries: categoryLibraries.map((lib) => ({
-                name: lib.name,
-                handle: lib.handle,
-                description: lib.description,
-                type: lib.type,
-                usage: lib.usage,
-            })),
+            total: Object.keys(results.sections).length + results.patterns.length +
+                results.errors.length + results.modules.length + results.attributes.length,
+            results
         };
     }
+    return {
+        title: data.title,
+        description: data.description,
+        version: data.version,
+        sections: Object.keys(data.sections || {}),
+        available_sections: {
+            principles: "Основные принципы написания JavaScript",
+            global_apis: "Глобальные API (Cart, Products, EventBus, etc.)",
+            data_attributes: "Data-атрибуты CommonJS",
+            patterns: "Паттерны и примеры кода",
+            common_errors: "Частые ошибки и их исправление",
+            debugging: "Способы отладки",
+            linting: "Линтер и проверка кода",
+            checklist: "Чеклист перед завершением",
+            golden_rule: "Золотое правило"
+        }
+    };
 }
 //# sourceMappingURL=index.js.map