@boristype/bt-cli 0.1.0-alpha.0

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

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Linker для standalone пакетов
+ * @module linking/linkers/standalone
+ */
+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.standaloneLinker = 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 init_xml_1 = require("../generators/init-xml");
+const filemap_1 = require("../generators/filemap");
+/**
+ * Linker для standalone пакетов
+ *
+ * @remarks
+ * Standalone пакеты:
+ * - Генерируют init.xml
+ * - Генерируют .filemap.json (per-module)
+ * - Регистрируются в api_ext.xml
+ * - Копируют node_modules (с кэшированием)
+ */
+exports.standaloneLinker = {
+    type: 'standalone',
+    link(pkg, ctx) {
+        const { sourceDir, targetPath, packageJson, rootUrl, projectPath, wsName } = pkg;
+        const { distPath, executables, logger, cache, devMode, changedFiles } = ctx;
+        const generatedFiles = [];
+        // Полный путь к целевой директории
+        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. Создаём init.xml (только если его нет в build/)
+        const mainFile = packageJson.main;
+        const initXmlPath = path.join(fullTargetPath, 'init.xml');
+        const initXmlExists = fs.existsSync(initXmlPath);
+        if (mainFile && !initXmlExists) {
+            const initXmlContent = (0, init_xml_1.buildInitXml)(mainFile, rootUrl);
+            if ((0, write_1.writeIfChanged)(initXmlPath, initXmlContent)) {
+                generatedFiles.push('init.xml');
+                logger.success(`  ├─ Generated init.xml`);
+            }
+        }
+        else if (initXmlExists && !devMode) {
+            logger.success(`  ├─ Using existing init.xml`);
+        }
+        // 4. Создаём .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`);
+            }
+        }
+        // 5. Формируем apiext запись
+        let apiext;
+        const wsApiext = packageJson['ws:apiext'];
+        if (wsApiext) {
+            // Явно указано в package.json
+            apiext = {
+                name: wsApiext.name,
+                libs: wsApiext.libs.map((lib) => rootUrl + '/' + path.posix.normalize(lib))
+            };
+        }
+        else if (mainFile) {
+            // Автоматически по main, используем wsName
+            apiext = {
+                name: `module:${wsName}`,
+                libs: [rootUrl + '/init.xml']
+            };
+        }
+        logger.success(`  └─ Standalone package linked: ${packageJson.name} (ws:name=${wsName})`);
+        return {
+            info: pkg,
+            outputPath: fullTargetPath,
+            apiext,
+            generatedFiles
+        };
+    }
+};

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

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Linker для system пакетов (бывший bt)
+ * @module linking/linkers/system
+ */
+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.systemLinker = void 0;
+const path = __importStar(require("path"));
+const copy_1 = require("../utils/copy");
+const node_modules_1 = require("../utils/node-modules");
+/**
+ * Linker для system пакетов
+ *
+ * @remarks
+ * System пакеты (ранее назывались 'bt'):
+ * - Уже **полностью готовы** к линковке
+ * - Все необходимые файлы (init.xml, spxml/ и т.д.) уже есть в build/
+ * - **Ничего не генерируется** - только копирование
+ * - Режим линковки определяется через CLI флаг `--linking-system-as`:
+ *   - `component` (по умолчанию): копируются в components/<ws:name>, НЕ добавляются в api_ext.xml
+ *   - `standalone`: копируются по ws:root, добавляются в api_ext.xml
+ * - Копируют node_modules
+ *
+ * Примеры: polyfill, runtime
+ */
+exports.systemLinker = {
+    type: 'system',
+    link(pkg, ctx) {
+        const { sourceDir, targetPath, packageJson, projectPath, apiext, wsName } = pkg;
+        const { distPath, logger, systemLinkMode, cache } = ctx;
+        // Полный путь к целевой директории
+        const fullTargetPath = path.join(distPath, targetPath);
+        // 1. Копируем файлы пакета как есть (всё уже готово)
+        (0, copy_1.copyRecursive)(sourceDir, fullTargetPath);
+        logger.success(`  ├─ Copied files to ${targetPath}`);
+        // 2. Копируем node_modules (с кэшированием)
+        (0, node_modules_1.copyNodeModulesWithCache)({
+            searchDir: projectPath,
+            targetDir: fullTargetPath,
+            wsName,
+            cache,
+            logger
+        });
+        logger.success(`  └─ System package linked as ${systemLinkMode}: ${packageJson.name} (ws:name=${wsName})`);
+        // apiext уже определён в PackageInfo в зависимости от режима
+        return {
+            info: pkg,
+            outputPath: fullTargetPath,
+            apiext,
+            generatedFiles: [] // System пакеты ничего не генерируют
+        };
+    }
+};

