@boristype/bt-cli 0.1.0-alpha.0

package/build/core/linking/context.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Создание и управление контекстом линковки
+ * @module linking/context
+ */
+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.createLinkingContext = createLinkingContext;
+exports.prepareDistDirectory = prepareDistDirectory;
+exports.addLinkedPackage = addLinkedPackage;
+exports.addApiExtEntry = addApiExtEntry;
+exports.addExecutable = addExecutable;
+exports.getLinkingStats = getLinkingStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cache_1 = require("./cache");
+const logger_1 = require("../logger");
+/**
+ * Создаёт новый контекст линковки
+ *
+ * @param options - Опции для создания контекста
+ * @returns Инициализированный контекст линковки
+ *
+ * @remarks
+ * Контекст содержит:
+ * - Пути к проекту и dist директории
+ * - Списки слинкованных пакетов и api_ext записей
+ * - Глобальную карту executables
+ * - Кэш линковки
+ * - Логгер
+ */
+function createLinkingContext(options) {
+    const { projectPath, systemLinkMode = 'component', noCache = false, logger = logger_1.logger, devMode = false, changedFiles = [] } = options;
+    const distPath = path.join(projectPath, 'dist');
+    const cache = new cache_1.LinkingCache(projectPath, !noCache);
+    return {
+        projectPath,
+        distPath,
+        systemLinkMode,
+        cache,
+        linkedPackages: [],
+        apiExtEntries: [],
+        executables: new Map(),
+        logger,
+        devMode,
+        changedFiles
+    };
+}
+/**
+ * Подготавливает директорию dist
+ *
+ * @param ctx - Контекст линковки
+ * @param clean - Очистить директорию перед созданием (кэш очищается отдельно до создания контекста)
+ */
+function prepareDistDirectory(ctx, clean = false) {
+    if (clean) {
+        // Очищаем dist
+        if (fs.existsSync(ctx.distPath)) {
+            fs.rmSync(ctx.distPath, { recursive: true, force: true });
+        }
+        // Кэш уже очищен до создания контекста
+        ctx.logger.success('🧹 Cleaned dist directory and cache');
+    }
+    if (!fs.existsSync(ctx.distPath)) {
+        fs.mkdirSync(ctx.distPath, { recursive: true });
+    }
+}
+/**
+ * Добавляет результат линковки в контекст
+ *
+ * @param ctx - Контекст линковки
+ * @param result - Результат линковки пакета
+ */
+function addLinkedPackage(ctx, result) {
+    ctx.linkedPackages.push(result);
+    if (result.apiext) {
+        ctx.apiExtEntries.push(result.apiext);
+    }
+}
+/**
+ * Добавляет запись в api_ext напрямую
+ *
+ * @param ctx - Контекст линковки
+ * @param entry - Запись для api_ext.xml
+ */
+function addApiExtEntry(ctx, entry) {
+    ctx.apiExtEntries.push(entry);
+}
+/**
+ * Добавляет executable в глобальную карту
+ *
+ * @param ctx - Контекст линковки
+ * @param key - Ключ файла (packageName+version+filePath)
+ * @param url - URL файла (x-local://...)
+ */
+function addExecutable(ctx, key, url) {
+    ctx.executables.set(key, url);
+}
+/**
+ * Получает статистику линковки
+ *
+ * @param ctx - Контекст линковки
+ * @returns Объект со статистикой
+ */
+function getLinkingStats(ctx) {
+    const packagesByType = {};
+    for (const pkg of ctx.linkedPackages) {
+        const type = pkg.info.packageType;
+        packagesByType[type] = (packagesByType[type] || 0) + 1;
+    }
+    return {
+        totalPackages: ctx.linkedPackages.length,
+        totalApiExtEntries: ctx.apiExtEntries.length,
+        totalExecutables: ctx.executables.size,
+        packagesByType
+    };
+}

