@boristype/bt-cli 0.1.0-alpha.0

package/build/core/linking/generators/init-xml.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Генератор init.xml для standalone и system пакетов
+ * @module linking/generators/init-xml
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildInitXml = buildInitXml;
+const xml_1 = require("../../utils/xml");
+/**
+ * Генерирует содержимое init.xml файла для standalone/system пакетов
+ *
+ * @param mainFile - Путь к главному файлу (main из package.json)
+ * @param rootUrl - URL корневой директории пакета (x-local://...)
+ * @returns Содержимое init.xml файла
+ *
+ * @remarks
+ * init.xml используется для загрузки модуля через bt.require.
+ * Файл создаётся только для standalone и system пакетов.
+ *
+ * @example
+ * ```ts
+ * buildInitXml('./index.js', 'x-local://wt/mypackage')
+ * // Возвращает XML с bt.require('./index.js', 'x-local://wt/mypackage')
+ * ```
+ */
+function buildInitXml(mainFile, rootUrl) {
+    const xmlObj = {
+        '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+        'SPXML-INLINE-FORM': {
+            'OnInit': {
+                '@_PROPERTY': '1',
+                '@_EXPR': `\n    bt.require('${mainFile}', '${rootUrl}')\n  `,
+            },
+        },
+    };
+    return xml_1.xmlBuilder.build(xmlObj);
+}

package/build/core/linking/generators/package-json.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Генератор package.json для компонентов
+ * @module linking/generators/package-json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponentPackageJson = buildComponentPackageJson;
+exports.buildComponentPackageJsonString = buildComponentPackageJsonString;
+/**
+ * Генерирует package.json для компонента
+ *
+ * @param info - Информация о компоненте
+ * @returns Объект package.json для компонента
+ *
+ * @remarks
+ * Компоненты имеют специфичный формат package.json:
+ * - enableByDefault: true
+ * - type: 'standard'
+ * - tags: ['#public']
+ * - dependencies: {} (пустой)
+ *
+ * @example
+ * ```ts
+ * const pkgJson = buildComponentPackageJson({
+ *   name: 'my-component',
+ *   version: '1.0.0',
+ *   description: 'My awesome component'
+ * });
+ * ```
+ */
+function buildComponentPackageJson(info) {
+    return {
+        name: info.name || 'unknown',
+        version: info.version || '1.0.0.0',
+        description: info.description || info.name || 'unknown',
+        enableByDefault: true,
+        dependencies: {},
+        type: 'standard',
+        tags: ['#public']
+    };
+}
+/**
+ * Генерирует package.json как JSON-строку
+ *
+ * @param info - Информация о компоненте
+ * @returns JSON-строка package.json
+ */
+function buildComponentPackageJsonString(info) {
+    return JSON.stringify(buildComponentPackageJson(info), null, 2);
+}

