iwgt 2.3.0

package/dist/tools/index.js

@@ -0,0 +1,430 @@
+/**
+ * Инструменты для работы со справочной информацией
+ * Модуль содержит функции для получения данных из справочников
+ */
+import blockTemplatesFull from '../data/references/block-templates-full.json' with { type: 'json' };
+import categoryBlockTemplates from '../data/references/category-block-templates.json' with { type: 'json' };
+import iconsRegistry from '../data/references/icons-registry.json' with { type: 'json' };
+import categorySettings from '../data/references/category-settings.json' with { type: 'json' };
+import librariesRegistry from '../data/references/libraries-registry.json' with { type: 'json' };
+import liquidVariables from '../data/references/liquid-variables.json' with { type: 'json' };
+import liquidFilters from '../data/references/liquid-filters.json' with { type: 'json' };
+import commonjsReference from '../data/references/commonjs-reference.json' with { type: 'json' };
+import collectionsMenuPatterns from '../data/references/collections-menu-patterns.json' with { type: 'json' };
+/**
+ * Получить список блок-темплейтов с фильтрацией
+ */
+export function getBlockTemplates(args = {}) {
+    const { category, search } = args;
+    const fullData = blockTemplatesFull;
+    let templates = fullData.templates || [];
+    if (category) {
+        const categoryData = categoryBlockTemplates[category] || [];
+        const categoryHandles = categoryData.map((t) => t.handle);
+        templates = templates.filter((t) => categoryHandles.includes(t.handle));
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        templates = templates.filter((t) => t.keywords?.some((k) => k.toLowerCase().includes(searchLower)) ||
+            t.handle.toLowerCase().includes(searchLower));
+    }
+    return {
+        total: templates.length,
+        category: category || 'all',
+        templates: templates.map((t) => ({
+            handle: t.handle,
+            name: t.name,
+            keywords: t.keywords,
+            fields: t.fields.map((f) => ({
+                name: f.name,
+                handle: f.handle,
+                kind: f.kind,
+            })),
+        })),
+    };
+}
+/**
+ * Получить список доступных иконок
+ * Иконки используются через иконочный шрифт
+ */
+export function getAvailableIcons(args = {}) {
+    const { search, category } = args;
+    const iconsData = iconsRegistry;
+    const defaultIcons = iconsData.iconSets?.default?.icons || [];
+    let icons = defaultIcons;
+    if (category) {
+        const categoryIcons = iconsData.categories?.[category] || [];
+        icons = icons.filter((icon) => categoryIcons.includes(icon.name));
+    }
+    if (search) {
+        const searchLower = search.toLowerCase();
+        icons = icons.filter((icon) => icon.name.toLowerCase().includes(searchLower) ||
+            icon.keywords?.some((k) => k.toLowerCase().includes(searchLower)));
+    }
+    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,
+            keywords: icon.keywords,
+            htmlClass: `<i class="icon icon-${icon.name}"></i>`,
+            className: `icon icon-${icon.name}`,
+        })),
+    };
+}
+/**
+ * Получить информацию о категории виджетов
+ */
+export function getCategoryInfo(args) {
+    const { category } = args;
+    if (!category) {
+        const categories = Object.keys(categorySettings);
+        return {
+            available_categories: categories,
+            message: "Укажите category для получения детальной информации",
+        };
+    }
+    const categoryData = categorySettings[category];
+    if (!categoryData) {
+        return {
+            error: `Категория "${category}" не найдена`,
+            available_categories: Object.keys(categorySettings),
+        };
+    }
+    return {
+        category,
+        libraries: categoryData.libraries,
+        common_settings: categoryData.commonSettings,
+        examples: categoryData.examples || [],
+        block_templates: (categoryBlockTemplates[category] || []).map((t) => t.handle),
+    };
+}
+/**
+ * Получить информацию о библиотеках
+ */
+export function getLibrariesInfo(args = {}) {
+    const { category } = args;
+    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,
+            })),
+        };
+    }
+    const librariesData = librariesRegistry.libraries || [];
+    return {
+        libraries: librariesData.map((lib) => ({
+            name: lib.name,
+            description: lib.description,
+            documentation: lib.documentation,
+            categories: lib.categories,
+        })),
+    };
+}
+/**
+ * Получить справочник 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 для получения фильтров",
+        };
+    }
+    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,
+        };
+    }
+    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,
+        };
+    }
+}
+/**
+ * Получить справочник CommonJS API
+ */
+export function getCommonJSAPI(args = {}) {
+    const { category, module, search } = args;
+    const data = commonjsReference;
+    // Без параметров - общая информация
+    if (!category && !module && !search) {
+        return {
+            modules: data.modules.map(m => ({
+                name: m.name,
+                description: m.description,
+                methods_count: m.methods?.length || 0,
+                events_count: m.events?.length || 0,
+            })),
+            total_modules: data.modules.length,
+            total_methods: data.modules.reduce((sum, m) => sum + (m.methods?.length || 0), 0),
+            total_events: data.modules.reduce((sum, m) => sum + (m.events?.length || 0), 0),
+            message: "Укажите module или search для детальной информации",
+        };
+    }
+    // Поиск по категории (не используется в CommonJS)
+    if (category) {
+        // CommonJS не имеет категорий, игнорируем
+        const modules = data.modules;
+        return {
+            category,
+            modules: modules.map(m => ({
+                name: m.name,
+                description: m.description,
+                methods: m.methods,
+                attributes: m.attributes,
+                events: m.events,
+            })),
+        };
+    }
+    // Поиск по модулю
+    if (module) {
+        const mod = data.modules.find(m => m.name === module);
+        if (!mod) {
+            return {
+                error: `Модуль "${module}" не найден`,
+                available_modules: data.modules.map(m => m.name),
+            };
+        }
+        return {
+            module: mod.name,
+            description: mod.description,
+            methods: mod.methods,
+            attributes: mod.attributes,
+            events: mod.events,
+            examples: mod.examples,
+        };
+    }
+    // Поиск по ключевому слову
+    if (search) {
+        const searchLower = search.toLowerCase();
+        const results = {
+            methods: [],
+            events: [],
+            attributes: [],
+            method_events: [], // События, связанные с методами
+        };
+        data.modules.forEach(mod => {
+            // Поиск по методам
+            mod.methods?.forEach(method => {
+                if (method.name.toLowerCase().includes(searchLower) ||
+                    method.description?.toLowerCase().includes(searchLower)) {
+                    results.methods.push({
+                        ...method,
+                        module: mod.name,
+                    });
+                }
+                // Поиск по событиям внутри методов
+                method.events?.forEach(event => {
+                    if (event.name.toLowerCase().includes(searchLower) ||
+                        event.description?.toLowerCase().includes(searchLower)) {
+                        results.method_events.push({
+                            ...event,
+                            module: mod.name,
+                            method: method.name,
+                        });
+                    }
+                });
+            });
+            // Поиск по событиям модуля
+            mod.events?.forEach(event => {
+                if (event.name.toLowerCase().includes(searchLower) ||
+                    event.description?.toLowerCase().includes(searchLower)) {
+                    results.events.push({
+                        ...event,
+                        module: mod.name,
+                    });
+                }
+            });
+            // Поиск по атрибутам
+            mod.attributes?.forEach(attr => {
+                if (attr.name.toLowerCase().includes(searchLower) ||
+                    attr.description?.toLowerCase().includes(searchLower)) {
+                    results.attributes.push({
+                        ...attr,
+                        module: mod.name,
+                    });
+                }
+            });
+        });
+        return {
+            search,
+            methods_count: results.methods.length,
+            events_count: results.events.length,
+            method_events_count: results.method_events.length,
+            attributes_count: results.attributes.length,
+            note: results.attributes.length > 0
+                ? 'Data-атрибуты работают автоматически при добавлении в HTML. JavaScript не требуется для базовой функциональности.'
+                : undefined,
+            results,
+        };
+    }
+}
+/**
+ * Получить паттерны меню категорий
+ */
+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 для получения полного кода паттерна",
+        };
+    }
+    // Поиск конкретного паттерна
+    if (patternId) {
+        const pattern = data.patterns.find((p) => p.id === patternId);
+        if (!pattern) {
+            return {
+                error: `Паттерн "${patternId}" не найден`,
+                available_patterns: data.patterns.map((p) => p.id),
+            };
+        }
+        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,
+        };
+    }
+    // Фильтрация по категории (по 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,
+            })),
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/types/index.d.ts

