@boristype/bt-cli 0.1.0-alpha.0

package/build/core/config.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Конфигурация проекта — tsconfig.json и btconfig.json
+ *
+ * Единый модуль для чтения, парсинга и генерации конфигурационных файлов.
+ * Также содержит типы для btconfig.json.
+ *
+ * @module core/config
+ */
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTSConfig = getTSConfig;
+exports.generateDefaultTSConfig = generateDefaultTSConfig;
+exports.getBTConfig = getBTConfig;
+const typescript_1 = __importDefault(require("typescript"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const logger_js_1 = require("./utils/logger.js");
+// ─── tsconfig.json ──────────────────────────────────────────────
+/**
+ * Читает и парсит tsconfig.json.
+ *
+ * @param cwd - Рабочая директория для поиска tsconfig
+ * @param project - Имя файла конфигурации (по умолчанию tsconfig.json)
+ * @returns Распарсенная конфигурация TypeScript
+ */
+function getTSConfig(cwd, project = 'tsconfig.json') {
+    const tsconfigPath = typescript_1.default.findConfigFile(cwd, typescript_1.default.sys.fileExists, project);
+    if (!tsconfigPath) {
+        logger_js_1.logger.error(`There is no any configuration files at "${cwd}". Execute npx tsc -init to create a new one.`);
+        process.exit(1);
+    }
+    const { config, error } = typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile);
+    if (error) {
+        logger_js_1.logger.error(error.messageText.toString());
+        process.exit(1);
+    }
+    // Используем директорию tsconfig.json как базу для резолва путей
+    const configDir = path.dirname(tsconfigPath);
+    const configFileContent = typescript_1.default.parseJsonConfigFileContent(config, typescript_1.default.sys, configDir);
+    if (configFileContent.errors.length > 0) {
+        configFileContent.errors.forEach(diagnostic => {
+            logger_js_1.logger.error(diagnostic.messageText.toString());
+        });
+        process.exit(1);
+    }
+    return configFileContent;
+}
+/**
+ * Генерирует tsconfig.json с дефолтными настройками для BorisType проекта.
+ *
+ * @param cwd - Рабочая директория (по умолчанию process.cwd())
+ * @returns true если файл создан, false если уже существует
+ */
+function generateDefaultTSConfig(cwd = process.cwd()) {
+    const tsconfigContent = `{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "Bundler",
+    "rootDir": "./src/",
+    "outDir": "./build/",
+    "strict": true,
+    "noImplicitAny": true,
+    "allowJs": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noLib": true,
+    "typeRoots": [
+      "node_modules/@boristype/types/lib",
+      "node_modules/@boristype/types/lib/xml"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}
+`;
+    const tsconfigPath = path.join(cwd, 'tsconfig.json');
+    if (fs.existsSync(tsconfigPath)) {
+        logger_js_1.logger.warning('⚠️  tsconfig.json already exists. Skipping generation.');
+        return false;
+    }
+    try {
+        fs.writeFileSync(tsconfigPath, tsconfigContent, 'utf8');
+        logger_js_1.logger.success('Created a new tsconfig.json');
+        return true;
+    }
+    catch (error) {
+        logger_js_1.logger.error('❌ Failed to create tsconfig.json');
+        throw error;
+    }
+}
+// ─── btconfig.json ──────────────────────────────────────────────
+/**
+ * Читает и парсит btconfig.json.
+ *
+ * @param cwd - Рабочая директория
+ * @param project - Имя файла конфигурации (по умолчанию btconfig.json)
+ * @returns Объект конфигурации BtConfig или undefined если файл не найден
+ */
+function getBTConfig(cwd, project = 'btconfig.json') {
+    const btconfigPath = path.join(cwd, project);
+    if (!fs.existsSync(btconfigPath)) {
+        return undefined;
+    }
+    try {
+        const configContent = fs.readFileSync(btconfigPath, 'utf-8');
+        const config = JSON.parse(configContent);
+        return config;
+    }
+    catch (error) {
+        logger_js_1.logger.error(`Error reading or parsing ${project}: ${error}`);
+        process.exit(1);
+    }
+}

package/build/core/dependencies.js

@@ -0,0 +1,223 @@
+"use strict";
+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 fs_1 = require("fs");
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+// Класс для узла дерева зависимостей
+class DependencyNode {
+    packageJson;
+    constructor(packageJson, projectPath = '') {
+        this.packageJson = packageJson;
+        this.name = packageJson.name;
+        this.version = packageJson.version;
+        this.dependencies = [];
+        this.projectPath = projectPath;
+        this.hash = (0, crypto_1.randomUUID)();
+    }
+    name;
+    version;
+    dependencies;
+    projectPath;
+    hash;
+}
+exports.DependencyNode = DependencyNode;
+async function getCompilerRequiredDependencies(projectPath) {
+    const rootPackageJsonPath = path.join(projectPath, 'package.json');
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    const rootPackageJson = JSON.parse(await fs_1.promises.readFile(rootPackageJsonPath, 'utf-8'));
+    const devDependencies = rootPackageJson.devDependencies || {};
+    const btcRemoteDependency = devDependencies['@boristype/btc'] !== undefined;
+    const btcLocalDependency = devDependencies['btc'] !== undefined;
+    if (!btcLocalDependency && !btcRemoteDependency) {
+        console.warn(`Предупреждение: В devDependencies отсутствует зависимость 'btc'.`);
+        return [];
+    }
+    const btcPath = btcRemoteDependency ? path.join(nodeModulesPath, '@boristype', 'btc') : path.join(nodeModulesPath, 'btc');
+    const btcPackageJsonPath = path.join(btcPath, 'package.json');
+    const btcPackageJson = JSON.parse(await fs_1.promises.readFile(btcPackageJsonPath, 'utf-8'));
+    const btcDependencies = btcPackageJson.dependencies || {};
+    const result = [];
+    console.log(`Загрузка зависимостей компилятора из ${btcPath}`);
+    for (const [depName, depVersion] of Object.entries(btcDependencies)) {
+        if (depName.startsWith('@boristype/')) {
+            // Если btc установлен из репозитория, ищем в node_modules проекта
+            // Если btc установлен локально (file:...), ищем в node_modules внутри btc
+            const btcNodeModulesPath = btcRemoteDependency ? nodeModulesPath : path.join(btcPath, 'node_modules');
+            const depPath = btcRemoteDependency ? path.join(btcNodeModulesPath, '@boristype', depName.replace('@boristype/', '')) : path.join(btcNodeModulesPath, depName);
+            console.log(`Загрузка зависимости компилятора: ${depName} из ${depPath}`);
+            try {
+                const depPackageJsonPath = path.join(depPath, 'package.json');
+                const depPackageJson = JSON.parse(await fs_1.promises.readFile(depPackageJsonPath, 'utf-8'));
+                const depNode = new DependencyNode(depPackageJson, depPath);
+                result.push(depNode);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    console.warn(`Не удалось обработать зависимость ${depName}: ${err.message}`);
+                }
+                else {
+                    console.warn(`Не удалось обработать зависимость ${depName}: ${String(err)}`);
+                }
+            }
+        }
+    }
+    return result;
+}
+async function buildDependencyTree(projectPath) {
+    const rootPackageJsonPath = path.join(projectPath, 'package.json');
+    const nodeModulesPath = path.join(projectPath, 'node_modules');
+    const rootPackageJson = JSON.parse(await 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 fs_1.promises.readFile(packageJsonPath, 'utf-8'));
+            dependencies = packageJson.dependencies || {};
+        }
+        catch (err) {
+            console.warn(`Не удалось прочитать package.json для ${parentNode.name}: ${packageJsonPath}`);
+            return;
+        }
+        for (const [depName, depVersion] of Object.entries(dependencies)) {
+            const depKey = `${depName}@${depVersion}`;
+            if (visited.has(depKey)) {
+                console.warn(`Обнаружена циклическая зависимость: ${depKey}`);
+                continue;
+            }
+            const depPath = path.join(nodeModulesDir, depName);
+            try {
+                const depPackageJsonPath = path.join(depPath, 'package.json');
+                const depPackageJson = JSON.parse(await 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) {
+                if (err instanceof Error) {
+                    console.warn(`Не удалось обработать зависимость ${depName}: ${err.message}`);
+                }
+                else {
+                    console.warn(`Не удалось обработать зависимость ${depName}: ${String(err)}`);
+                }
+            }
+        }
+    }
+    await processDependencies(rootNode, nodeModulesPath, rootPackageJsonPath);
+    return rootNode;
+}
+// Альтернативная версия с итеративным подходом (более безопасная для больших деревьев)
+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)) {
+            console.warn(`Обнаружена циклическая зависимость: ${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) {
+    console.log('\n📦 Дерево зависимостей:');
+    function printInternal(node, depth) {
+        console.log('='.repeat(50));
+        console.log(`${' '.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) {
+    console.log('\n📦 Плоский список зависимостей (в порядке загрузки):');
+    console.log('='.repeat(50));
+    flatTree.forEach((node, index) => {
+        console.log(`${(index + 1).toString().padStart(2)}. ${node.name}@${node.version}  [${node.hash}]`);
+    });
+}
+function extractBorisTypeDependencies(flatTree) {
+    return flatTree.filter(node => {
+        const wsPackage = node.packageJson['ws:package']; // для libs
+        return typeof wsPackage === 'string';
+    });
+}

package/build/core/linking/cache.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Кэширование для линковки
+ *
+ * Управляет кэшем в директории .btc/ для оптимизации линковки:
+ * - Кэширование hash от package-lock.json для node_modules
+ * - Позволяет пропускать копирование если зависимости не изменились
+ *
+ * @module linking/cache
+ */
+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.LinkingCache = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+/** Текущая версия формата кэша */
+const CACHE_VERSION = 1;
+/** Имя директории кэша */
+const CACHE_DIR_NAME = '.btc';
+/** Имя файла состояния кэша */
+const CACHE_STATE_FILE = 'linking-cache.json';
+/**
+ * Менеджер кэша линковки
+ *
+ * @remarks
+ * Хранит состояние кэша в `.btc/linking-cache.json`
+ * Позволяет проверять нужно ли перекопировать node_modules
+ */
+class LinkingCache {
+    projectPath;
+    cachePath;
+    stateFilePath;
+    state;
+    enabled;
+    /**
+     * Создаёт экземпляр менеджера кэша
+     *
+     * @param projectPath - Корневая директория проекта
+     * @param enabled - Включён ли кэш (false при --no-cache)
+     */
+    constructor(projectPath, enabled = true) {
+        this.projectPath = projectPath;
+        this.cachePath = path.join(projectPath, CACHE_DIR_NAME);
+        this.stateFilePath = path.join(this.cachePath, CACHE_STATE_FILE);
+        this.enabled = enabled;
+        this.state = this.loadState();
+    }
+    /**
+     * Загружает состояние кэша из файла
+     */
+    loadState() {
+        if (!this.enabled) {
+            return this.createEmptyState();
+        }
+        try {
+            if (fs.existsSync(this.stateFilePath)) {
+                const content = fs.readFileSync(this.stateFilePath, 'utf-8');
+                const state = JSON.parse(content);
+                // Проверяем версию кэша
+                if (state.version !== CACHE_VERSION) {
+                    // Версия устарела - сбрасываем кэш
+                    return this.createEmptyState();
+                }
+                return state;
+            }
+        }
+        catch (error) {
+            // Ошибка чтения - начинаем с чистого состояния
+        }
+        return this.createEmptyState();
+    }
+    /**
+     * Создаёт пустое состояние кэша
+     */
+    createEmptyState() {
+        return {
+            version: CACHE_VERSION,
+            nodeModules: {}
+        };
+    }
+    /**
+     * Сохраняет состояние кэша в файл
+     */
+    saveState() {
+        if (!this.enabled) {
+            return;
+        }
+        try {
+            // Создаём директорию .btc если её нет
+            if (!fs.existsSync(this.cachePath)) {
+                fs.mkdirSync(this.cachePath, { recursive: true });
+            }
+            fs.writeFileSync(this.stateFilePath, JSON.stringify(this.state, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Не критично если не удалось сохранить кэш
+            console.warn('Warning: Failed to save linking cache:', error);
+        }
+    }
+    /**
+     * Вычисляет hash от содержимого файла
+     *
+     * @param filePath - Путь к файлу
+     * @returns SHA256 hash или null если файл не существует
+     */
+    computeFileHash(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            const content = fs.readFileSync(filePath);
+            return crypto.createHash('sha256').update(content).digest('hex');
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Получает hash от lockfile пакета
+     * Пробует package-lock.json, затем pnpm-lock.yaml, затем package.json как fallback
+     *
+     * @param packagePath - Путь к директории пакета
+     * @returns Hash от lockfile
+     */
+    getLockfileHash(packagePath) {
+        // Сначала пробуем package-lock.json (npm)
+        const npmLockPath = path.join(packagePath, 'package-lock.json');
+        let hash = this.computeFileHash(npmLockPath);
+        if (hash) {
+            return hash;
+        }
+        // Затем пробуем pnpm-lock.yaml (pnpm workspaces)
+        const pnpmLockPath = path.join(packagePath, 'pnpm-lock.yaml');
+        hash = this.computeFileHash(pnpmLockPath);
+        if (hash) {
+            return hash;
+        }
+        // Fallback на package.json
+        const packageJsonPath = path.join(packagePath, 'package.json');
+        return this.computeFileHash(packageJsonPath);
+    }
+    /**
+     * Проверяет нужно ли копировать node_modules для пакета
+     *
+     * @param wsName - ws:name пакета
+     * @param packagePath - Путь к директории пакета (где находится package-lock.json)
+     * @returns true если нужно копировать, false если можно пропустить
+     *
+     * @remarks
+     * Возвращает true (нужно копировать) если:
+     * - Кэш отключён (--no-cache)
+     * - Нет записи в кэше для этого пакета
+     * - Hash от package-lock.json изменился
+     * - Не удалось вычислить hash
+     */
+    shouldCopyNodeModules(wsName, packagePath) {
+        if (!this.enabled) {
+            return true;
+        }
+        const currentHash = this.getLockfileHash(packagePath);
+        if (!currentHash) {
+            // Не удалось получить hash - копируем на всякий случай
+            return true;
+        }
+        const cached = this.state.nodeModules[wsName];
+        if (!cached) {
+            // Нет записи в кэше
+            return true;
+        }
+        // Сравниваем hash
+        return cached.lockfileHash !== currentHash;
+    }
+    /**
+     * Обновляет запись кэша после копирования node_modules
+     *
+     * @param wsName - ws:name пакета
+     * @param packagePath - Путь к директории пакета
+     */
+    updateNodeModulesCache(wsName, packagePath) {
+        if (!this.enabled) {
+            return;
+        }
+        const hash = this.getLockfileHash(packagePath);
+        if (!hash) {
+            // Удаляем запись если не можем вычислить hash
+            delete this.state.nodeModules[wsName];
+        }
+        else {
+            this.state.nodeModules[wsName] = {
+                lockfileHash: hash,
+                linkedAt: new Date().toISOString(),
+                version: CACHE_VERSION
+            };
+        }
+        this.saveState();
+    }
+    /**
+     * Очищает весь кэш
+     */
+    clear() {
+        this.state = this.createEmptyState();
+        try {
+            if (fs.existsSync(this.stateFilePath)) {
+                fs.unlinkSync(this.stateFilePath);
+            }
+        }
+        catch (error) {
+            // Не критично
+        }
+    }
+    /**
+     * Полностью удаляет директорию .btc
+     */
+    static removeAll(projectPath) {
+        const cachePath = path.join(projectPath, CACHE_DIR_NAME);
+        if (fs.existsSync(cachePath)) {
+            fs.rmSync(cachePath, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Проверяет включён ли кэш
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+}
+exports.LinkingCache = LinkingCache;