package/build/core/linking/index.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Модуль линковки пакетов
+ *
+ * Реализует Pipeline + Registry архитектуру:
+ * - Pipeline: последовательные этапы обработки (resolve → link → finalize)
+ * - Registry: реестр линковщиков по типам пакетов
+ *
+ * @module linking
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkingCache = exports.addExecutable = exports.addLinkedPackage = exports.prepareDistDirectory = exports.createLinkingContext = void 0;
+exports.processLinking = processLinking;
+exports.resolvePackagesToLink = resolvePackagesToLink;
+exports.processPackagesLinking = processPackagesLinking;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../logger");
+const dependencies_1 = require("./dependencies");
+const config_1 = require("../config");
+const context_1 = require("./context");
+const cache_1 = require("./cache");
+const utils_1 = require("./utils");
+const linkers_1 = require("./linkers");
+const generators_1 = require("./generators");
+const parsers_1 = require("./parsers");
+const executables_1 = require("./executables");
+// Re-export всех типов и утилит для удобства
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./generators"), exports);
+__exportStar(require("./linkers"), exports);
+var context_2 = require("./context");
+Object.defineProperty(exports, "createLinkingContext", { enumerable: true, get: function () { return context_2.createLinkingContext; } });
+Object.defineProperty(exports, "prepareDistDirectory", { enumerable: true, get: function () { return context_2.prepareDistDirectory; } });
+Object.defineProperty(exports, "addLinkedPackage", { enumerable: true, get: function () { return context_2.addLinkedPackage; } });
+Object.defineProperty(exports, "addExecutable", { enumerable: true, get: function () { return context_2.addExecutable; } });
+var cache_2 = require("./cache");
+Object.defineProperty(exports, "LinkingCache", { enumerable: true, get: function () { return cache_2.LinkingCache; } });
+/**
+ * Главная точка входа для линковки
+ *
+ * @param options - Опции линковки
+ *
+ * @remarks
+ * Выполняет полный процесс линковки:
+ * 1. Определяет пакеты для линковки (из btconfig.json или package.json)
+ * 2. Определяет зависимости компилятора (polyfill и т.д.)
+ * 3. Обрабатывает каждый пакет через соответствующий линковщик
+ * 4. Создаёт api_ext.xml
+ */
+async function processLinking(options = {}) {
+    const projectPath = process.cwd();
+    // Получаем список пакетов для линковки
+    const packagesToLink = resolvePackagesToLink(projectPath);
+    logger_1.logger.success(`📋 Found ${packagesToLink.length} package(s) to link`);
+    await processPackagesLinking(projectPath, packagesToLink, options);
+    process.exit(0);
+}
+/**
+ * Определяет список пакетов для линковки
+ *
+ * Логика определения:
+ * 1. Если есть btconfig.json с linking.packages — используем packages
+ * 2. Если есть btconfig.json с linking (без packages) — текущий проект
+ * 3. Если нет btconfig.json — текущий проект из package.json
+ *
+ * @param projectPath - Путь к корневой директории проекта
+ * @returns Массив пакетов для линковки
+ */
+function resolvePackagesToLink(projectPath) {
+    const btConfig = (0, config_1.getBTConfig)(projectPath);
+    // Случай 1: btconfig.json с packages
+    if (btConfig?.linking?.packages && btConfig.linking.packages.length > 0) {
+        return btConfig.linking.packages;
+    }
+    // Случай 2: btconfig.json с linking (текущий проект)
+    if (btConfig?.linking && !btConfig.linking.packages) {
+        const { source, target } = btConfig.linking;
+        return [{
+                name: '.', // Текущий проект
+                source,
+                target,
+            }];
+    }
+    // Случай 3: Нет btconfig.json — проверяем package.json
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        logger_1.logger.error('❌ No btconfig.json and no package.json found. Nothing to link.');
+        process.exit(1);
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const packageType = (0, utils_1.normalizePackageType)(packageJson['ws:package']);
+    if (!packageType || !(0, utils_1.isExecutablePackageType)(packageType)) {
+        logger_1.logger.error('❌ No btconfig.json found and current project is not an executable BorisType package (ws:package must be "standalone", "component", "system"). Nothing to link.');
+        process.exit(1);
+    }
+    // Виртуальная конфигурация из package.json
+    return [{
+            name: '.', // Текущая директория
+        }];
+}
+/**
+ * Линковка пакетов
+ *
+ * @param projectPath - Путь к корню проекта
+ * @param packages - Пакеты для линковки
+ * @param options - Опции линковки (включая devMode и changedFiles)
+ */
+async function processPackagesLinking(projectPath, packages, options = {}) {
+    // При --clean сначала удаляем кэш, потом создаём контекст
+    if (options.clean) {
+        cache_1.LinkingCache.removeAll(projectPath);
+    }
+    // Создаём контекст линковки
+    const ctx = (0, context_1.createLinkingContext)({
+        projectPath,
+        systemLinkMode: options.systemLinkMode ?? 'component',
+        noCache: options.noCache,
+        logger: logger_1.logger,
+        devMode: options.devMode,
+        changedFiles: options.changedFiles
+    });
+    logger_1.logger.success(`📦 System packages will be linked as: ${ctx.systemLinkMode}`);
+    if (!ctx.cache.isEnabled()) {
+        logger_1.logger.warning('⚠️  Cache disabled (--no-cache)');
+    }
+    // Подготавливаем dist директорию (кэш уже очищен если нужно)
+    (0, context_1.prepareDistDirectory)(ctx, options.clean);
+    // Получаем зависимости, добавляемые компилятором (например, polyfill)
+    const compilerDeps = await (0, dependencies_1.getCompilerRequiredDependencies)(projectPath);
+    logger_1.logger.success('📦 Compiler dependencies (polyfill):');
+    (0, dependencies_1.printFlattenedTree)(compilerDeps);
+    // === STAGE 1: Линковка зависимостей компилятора (system пакеты) ===
+    logger_1.logger.success('📦 Copying compiler dependencies (polyfill)...');
+    for (const dep of compilerDeps) {
+        const pkgInfo = (0, parsers_1.parseCompilerDependencyPackageInfo)(dep, ctx);
+        if (!pkgInfo) {
+            continue;
+        }
+        logger_1.logger.success(`  📦 ${pkgInfo.packageJson.name}: ${pkgInfo.targetPath}`);
+        // Копируем файлы
+        (0, utils_1.copyWithPrefix)(pkgInfo.sourceDir, ctx.distPath, pkgInfo.targetPath);
+        // Линкуем через соответствующий линковщик
+        const result = (0, linkers_1.linkPackage)(pkgInfo, ctx);
+        (0, context_1.addLinkedPackage)(ctx, result);
+    }
+    // === STAGE 2: Линковка пользовательских пакетов ===
+    for (const packageConfig of packages) {
+        // name === '.' означает текущую директорию
+        const packageDirAbsolute = packageConfig.name === '.'
+            ? projectPath
+            : path.join(projectPath, packageConfig.name);
+        const displayName = packageConfig.name === '.' ? 'current project' : packageConfig.name;
+        logger_1.logger.success(`📦 Processing package: ${displayName}`);
+        // Парсим информацию о пакете
+        const pkgInfo = (0, parsers_1.parseUserPackageInfo)(projectPath, packageDirAbsolute, packageConfig, displayName);
+        if (!pkgInfo) {
+            // Обычная директория (не BT пакет) - просто копируем
+            continue;
+        }
+        // Собираем executables из .executables.json
+        (0, executables_1.collectExecutables)(pkgInfo, ctx);
+        // Линкуем через соответствующий линковщик
+        const result = (0, linkers_1.linkPackage)(pkgInfo, ctx);
+        (0, context_1.addLinkedPackage)(ctx, result);
+    }
+    // === STAGE 3: Создаём api_ext.xml ===
+    if (ctx.apiExtEntries.length > 0) {
+        const apiExtXml = (0, generators_1.buildApiExt)(ctx.apiExtEntries);
+        const apiExtXmlFilePath = path.join(ctx.distPath, 'source', 'api_ext.xml');
+        fs.mkdirSync(path.dirname(apiExtXmlFilePath), { recursive: true });
+        fs.writeFileSync(apiExtXmlFilePath, '\uFEFF' + apiExtXml, { encoding: 'utf-8' });
+        logger_1.logger.success(`📄 Generated api_ext.xml with ${ctx.apiExtEntries.length} entries`);
+    }
+    logger_1.logger.success(`✅ Linking completed (${packages.length} package(s))`);
+}