package/build/core/linking/dependencies.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * Дерево зависимостей проекта
+ *
+ * Построение, обход и вывод дерева npm-зависимостей.
+ * Используется линковкой для определения @boristype/* пакетов.
+ *
+ * @module linking/dependencies
+ */
+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.DependencyNode = void 0;
+exports.getCompilerRequiredDependencies = getCompilerRequiredDependencies;
+exports.buildDependencyTree = buildDependencyTree;
+exports.flattenDependencyTreeIterative = flattenDependencyTreeIterative;
+exports.printDependencyTree = printDependencyTree;
+exports.printFlattenedTree = printFlattenedTree;
+exports.extractBorisTypeDependencies = extractBorisTypeDependencies;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const logger_1 = require("../utils/logger");
+/**
+ * Узел дерева зависимостей
+ */
+class DependencyNode {
+    packageJson;
+    name;
+    version;
+    dependencies;
+    projectPath;
+    hash;
+    constructor(packageJson, projectPath = '') {
+        this.packageJson = packageJson;
+        this.name = packageJson.name;
+        this.version = packageJson.version;
+        this.dependencies = [];
+        this.projectPath = projectPath;
+        this.hash = (0, node_crypto_1.randomUUID)();
+    }
+}
+exports.DependencyNode = DependencyNode;
+/**
+ * Собирает @boristype/* зависимости компилятора из node_modules.
+ *
+ * @param projectPath - путь к корню проекта
+ * @returns массив узлов зависимостей
+ */
+async function getCompilerRequiredDependencies(projectPath) {
+    const rootPackageJsonPath = path.join(projectPath, 'package.json');
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    const rootPackageJson = JSON.parse(await node_fs_1.promises.readFile(rootPackageJsonPath, 'utf-8'));
+    const devDependencies = rootPackageJson.devDependencies || {};
+    const btcRemoteDependency = devDependencies['@boristype/bt-cli'] !== undefined;
+    if (!btcRemoteDependency) {
+        logger_1.logger.warning(`Предупреждение: В devDependencies отсутствует зависимость '@boristype/bt-cli'.`);
+        return [];
+    }
+    const btcPath = path.join(nodeModulesPath, '@boristype', 'bt-cli');
+    const btcPackageJsonPath = path.join(btcPath, 'package.json');
+    const btcPackageJson = JSON.parse(await node_fs_1.promises.readFile(btcPackageJsonPath, 'utf-8'));
+    const btcDependencies = btcPackageJson.dependencies || {};
+    const result = [];
+    logger_1.logger.info(`Загрузка зависимостей компилятора из ${btcPath}`);
+    for (const [depName, depVersion] of Object.entries(btcDependencies)) {
+        if (depName.startsWith('@boristype/')) {
+            const depPath = path.join(nodeModulesPath, '@boristype', depName.replace('@boristype/', ''));
+            logger_1.logger.info(`Загрузка зависимости компилятора: ${depName} из ${depPath}`);
+            try {
+                const depPackageJsonPath = path.join(depPath, 'package.json');
+                const depPackageJson = JSON.parse(await node_fs_1.promises.readFile(depPackageJsonPath, 'utf-8'));
+                const depNode = new DependencyNode(depPackageJson, depPath);
+                result.push(depNode);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logger_1.logger.warning(`Не удалось обработать зависимость ${depName}: ${message}`);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Строит полное дерево зависимостей проекта.
+ *
+ * @param projectPath - путь к корню проекта
+ * @returns корневой узел дерева
+ */
+async function buildDependencyTree(projectPath) {
+    const rootPackageJsonPath = path.join(projectPath, 'package.json');
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    const rootPackageJson = JSON.parse(await node_fs_1.promises.readFile(rootPackageJsonPath, 'utf-8'));
+    const rootNode = new DependencyNode(rootPackageJson, projectPath);
+    const processedModules = new Map();
+    async function processDependencies(parentNode, nodeModulesDir, packageJsonPath, visited = new Set()) {
+        let dependencies = {};
+        try {
+            const packageJson = JSON.parse(await node_fs_1.promises.readFile(packageJsonPath, 'utf-8'));
+            dependencies = packageJson.dependencies || {};
+        }
+        catch (err) {
+            logger_1.logger.warning(`Не удалось прочитать package.json для ${parentNode.name}: ${packageJsonPath}`);
+            return;
+        }
+        for (const [depName, depVersion] of Object.entries(dependencies)) {
+            const depKey = `${depName}@${depVersion}`;
+            if (visited.has(depKey)) {
+                logger_1.logger.warning(`Обнаружена циклическая зависимость: ${depKey}`);
+                continue;
+            }
+            const depPath = path.join(nodeModulesDir, depName);
+            try {
+                const depPackageJsonPath = path.join(depPath, 'package.json');
+                const depPackageJson = JSON.parse(await node_fs_1.promises.readFile(depPackageJsonPath, 'utf-8'));
+                const processedKey = `${depPackageJson.name}@${depPackageJson.version}`;
+                let depNode;
+                if (processedModules.has(processedKey)) {
+                    depNode = processedModules.get(processedKey);
+                }
+                else {
+                    depNode = new DependencyNode(depPackageJson, depPath);
+                    processedModules.set(processedKey, depNode);
+                    const newVisited = new Set(visited);
+                    newVisited.add(depKey);
+                    await processDependencies(depNode, nodeModulesDir, depPackageJsonPath, newVisited);
+                }
+                parentNode.dependencies.push(depNode);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logger_1.logger.warning(`Не удалось обработать зависимость ${depName}: ${message}`);
+            }
+        }
+    }
+    await processDependencies(rootNode, nodeModulesPath, rootPackageJsonPath);
+    return rootNode;
+}
+/**
+ * Итеративное уплощение дерева зависимостей (безопасно для больших деревьев).
+ *
+ * @param rootNode - корневой узел
+ * @returns массив узлов в порядке загрузки
+ */
+function flattenDependencyTreeIterative(rootNode) {
+    const visited = new Set();
+    const result = [];
+    const stack = [];
+    stack.push({ node: rootNode, path: new Set() });
+    while (stack.length > 0) {
+        const { node, path } = stack.pop();
+        if (path.has(node.hash)) {
+            logger_1.logger.warning(`Обнаружена циклическая зависимость: ${node.name}@${node.version}`);
+            continue;
+        }
+        if (visited.has(node.hash)) {
+            continue;
+        }
+        const unprocessedDeps = node.dependencies.filter(dep => !visited.has(dep.hash));
+        if (unprocessedDeps.length === 0) {
+            visited.add(node.hash);
+            result.push(node);
+        }
+        else {
+            stack.push({ node, path });
+            const newPath = new Set(path);
+            newPath.add(node.hash);
+            for (const dep of unprocessedDeps) {
+                if (!path.has(dep.hash)) {
+                    stack.push({ node: dep, path: newPath });
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Выводит дерево зависимостей в консоль.
+ */
+function printDependencyTree(node, depth = 0) {
+    logger_1.logger.info('\n📦 Дерево зависимостей:');
+    function printInternal(node, depth) {
+        logger_1.logger.info('='.repeat(50));
+        logger_1.logger.info(`${' '.repeat(depth * 2)}${node.name}@${node.version}  [${node.hash}]`);
+        for (const dep of node.dependencies) {
+            printInternal(dep, depth + 1);
+        }
+    }
+    printInternal(node, depth);
+}
+/**
+ * Выводит плоский список зависимостей в консоль.
+ */
+function printFlattenedTree(flatTree) {
+    logger_1.logger.info('\n📦 Плоский список зависимостей (в порядке загрузки):');
+    logger_1.logger.info('='.repeat(50));
+    flatTree.forEach((node, index) => {
+        logger_1.logger.info(`${(index + 1).toString().padStart(2)}. ${node.name}@${node.version}  [${node.hash}]`);
+    });
+}
+/**
+ * Извлекает только ws:package зависимости из плоского списка.
+ */
+function extractBorisTypeDependencies(flatTree) {
+    return flatTree.filter(node => {
+        const wsPackage = node.packageJson['ws:package'];
+        return typeof wsPackage === 'string';
+    });
+}

package/build/core/linking/executables.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Сбор информации об исполняемых объектах (executables) из пакетов
+ *
+ * @module linking/executables
+ */
+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.collectExecutables = collectExecutables;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_js_1 = require("./utils/url.js");
+const context_js_1 = require("./context.js");
+/**
+ * Собирает executables из .executables.json пакета
+ * и регистрирует их в контексте линковки
+ */
+function collectExecutables(pkgInfo, ctx) {
+    const executablesPath = path.join(pkgInfo.sourceDir, '.executables.json');
+    if (!fs.existsSync(executablesPath)) {
+        return;
+    }
+    const executablesData = JSON.parse(fs.readFileSync(executablesPath, 'utf-8'));
+    for (const exec of executablesData) {
+        const fileKey = `${exec.packageName}+${exec.packageVersion}+${exec.filePath}`;
+        const fileAbsoluteUrl = (0, url_js_1.UrlAppenPath)(pkgInfo.rootUrl, exec.filePath.replace(/\.ts$/, '.js').substring(exec.filePath.indexOf('/')));
+        (0, context_js_1.addExecutable)(ctx, fileKey, fileAbsoluteUrl);
+    }
+}

package/build/core/linking/generators/api-ext.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Генератор api_ext.xml
+ * @module linking/generators/api-ext
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildApiExt = buildApiExt;
+const xml_1 = require("../../utils/xml");
+/**
+ * Генерирует содержимое api_ext.xml файла
+ *
+ * @param entries - Массив записей для api_ext.xml
+ * @returns Содержимое api_ext.xml файла
+ *
+ * @remarks
+ * api_ext.xml содержит список модулей и их библиотек (libs).
+ * Создаётся один раз для всего проекта в dist/source/api_ext.xml.
+ *
+ * Структура:
+ * ```xml
+ * <api_ext>
+ *   <apis>
+ *     <api>
+ *       <name>module:mypackage</name>
+ *       <libs>
+ *         <lib><path>x-local://wt/mypackage/init.xml</path></lib>
+ *       </libs>
+ *     </api>
+ *   </apis>
+ * </api_ext>
+ * ```
+ *
+ * @example
+ * ```ts
+ * const entries = [
+ *   { name: 'module:polyfill', libs: ['x-local://wt/polyfill/init.xml'] },
+ *   { name: 'module:myapp', libs: ['x-local://wt/myapp/init.xml'] }
+ * ];
+ * const xml = buildApiExt(entries);
+ * ```
+ */
+function buildApiExt(entries) {
+    const xmlObj = {
+        '?xml': { '@_version': '1.0', '@_encoding': 'utf-8' },
+        'api_ext': {
+            'apis': {
+                'api': entries.map(entry => ({
+                    'name': entry.name,
+                    'libs': {
+                        'lib': entry.libs.map(libPath => ({ 'path': libPath })),
+                    },
+                })),
+            },
+        },
+    };
+    return xml_1.xmlBuilderKeepEmpty.build(xmlObj);
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Генераторы для компонентов (spxml файлы)
+ * @module linking/generators/component
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponentXml = buildComponentXml;
+exports.buildComponentJs = buildComponentJs;
+exports.buildComponentFiles = buildComponentFiles;
+const xml_1 = require("../../utils/xml");
+/**
+ * Генерирует содержимое XML файла компонента (spxml/<name>.xml)
+ *
+ * @param componentName - Имя компонента (обычно name из package.json)
+ * @returns Содержимое XML файла компонента
+ *
+ * @remarks
+ * XML файл компонента создаётся в директории spxml/.
+ * Содержит определение компонента с атрибутом CODE-LIB="1".
+ *
+ * @example
+ * ```ts
+ * buildComponentXml('my-component')
+ * // Возвращает XML с тегом <my-component></my-component>
+ * ```
+ */
+function buildComponentXml(componentName) {
+    const xmlObj = {
+        '?xml': { '@_version': '1.0', '@_encoding': 'utf-8' },
+        'SPXML-INLINE-FORM': {
+            '@_CODE-LIB': '1',
+            [componentName]: '',
+        },
+    };
+    return xml_1.xmlBuilderKeepEmpty.build(xmlObj);
+}
+/**
+ * Генерирует содержимое JS файла компонента (spxml/<name>.js)
+ *
+ * @param componentName - Имя компонента (обычно name из package.json)
+ * @param mainFile - Путь к главному файлу (main из package.json)
+ * @param rootUrl - URL корневой директории пакета (x-local://...)
+ * @returns Содержимое JS файла компонента
+ *
+ * @remarks
+ * JS файл компонента содержит функцию init(), которая:
+ * - Загружает модуль через bt.require
+ * - Логирует состояние инициализации
+ * - Обрабатывает ошибки
+ *
+ * @example
+ * ```ts
+ * buildComponentJs('my-component', './index.js', 'x-local://components/my-component')
+ * ```
+ */
+function buildComponentJs(componentName, mainFile, rootUrl) {
+    const content = `function init() {
+  try {
+    alert('Component ${componentName} initializing...');
+    bt.require('${mainFile}', '${rootUrl}/spxml')
+    alert('Component ${componentName} initialized');
+  } catch (g_err) {
+    alert('ERROR: Component initializing: ${componentName}:\\r\\n' + g_err);
+    throw g_err;
+  }
+}`;
+    return content;
+}
+/**
+ * Генерирует все файлы для компонента
+ *
+ * @param componentName - Имя компонента
+ * @param mainFile - Путь к главному файлу
+ * @param rootUrl - URL корневой директории
+ * @returns Объект с содержимым XML и JS файлов
+ */
+function buildComponentFiles(componentName, mainFile, rootUrl) {
+    return {
+        xml: buildComponentXml(componentName),
+        js: buildComponentJs(componentName, mainFile, rootUrl),
+        fileName: componentName
+    };
+}

package/build/core/linking/generators/filemap.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Генератор filemap для executable модулей
+ * @module linking/generators/filemap
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFilemapJson = generateFilemapJson;
+exports.generateFilemapJsonForPackage = generateFilemapJsonForPackage;
+/**
+ * Генерирует содержимое .filemap.json для модуля
+ *
+ * @param executables - Карта исполняемых файлов: ключ -> URL
+ * @returns JSON-строка для записи в .filemap.json
+ *
+ * @remarks
+ * Filemap используется для маппинга ключей файлов на их URL.
+ * Теперь создаётся per-module (в каждом модуле) вместо глобального bt:filemap.
+ *
+ * Структура ключа: `${packageName}+${packageVersion}+${filePath}`
+ *
+ * @example
+ * ```ts
+ * const executables = new Map([
+ *   ['mypackage+1.0.0+src/handler.js', 'x-local://wt/mypackage/handler.js']
+ * ]);
+ * const json = generateFilemapJson(executables);
+ * // -> { "mypackage+1.0.0+src/handler.js": "x-local://wt/mypackage/handler.js" }
+ * ```
+ */
+function generateFilemapJson(executables) {
+    const data = {};
+    for (const [key, value] of executables.entries()) {
+        data[key] = value;
+    }
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Генерирует filemap только для конкретного пакета
+ *
+ * @param executables - Полная карта исполняемых файлов
+ * @param packageName - Имя пакета для фильтрации
+ * @returns JSON-строка с данными только для указанного пакета
+ */
+function generateFilemapJsonForPackage(executables, packageName) {
+    const data = {};
+    const prefix = `${packageName}+`;
+    for (const [key, value] of executables.entries()) {
+        if (key.startsWith(prefix)) {
+            data[key] = value;
+        }
+    }
+    return JSON.stringify(data, null, 2);
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Генераторы для linking модуля
+ * @module linking/generators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponentPackageJsonString = exports.buildComponentPackageJson = exports.generateFilemapJsonForPackage = exports.generateFilemapJson = exports.buildApiExt = exports.buildComponentFiles = exports.buildComponentJs = exports.buildComponentXml = exports.buildInitXml = void 0;
+var init_xml_1 = require("./init-xml");
+Object.defineProperty(exports, "buildInitXml", { enumerable: true, get: function () { return init_xml_1.buildInitXml; } });
+var component_1 = require("./component");
+Object.defineProperty(exports, "buildComponentXml", { enumerable: true, get: function () { return component_1.buildComponentXml; } });
+Object.defineProperty(exports, "buildComponentJs", { enumerable: true, get: function () { return component_1.buildComponentJs; } });
+Object.defineProperty(exports, "buildComponentFiles", { enumerable: true, get: function () { return component_1.buildComponentFiles; } });
+var api_ext_1 = require("./api-ext");
+Object.defineProperty(exports, "buildApiExt", { enumerable: true, get: function () { return api_ext_1.buildApiExt; } });
+var filemap_1 = require("./filemap");
+Object.defineProperty(exports, "generateFilemapJson", { enumerable: true, get: function () { return filemap_1.generateFilemapJson; } });
+Object.defineProperty(exports, "generateFilemapJsonForPackage", { enumerable: true, get: function () { return filemap_1.generateFilemapJsonForPackage; } });
+var package_json_1 = require("./package-json");
+Object.defineProperty(exports, "buildComponentPackageJson", { enumerable: true, get: function () { return package_json_1.buildComponentPackageJson; } });
+Object.defineProperty(exports, "buildComponentPackageJsonString", { enumerable: true, get: function () { return package_json_1.buildComponentPackageJsonString; } });