package/build/core/linking/parsers.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * Парсеры информации о пакетах для линковки
+ *
+ * Содержит функции для парсинга PackageInfo из:
+ * - DependencyNode (для compiler dependencies / polyfill)
+ * - BtConfigLinkingPackage (для пользовательских пакетов)
+ *
+ * @module linking/parsers
+ */
+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.parseCompilerDependencyPackageInfo = parseCompilerDependencyPackageInfo;
+exports.parseUserPackageInfo = parseUserPackageInfo;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_js_1 = require("../logger.js");
+const index_js_1 = require("./utils/index.js");
+/**
+ * Парсит PackageInfo из DependencyNode (для compiler dependencies)
+ *
+ * @remarks
+ * System пакеты линкуются в зависимости от режима:
+ * - component (по умолчанию): копируются в components/<ws:name>, НЕ добавляются в api_ext.xml
+ * - standalone: копируются по ws:root, добавляются в api_ext.xml
+ */
+function parseCompilerDependencyPackageInfo(dep, ctx) {
+    const packageJson = dep.packageJson;
+    const packageType = (0, index_js_1.normalizePackageType)(packageJson['ws:package']);
+    const wsRoot = packageJson['ws:root'];
+    const wsName = packageJson['ws:name'];
+    const { systemLinkMode } = ctx;
+    if (!packageType) {
+        logger_js_1.logger.warning(`Package ${packageJson.name} does not have ws:package field, skipping`);
+        return null;
+    }
+    if (packageType === 'library') {
+        // Library пакеты обрабатываются через node_modules
+        return null;
+    }
+    // ws:name обязательно для всех пакетов кроме library
+    if (!wsName || typeof wsName !== 'string') {
+        logger_js_1.logger.error(`Package ${packageJson.name}: ws:name field is required for ${packageType} packages`);
+        process.exit(1);
+    }
+    // Для system пакетов определяем targetPath и apiext в зависимости от режима
+    let targetPath;
+    let rootUrl;
+    let apiext;
+    if (packageType === 'system') {
+        if (systemLinkMode === 'standalone') {
+            // Standalone режим: копируем по ws:root, добавляем в api_ext.xml
+            // ws:root обязателен для standalone режима
+            if (typeof wsRoot !== 'string' || wsRoot === '') {
+                logger_js_1.logger.error(`Invalid ws:root field in ${dep.projectPath}/package.json. Required for standalone mode.`);
+                process.exit(1);
+            }
+            targetPath = wsRoot;
+            rootUrl = 'x-local://' + path.posix.normalize(wsRoot);
+            // Формируем apiext
+            const wsApiext = packageJson['ws:apiext'];
+            if (wsApiext) {
+                apiext = {
+                    name: wsApiext.name,
+                    libs: wsApiext.libs.map((lib) => rootUrl + '/' + path.posix.normalize(lib))
+                };
+            }
+            else if (packageJson.main) {
+                apiext = {
+                    name: `module:${wsName}`,
+                    libs: [rootUrl + '/init.xml']
+                };
+            }
+        }
+        else {
+            // Component режим (по умолчанию): копируем в components/<ws:name>, НЕ добавляем в api_ext.xml
+            targetPath = `./components/${wsName}`;
+            rootUrl = 'x-local://components/' + wsName;
+            apiext = undefined; // Компоненты не регистрируются в api_ext.xml
+        }
+    }
+    else {
+        // Для standalone/component пакетов - вычисляем targetPath
+        if (packageType === 'component') {
+            targetPath = `./components/${wsName}`;
+        }
+        else if (typeof wsRoot === 'string' && wsRoot !== '') {
+            targetPath = wsRoot;
+        }
+        else {
+            // ws:root опционален для standalone, по умолчанию ./wt/<ws:name>
+            targetPath = `./wt/${wsName}`;
+        }
+        rootUrl = 'x-local://' + path.posix.normalize(targetPath);
+        const wsApiext = packageJson['ws:apiext'];
+        if (wsApiext) {
+            apiext = {
+                name: wsApiext.name,
+                libs: wsApiext.libs.map((lib) => rootUrl + '/' + path.posix.normalize(lib))
+            };
+        }
+        else if (packageJson.main && packageType !== 'component') {
+            // Компоненты не регистрируются в api_ext.xml
+            apiext = {
+                name: `module:${wsName}`,
+                libs: [rootUrl + '/init.xml']
+            };
+        }
+    }
+    return {
+        dependencyNode: dep,
+        packageJson,
+        packageType,
+        wsName,
+        projectPath: dep.projectPath,
+        sourceDir: path.join(dep.projectPath, 'build'),
+        targetPath,
+        rootUrl,
+        apiext,
+        needsInitGeneration: false // System пакеты ничего не генерируют
+    };
+}
+/**
+ * Парсит PackageInfo из пользовательской конфигурации
+ *
+ * @remarks
+ * Для не-BT пакетов (без ws:package) выполняет копирование и возвращает null.
+ * Для BT пакетов формирует полную информацию включая targetPath и apiext.
+ */
+function parseUserPackageInfo(projectPath, packageDirAbsolute, packageConfig, displayName) {
+    // Проверяем существование директории пакета
+    if (!fs.existsSync(packageDirAbsolute)) {
+        logger_js_1.logger.error(`❌ Package directory not found: ${packageDirAbsolute}`);
+        process.exit(1);
+    }
+    // Проверяем наличие package.json и определяем тип пакета
+    const packageJsonPath = path.join(packageDirAbsolute, 'package.json');
+    let packageJson = null;
+    let packageType = null;
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            packageType = (0, index_js_1.normalizePackageType)(packageJson['ws:package']);
+            if (packageType === 'library') {
+                logger_js_1.logger.error(`❌ Package ${displayName}: libraries (ws:package: "library") cannot be linked directly. They are included via node_modules of executable packages.`);
+                process.exit(1);
+            }
+            else if (packageJson['ws:package'] && !packageType) {
+                logger_js_1.logger.error(`❌ Package ${displayName}: invalid ws:package type "${packageJson['ws:package']}". Valid types: ${(0, index_js_1.formatValidPackageTypes)()}`);
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Failed to parse package.json in ${packageDirAbsolute}: ${error}`);
+            process.exit(1);
+        }
+    }
+    const isBorisTypePackage = packageType && (0, index_js_1.isExecutablePackageType)(packageType);
+    // Проверяем ws:name для BT пакетов
+    let wsName;
+    if (isBorisTypePackage) {
+        wsName = packageJson['ws:name'];
+        if (!wsName || typeof wsName !== 'string') {
+            logger_js_1.logger.error(`❌ Package ${displayName}: ws:name field is required for ${packageType} packages`);
+            process.exit(1);
+        }
+    }
+    // Определяем source директорию
+    let sourceDir;
+    if (packageConfig.source) {
+        sourceDir = path.join(projectPath, packageConfig.source);
+    }
+    else if (isBorisTypePackage) {
+        sourceDir = path.join(packageDirAbsolute, 'build');
+    }
+    else {
+        logger_js_1.logger.error(`❌ Package ${displayName}: 'source' is required for non-BorisType packages`);
+        process.exit(1);
+    }
+    if (!fs.existsSync(sourceDir)) {
+        logger_js_1.logger.error(`❌ Source directory not found: ${sourceDir}`);
+        process.exit(1);
+    }
+    // Определяем target
+    let targetPath;
+    if (packageConfig.target) {
+        targetPath = packageConfig.target;
+    }
+    else if (isBorisTypePackage && packageJson) {
+        if (packageType === 'component') {
+            if (packageJson['ws:root']) {
+                logger_js_1.logger.error(`❌ Package ${displayName}: components cannot have 'ws:root' field. They are always placed in ./components/<ws:name>`);
+                process.exit(1);
+            }
+            targetPath = `./components/${wsName}`;
+        }
+        else if (packageJson['ws:root']) {
+            targetPath = packageJson['ws:root'];
+        }
+        else {
+            // ws:root опционален для standalone, по умолчанию ./wt/<ws:name>
+            targetPath = `./wt/${wsName}`;
+        }
+    }
+    else {
+        logger_js_1.logger.error(`❌ Package ${displayName}: 'target' is required for non-BorisType packages`);
+        process.exit(1);
+    }
+    if (!isBorisTypePackage) {
+        // Обычная директория - просто копируем
+        const distPath = path.join(projectPath, 'dist');
+        const fullTargetPath = path.join(distPath, targetPath);
+        (0, index_js_1.copyRecursive)(sourceDir, fullTargetPath);
+        const sourceInfo = packageConfig.source || '';
+        logger_js_1.logger.success(`✓ Copied ${displayName} (${sourceInfo}) to ${targetPath}`);
+        return null;
+    }
+    const rootUrl = 'x-local://' + path.posix.normalize(targetPath);
+    // Формируем apiext
+    let apiext;
+    const wsApiext = packageJson['ws:apiext'];
+    if (wsApiext) {
+        apiext = {
+            name: wsApiext.name,
+            libs: wsApiext.libs.map((lib) => rootUrl + '/' + path.posix.normalize(lib))
+        };
+    }
+    else if (packageJson.main && packageType !== 'component') {
+        // Компоненты не регистрируются в api_ext.xml
+        apiext = {
+            name: `module:${wsName}`,
+            libs: [rootUrl + '/init.xml']
+        };
+    }
+    return {
+        packageJson,
+        packageType: packageType,
+        wsName: wsName,
+        projectPath: packageDirAbsolute,
+        sourceDir,
+        targetPath,
+        rootUrl,
+        apiext,
+        needsInitGeneration: !!packageJson.main && !wsApiext
+    };
+}

package/build/core/linking/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Типы для модуля linking
+ * @module linking/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/core/linking/utils/copy.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Утилиты для копирования файлов и директорий
+ * @module linking/utils/copy
+ */
+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.copyRecursive = copyRecursive;
+exports.copyWithPrefix = copyWithPrefix;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Рекурсивно копирует файлы и папки
+ *
+ * @param source - Путь к исходному файлу или директории
+ * @param target - Путь к целевому файлу или директории
+ *
+ * @remarks
+ * - Следует по symlink (использует fs.statSync вместо fs.lstatSync)
+ * - Создаёт целевые директории автоматически
+ * - Копирует файлы и поддиректории рекурсивно
+ */
+function copyRecursive(source, target) {
+    // Используем fs.statSync чтобы следовать по symlink если это ссылка
+    const stats = fs.statSync(source);
+    if (stats.isDirectory()) {
+        fs.mkdirSync(target, { recursive: true });
+        const items = fs.readdirSync(source);
+        for (const itemName of items) {
+            const sourcePath = path.join(source, itemName);
+            const targetPath = path.join(target, itemName);
+            // Используем fs.statSync чтобы следовать по symlink
+            const itemStats = fs.statSync(sourcePath);
+            if (itemStats.isDirectory()) {
+                copyRecursive(sourcePath, targetPath);
+            }
+            else {
+                fs.copyFileSync(sourcePath, targetPath);
+            }
+        }
+    }
+    else {
+        // Если source это файл (или symlink на файл), просто копируем
+        fs.copyFileSync(source, target);
+    }
+}
+/**
+ * Копирует все содержимое папки в другую папку с добавлением префикса к относительным путям
+ *
+ * @param sourceDir - Исходная папка
+ * @param targetDir - Целевая папка
+ * @param pathPrefix - Префикс для относительных путей (например: './wt/test')
+ *
+ * @example
+ * ```ts
+ * // Копирует содержимое /src/build в /dist/wt/mypackage
+ * copyWithPrefix('/src/build', '/dist', './wt/mypackage');
+ * ```
+ */
+function copyWithPrefix(sourceDir, targetDir, pathPrefix) {
+    // Нормализуем пути
+    const normalizedSource = path.normalize(sourceDir);
+    const normalizedTarget = path.normalize(targetDir);
+    const normalizedPrefix = path.normalize(pathPrefix);
+    // Создаем целевую папку с учетом префикса
+    const targetWithPrefix = path.join(normalizedTarget, normalizedPrefix);
+    // Рекурсивно копируем содержимое
+    copyRecursive(normalizedSource, targetWithPrefix);
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Утилиты для linking модуля
+ * @module linking/utils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlAppenPath = exports.copyIfChanged = exports.writeIfChanged = exports.formatValidPackageTypes = exports.getLegacyPackageTypes = exports.getValidPackageTypes = exports.isExecutablePackageType = exports.normalizePackageType = exports.copyPackageContent = exports.processPackageDirectory = exports.copyNodeModulesWithCache = exports.copyNodeModules = exports.copyWithPrefix = exports.copyRecursive = void 0;
+var copy_1 = require("./copy");
+Object.defineProperty(exports, "copyRecursive", { enumerable: true, get: function () { return copy_1.copyRecursive; } });
+Object.defineProperty(exports, "copyWithPrefix", { enumerable: true, get: function () { return copy_1.copyWithPrefix; } });
+var node_modules_1 = require("./node-modules");
+Object.defineProperty(exports, "copyNodeModules", { enumerable: true, get: function () { return node_modules_1.copyNodeModules; } });
+Object.defineProperty(exports, "copyNodeModulesWithCache", { enumerable: true, get: function () { return node_modules_1.copyNodeModulesWithCache; } });
+Object.defineProperty(exports, "processPackageDirectory", { enumerable: true, get: function () { return node_modules_1.processPackageDirectory; } });
+Object.defineProperty(exports, "copyPackageContent", { enumerable: true, get: function () { return node_modules_1.copyPackageContent; } });
+var package_type_1 = require("./package-type");
+Object.defineProperty(exports, "normalizePackageType", { enumerable: true, get: function () { return package_type_1.normalizePackageType; } });
+Object.defineProperty(exports, "isExecutablePackageType", { enumerable: true, get: function () { return package_type_1.isExecutablePackageType; } });
+Object.defineProperty(exports, "getValidPackageTypes", { enumerable: true, get: function () { return package_type_1.getValidPackageTypes; } });
+Object.defineProperty(exports, "getLegacyPackageTypes", { enumerable: true, get: function () { return package_type_1.getLegacyPackageTypes; } });
+Object.defineProperty(exports, "formatValidPackageTypes", { enumerable: true, get: function () { return package_type_1.formatValidPackageTypes; } });
+var write_1 = require("./write");
+Object.defineProperty(exports, "writeIfChanged", { enumerable: true, get: function () { return write_1.writeIfChanged; } });
+Object.defineProperty(exports, "copyIfChanged", { enumerable: true, get: function () { return write_1.copyIfChanged; } });
+var url_1 = require("./url");
+Object.defineProperty(exports, "UrlAppenPath", { enumerable: true, get: function () { return url_1.UrlAppenPath; } });