package/build/core/linking/linkers/component.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Linker для component пакетов
+ * @module linking/linkers/component
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentLinker = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const copy_1 = require("../utils/copy");
+const node_modules_1 = require("../utils/node-modules");
+const write_1 = require("../utils/write");
+const component_1 = require("../generators/component");
+const package_json_1 = require("../generators/package-json");
+const filemap_1 = require("../generators/filemap");
+/**
+ * Linker для component пакетов
+ *
+ * @remarks
+ * Component пакеты:
+ * - Помещаются в ./components/<ws:name>
+ * - Генерируют spxml/<ws:name>.xml и spxml/<ws:name>.js
+ * - Генерируют package.json для компонента
+ * - Генерируют .filemap.json (per-module)
+ * - НЕ регистрируются в api_ext.xml (своя логика загрузки)
+ * - Копируют node_modules
+ */
+exports.componentLinker = {
+    type: 'component',
+    link(pkg, ctx) {
+        const { sourceDir, targetPath, packageJson, rootUrl, projectPath, wsName } = pkg;
+        const { distPath, executables, logger, cache, devMode, changedFiles } = ctx;
+        const generatedFiles = [];
+        // Используем wsName для имён файлов и директорий
+        const componentName = wsName;
+        // Полный путь к целевой директории (./components/<ws:name>)
+        const fullTargetPath = path.join(distPath, targetPath);
+        // 1. Копируем файлы пакета
+        if (devMode && changedFiles.length > 0) {
+            // Инкрементальное копирование — только изменённые файлы
+            for (const srcFile of changedFiles) {
+                const relativePath = path.relative(sourceDir, srcFile);
+                // Пропускаем файлы не из sourceDir (например, из другого пакета)
+                if (relativePath.startsWith('..')) {
+                    continue;
+                }
+                const dstFile = path.join(fullTargetPath, relativePath);
+                fs.mkdirSync(path.dirname(dstFile), { recursive: true });
+                fs.copyFileSync(srcFile, dstFile);
+            }
+            logger.success(`  ├─ Copied ${changedFiles.length} changed file(s) to ${targetPath}`);
+        }
+        else {
+            // Полное копирование
+            (0, copy_1.copyRecursive)(sourceDir, fullTargetPath);
+            logger.success(`  ├─ Copied files to ${targetPath}`);
+        }
+        // 2. Копируем node_modules (с кэшированием) — только при полной линковке
+        if (!devMode) {
+            (0, node_modules_1.copyNodeModulesWithCache)({
+                searchDir: projectPath,
+                targetDir: fullTargetPath,
+                wsName,
+                cache,
+                logger
+            });
+        }
+        // 3. Проверяем существование spxml файлов
+        const spxmlDir = path.join(fullTargetPath, 'spxml');
+        const xmlPath = path.join(spxmlDir, `${componentName}.xml`);
+        const jsPath = path.join(spxmlDir, `${componentName}.js`);
+        const xmlExists = fs.existsSync(xmlPath);
+        const jsExists = fs.existsSync(jsPath);
+        // 4. Генерируем spxml/<name>.xml (только если нет в build/)
+        if (!xmlExists) {
+            if (!fs.existsSync(spxmlDir)) {
+                fs.mkdirSync(spxmlDir, { recursive: true });
+            }
+            const componentXmlContent = (0, component_1.buildComponentXml)(componentName);
+            if ((0, write_1.writeIfChanged)(xmlPath, componentXmlContent)) {
+                generatedFiles.push(`spxml/${componentName}.xml`);
+            }
+        }
+        // 5. Генерируем spxml/<name>.js (только если нет в build/)
+        const mainFile = packageJson.main;
+        if (mainFile && !jsExists) {
+            if (!fs.existsSync(spxmlDir)) {
+                fs.mkdirSync(spxmlDir, { recursive: true });
+            }
+            const componentJsContent = (0, component_1.buildComponentJs)(componentName, mainFile, rootUrl);
+            if ((0, write_1.writeIfChanged)(jsPath, componentJsContent)) {
+                generatedFiles.push(`spxml/${componentName}.js`);
+            }
+        }
+        // Логируем результат
+        if (!devMode) {
+            if (!xmlExists || !jsExists) {
+                const generated = [];
+                if (!xmlExists)
+                    generated.push(`${componentName}.xml`);
+                if (!jsExists && mainFile)
+                    generated.push(`${componentName}.js`);
+                if (generated.length > 0) {
+                    logger.success(`  ├─ Generated spxml/${generated.join(', spxml/')}`);
+                }
+            }
+            else {
+                logger.success(`  ├─ Using existing spxml/${componentName}.xml, spxml/${componentName}.js`);
+            }
+        }
+        // 6. Генерируем package.json для компонента (используем wsName)
+        const componentPkgJson = (0, package_json_1.buildComponentPackageJsonString)({
+            name: wsName,
+            version: packageJson.version,
+            description: packageJson.description
+        });
+        const pkgJsonPath = path.join(fullTargetPath, 'package.json');
+        if ((0, write_1.writeIfChanged)(pkgJsonPath, componentPkgJson)) {
+            generatedFiles.push('package.json');
+            if (!devMode) {
+                logger.success(`  ├─ Generated package.json`);
+            }
+        }
+        // 7. Создаём .filemap.json (per-module)
+        if (executables.size > 0) {
+            const filemapContent = (0, filemap_1.generateFilemapJson)(executables);
+            const filemapPath = path.join(fullTargetPath, '.filemap.json');
+            if ((0, write_1.writeIfChanged)(filemapPath, filemapContent)) {
+                generatedFiles.push('.filemap.json');
+                logger.success(`  ├─ Generated .filemap.json`);
+            }
+        }
+        logger.success(`  └─ Component package linked: ${componentName}`);
+        // Компоненты НЕ регистрируются в api_ext.xml
+        return {
+            info: pkg,
+            outputPath: fullTargetPath,
+            apiext: undefined,
+            generatedFiles
+        };
+    }
+};