@@ -0,0 +1,181 @@
+export interface WidgetInfo {
+    widget_category_handle: string;
+    widget_type: 'simple_widget_type' | 'block_list_widget_type';
+    snippet_type: 'liquid';
+    libraries: string[];
+    block_template_handle?: string;
+}
+export interface SettingsField {
+    name: string;
+    type: string;
+    label?: string;
+    class?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+    with_btns?: boolean;
+    value?: any;
+    helper?: string;
+    frequency?: number;
+}
+export interface BlockTemplate {
+    handle: string;
+    name: string;
+    fields: BlockField[];
+    keywords: string[];
+    usedInCategories: string[];
+    usageCount: number;
+}
+export interface BlockField {
+    handle: string;
+    kind: string;
+    name: string;
+}
+export interface CategoryData {
+    commonSettings: SettingsField[];
+    totalWidgets: number;
+    libraries: string[];
+    blockTemplates: string[];
+    examples: string[];
+}
+export interface CreateWidgetParams {
+    description: string;
+    category?: string;
+    type?: 'simple_widget_type' | 'block_list_widget_type';
+    handle?: string;
+}
+export interface WidgetFiles {
+    'info.json': string;
+    'settings_form.json': string;
+    'settings_data.json': string;
+    'snippet.liquid': string;
+    'snippet.scss': string;
+    'snippet.js': string;
+    'messages.json': string;
+    'setup.json'?: string;
+}
+export interface LiquidVariable {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'html' | 'unknown';
+    description: string;
+    example: string;
+}
+export interface LiquidVariableCategory {
+    id: string;
+    name: string;
+    description: string;
+    variables: LiquidVariable[];
+}
+export interface LiquidVariablesReference {
+    meta: {
+        source: string;
+        description: string;
+        totalCategories: number;
+        totalVariables: number;
+        generatedAt: string;
+    };
+    categories: LiquidVariableCategory[];
+}
+export interface LiquidFilter {
+    id: string;
+    name: string;
+    description: string;
+    parameters: string[];
+    example: string;
+}
+export interface LiquidFilterCategory {
+    id: string;
+    name: string;
+    description: string;
+    filters: LiquidFilter[];
+}
+export interface LiquidFiltersReference {
+    meta: {
+        source: string;
+        description: string;
+        totalCategories: number;
+        totalFilters: number;
+        generatedAt: string;
+    };
+    categories: LiquidFilterCategory[];
+}
+export interface CommonJSMethod {
+    name: string;
+    fullName: string;
+    description: string;
+    parameters: CommonJSParameter[];
+    returns: CommonJSReturn | null;
+    example: string | null;
+    events?: CommonJSEvent[];
+}
+export interface CommonJSParameter {
+    name: string;
+    type: string;
+    description: string;
+}
+export interface CommonJSReturn {
+    type: string;
+    description: string;
+}
+export interface CommonJSAttribute {
+    name: string;
+    description: string;
+    example: string | null;
+}
+export interface CommonJSEvent {
+    name: string;
+    description: string;
+}
+export interface CommonJSExample {
+    code: string;
+    language: 'javascript' | 'html';
+}
+export interface CommonJSModule {
+    name: string;
+    displayName: string;
+    description: string;
+    methods: CommonJSMethod[];
+    attributes: CommonJSAttribute[];
+    events: CommonJSEvent[];
+    examples: CommonJSExample[];
+}
+export interface CommonJSGlobalObject {
+    global: string;
+    module: string;
+    description: string;
+}
+export interface CommonJSCategory {
+    id: string;
+    name: string;
+    description: string;
+    modules: string[];
+}
+export interface CommonJSReference {
+    version: string;
+    generatedAt: string;
+    description: string;
+    installation: {
+        method: string;
+        code: string;
+        alternative: string;
+    };
+    dependencies: Array<{
+        name: string;
+        version: string;
+        url: string;
+    }>;
+    globalObjects: CommonJSGlobalObject[];
+    categories: CommonJSCategory[];
+    modules: CommonJSModule[];
+    meta: {
+        modulesCount: number;
+        methodsCount: number;
+        attributesCount: number;
+        eventsCount: number;
+        globalObjectsCount: number;
+        categoriesCount: number;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -0,0 +1,3 @@
+// Типы для виджетов InSales
+export {};
+//# sourceMappingURL=index.js.map

package/dist/utils/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Утилиты для работы с виджетами
+ * Модуль содержит вспомогательные функции
+ */
+import type { BlockTemplate } from '../types/index.js';
+/**
+ * Определить категорию виджета по описанию
+ */
+export declare function inferCategory(description: string): string;
+/**
+ * Определить тип виджета по описанию
+ */
+export declare function inferType(description: string): 'simple_widget_type' | 'block_list_widget_type';
+/**
+ * Сгенерировать handle виджета из описания
+ */
+export declare function generateHandle(description: string): string;
+/**
+ * Выбрать подходящий блок-темплейт
+ */
+export declare function selectBlockTemplate(description: string, category: string): BlockTemplate | undefined;
+/**
+ * Валидация handle виджета
+ */
+export declare function validateHandle(handle: string): {
+    valid: boolean;
+    error?: string;
+};
+//# sourceMappingURL=index.d.ts.map