package/build/core/linking/linkers/index.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Registry линковщиков по типам пакетов
+ * @module linking/linkers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemLinker = exports.componentLinker = exports.standaloneLinker = void 0;
+exports.getLinker = getLinker;
+exports.hasLinker = hasLinker;
+exports.linkPackage = linkPackage;
+exports.getRegisteredTypes = getRegisteredTypes;
+const standalone_1 = require("./standalone");
+const component_1 = require("./component");
+const system_1 = require("./system");
+/**
+ * Реестр линковщиков по типам пакетов
+ */
+const linkerRegistry = new Map([
+    ['standalone', standalone_1.standaloneLinker],
+    ['component', component_1.componentLinker],
+    ['system', system_1.systemLinker],
+    // library не имеет линковщика - обрабатывается через node_modules
+]);
+/**
+ * Получает линковщик для указанного типа пакета
+ *
+ * @param type - Тип пакета
+ * @returns Линковщик или undefined если не найден
+ */
+function getLinker(type) {
+    return linkerRegistry.get(type);
+}
+/**
+ * Проверяет наличие линковщика для типа пакета
+ *
+ * @param type - Тип пакета
+ * @returns true если линковщик существует
+ */
+function hasLinker(type) {
+    return linkerRegistry.has(type);
+}
+/**
+ * Выполняет линковку пакета, выбирая нужный линковщик автоматически
+ *
+ * @param pkg - Информация о пакете
+ * @param ctx - Контекст линковки
+ * @returns Результат линковки
+ * @throws Error если линковщик для типа пакета не найден
+ */
+function linkPackage(pkg, ctx) {
+    const linker = getLinker(pkg.packageType);
+    if (!linker) {
+        throw new Error(`No linker found for package type: ${pkg.packageType}`);
+    }
+    return linker.link(pkg, ctx);
+}
+/**
+ * Возвращает список всех зарегистрированных типов пакетов с линковщиками
+ */
+function getRegisteredTypes() {
+    return Array.from(linkerRegistry.keys());
+}
+// Экспорт отдельных линковщиков для прямого использования
+var standalone_2 = require("./standalone");
+Object.defineProperty(exports, "standaloneLinker", { enumerable: true, get: function () { return standalone_2.standaloneLinker; } });
+var component_2 = require("./component");
+Object.defineProperty(exports, "componentLinker", { enumerable: true, get: function () { return component_2.componentLinker; } });
+var system_2 = require("./system");
+Object.defineProperty(exports, "systemLinker", { enumerable: true, get: function () { return system_2.systemLinker; } });