@mirta/rollup 0.3.5 → 0.4.1

package/dist/package.mjs

@@ -0,0 +1,1030 @@
+import ts$1 from '@rollup/plugin-typescript';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import replace from '@rollup/plugin-replace';
+import copy from 'rollup-plugin-copy';
+import dts from 'rollup-plugin-dts';
+import { A as AstTransformError, d as del, N as NpmBuildError } from './errors.mjs';
+import ts from 'typescript';
+import nodePath, { basename, dirname } from 'node:path';
+import { readPackage, toPosix } from '@mirta/package';
+import { ensureCompactArray } from '@mirta/basics/array';
+
+/**
+ * Удаляет расширение файла `.ts`, `.d.ts` или `.js`.
+ *
+ * @param fileName - Полное имя файла
+ * @returns Имя файла без расширения
+ *
+ * @since 0.3.5
+ *
+ **/
+const removeFileExtension = (fileName) => fileName.replace(/\.(?:d\.)?(?:[cm]?[tj]s)$/i, '');
+/**
+ * Находит общий префикс двух путей.
+ *
+ * @param a - Первый путь
+ * @param b - Второй путь
+ * @returns Общий префикс
+ *
+ * @since 0.3.5
+ *
+ **/
+function getCommonPrefix(a, b) {
+    const aParts = nodePath.normalize(a).split(nodePath.sep);
+    const bParts = nodePath.normalize(b).split(nodePath.sep);
+    const minLength = Math.min(aParts.length, bParts.length);
+    let i = 0;
+    while (i < minLength && aParts[i] === bParts[i]) {
+        i++;
+    }
+    return aParts.slice(0, i).join(nodePath.sep);
+}
+/**
+ * Проверяет, является ли указанный файл частью проекта.
+ *
+ * Файл считается проектным, если он:
+ * - Не находится в директории `node_modules`;
+ * - Расположен внутри указанной корневой директории.
+ *
+ * @param fileName - Полный путь к проверяемому файлу.
+ * @param rootDir - Корневая директория проекта.
+ * @returns `true`, если файл принадлежит проекту, иначе false.
+ *
+ * @since 0.3.5
+ *
+ **/
+function isProjectFile(fileName, rootDir) {
+    if (fileName.includes('node_modules'))
+        return false;
+    if (nodePath.relative(rootDir, fileName).startsWith('..'))
+        return false;
+    return true;
+}
+/**
+ * Вычисляет относительный путь от директории исходного файла к целевому файлу,
+ * добавляет имя выходного файла и нормализует путь для совместимости с POSIX-системами.
+ *
+ * @param sourceFilePath - Полный путь к исходному файлу.
+ * @param targetFilePath - Полный путь к целевому файлу.
+ * @param outputName - Имя выходного файла, который будет добавлен к относительному пути.
+ * @returns Нормализованный относительный путь с именем выходного файла.
+ *
+ * @example
+ *
+ * ```ts
+ * const sourceFilePath = '/project/src/index.ts'
+ * const targetFilePath = '/project/src/utils/index.ts'
+ * const outputName = 'utils.d.ts'
+ *
+ * getRelativeOutputPath(sourceFilePath, targetFilePath, outputName) // Возвращает './utils.d.ts'
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function getRelativeOutputPath(sourceFilePath, targetFilePath, outputFileName) {
+    // Шаг 1: Получаем директорию исходного файла.
+    const sourceDir = nodePath
+        .dirname(sourceFilePath);
+    // Шаг 2: Вычисляем относительный путь от директории исходного файла до целевого файла.
+    const relativeDir = nodePath
+        .dirname(nodePath.relative(sourceDir, targetFilePath));
+    // Шаг 3: Объединяем относительную директорию с именем выходного файла.
+    let relativePath = nodePath
+        .join(relativeDir, outputFileName);
+    relativePath = relativePath
+        .split(nodePath.sep)
+        .join(nodePath.posix.sep);
+    // Шаг 4: Гарантируем, что путь является относительным.
+    if (!relativePath.startsWith('.'))
+        relativePath = `./${relativePath}`;
+    return relativePath;
+}
+/**
+ * Определяет корневую директорию файла на основе конфигурации.
+ *
+ * @param context - Базовый контекст
+ * @param sourceFile - Обрабатываемый файл
+ * @returns Путь к корню проекта
+ * @throws Ошибка, если файлы не найдены
+ *
+ * @since 0.3.5
+ *
+ **/
+function getRootDir(context, sourceFile) {
+    const { compilerOptions, program } = context;
+    // Если rootDirs указаны — ищем, к какому корню относится файл.
+    if (compilerOptions.rootDirs?.length) {
+        const sortedRoots = [...compilerOptions.rootDirs]
+            .sort((a, b) => b.length - a.length);
+        const normalizedFile = nodePath.resolve(sourceFile.fileName);
+        for (const rootDir of sortedRoots) {
+            const normalizedRoot = nodePath.resolve(rootDir);
+            if (normalizedFile.startsWith(normalizedRoot + nodePath.sep))
+                return rootDir;
+        }
+    }
+    // Если rootDir указан — используем его.
+    if (compilerOptions.rootDir)
+        return compilerOptions.rootDir;
+    // Иначе находим общий корень для всех файлов.
+    const fileNames = program.getRootFileNames();
+    if (!fileNames.length)
+        throw AstTransformError.get('noRootFiles');
+    let commonPrefix = nodePath.dirname(fileNames[0]);
+    for (const fileName of fileNames.slice(1)) {
+        commonPrefix = getCommonPrefix(commonPrefix, fileName);
+    }
+    return commonPrefix;
+}
+
+/**
+ * Перечисление типов индексных файлов.
+ * Используется для классификации модулей в зависимости от их отношения к файлам `index`.
+ *
+ * @since 0.3.5
+ *
+ **/
+var IndexType;
+(function (IndexType) {
+    /** Не индексный файл. */
+    IndexType["NonIndex"] = "non-index";
+    /** Явный индекс (например, `import './index'`). */
+    IndexType["Explicit"] = "explicit";
+    /** Неявный индекс (например, `import './dir'`). */
+    IndexType["Implicit"] = "implicit";
+    /** Индекс внутри пакета (например, import 'package/index'). */
+    IndexType["ImplicitPackage"] = "implicit-package";
+})(IndexType || (IndexType = {}));
+
+/**
+ * Проверяет безопасность пути модуля, блокируя подозрительные символы.
+ *
+ * Эта функция проверяет, не содержит ли путь модуля недопустимых символов,
+ * таких как `:` (используется в URL) или `~` (ссылка на домашнюю директорию),
+ * которые могут представлять риск безопасности.
+ *
+ * @param path - Путь модуля для проверки.
+ *
+ * @throws {AstTransformError} Если обнаружены запрещённые символы.
+ *
+ * @example
+ * ```ts
+ * assertPathIsValid('./utils') // OK
+ * assertPathIsValid('http://malicious.com') // Выбросит ошибку
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function assertPathIsValid(path) {
+    if (path.includes(':') || path.includes('~'))
+        throw AstTransformError.get('invalidChars', path);
+}
+
+/**
+ * Создает кэш файлов по имени без расширения.
+ *
+ * @param program - Программа TypeScript
+ * @returns Карта: ключ - имя файла без расширения, значение - объект файла
+ *
+ * @since 0.3.5
+ *
+ **/
+function createSourceFilesCache(program) {
+    return new Map(program.getSourceFiles().map(sourceFile => [
+        removeFileExtension(sourceFile.fileName),
+        sourceFile,
+    ]));
+}
+/**
+ * Получает файл из программы или создает его при необходимости.
+ * Использует кэш для повышения производительности при повторных запросах.
+ *
+ * @param context - Контекст трансформера, содержащий ссылку на программу и кэш файлов.
+ * @param fileName - Полный путь к файлу, который необходимо найти или создать.
+ * @returns Экземпляр {@link ts.SourceFile} для существующего или созданного файла.
+ *
+ * @since 0.3.5
+ *
+ **/
+function resolveSourceFile(context, fileName) {
+    const { program, compilerOptions } = context;
+    let result = program.getSourceFile(fileName);
+    if (result)
+        return result;
+    // Если кэш уже создан, используем его. Иначе создаем новый.
+    const sourceFilesCache = context.sourceFilesCache ??= createSourceFilesCache(program);
+    const normalizedFileName = removeFileExtension(fileName);
+    // Попытка найти файл в кэше.
+    result = sourceFilesCache.get(normalizedFileName);
+    if (!result) {
+        result = ts.createSourceFile(fileName, '', compilerOptions.target ?? ts.ScriptTarget.ESNext, false);
+        sourceFilesCache.set(normalizedFileName, result);
+    }
+    return result;
+}
+
+/**
+ * Анализирует путь модуля и определяет его тип (явный, неявный, пакетный или обычный).
+ * Собирает метаданные о модуле для дальнейшей обработки путей импорта.
+ *
+ * @param path - Путь модуля из исходного кода (например, './dir' или 'package/index').
+ * @param resolvedModule - Объект, содержащий информацию о разрешённом модуле из TypeScript.
+ * @returns Объект с детализацией пути, включая тип индекса, имя файла, расширение и директорию.
+ *
+ * @since 0.3.5
+ *
+ **/
+function getPathDetails(path, resolvedModule) {
+    const { resolvedFileName, packageId } = resolvedModule;
+    const implicitPackagePath = packageId?.subModuleName;
+    // Указывает, является ли модуль частью пакета (например, 'package/index').
+    const isPackage = !!implicitPackagePath;
+    // Базовые данные разрешённого файла
+    const resolvedBaseName = nodePath.basename(isPackage
+        ? implicitPackagePath
+        : resolvedFileName);
+    const resolvedBaseNameNoExtension = resolvedBaseName
+        ? removeFileExtension(resolvedBaseName)
+        : undefined;
+    // const resolvedExtension = resolvedBaseName
+    //   ? nodePath.extname(resolvedFileName)
+    //   : undefined
+    // Базовые данные оригинального модуля
+    let baseName = isPackage
+        ? undefined
+        : nodePath.basename(path);
+    let baseNameNoExtension = baseName
+        ? removeFileExtension(baseName)
+        : undefined;
+    let extName = baseName
+        ? nodePath.extname(path)
+        : undefined;
+    // Если имя оригинального модуля совпадает с разрешённым, убираем расширение.
+    if (resolvedBaseNameNoExtension
+        && baseName
+        && resolvedBaseNameNoExtension === baseName) {
+        baseNameNoExtension = baseName;
+        extName = undefined;
+    }
+    let indexType;
+    if (isPackage) {
+        // Модуль внутри пакета (например, import 'package/index').
+        indexType = IndexType.ImplicitPackage;
+    }
+    else if (baseNameNoExtension === 'index' && resolvedBaseNameNoExtension === 'index') {
+        // Явный импорт файла index (например, import './dir/index').
+        indexType = IndexType.Explicit;
+    }
+    else if (baseNameNoExtension !== 'index' && resolvedBaseNameNoExtension === 'index') {
+        // Неявный импорт index (например, import './dir').
+        indexType = IndexType.Implicit;
+    }
+    else {
+        // Обычный файл, не связанный с index.
+        indexType = IndexType.NonIndex;
+    }
+    // Для неявных индексов убирает лишние поля оригинального
+    // модуля, чтобы не отображать index и расширения.
+    //
+    if (indexType === IndexType.Implicit) {
+        baseName = undefined;
+        baseNameNoExtension = undefined;
+        extName = undefined;
+    }
+    return {
+        // baseName,
+        // baseNameNoExtension,
+        extName,
+        // resolvedBaseName,
+        resolvedBaseNameNoExtension,
+        // resolvedExtension,
+        // resolvedDir: isPackage
+        //  ? removeSuffix(resolvedFileName, `/${implicitPackageIndex}`)
+        //  : nodePath.dirname(resolvedFileName),
+        indexType,
+        // implicitPackagePath,
+        // resolvedFileName,
+    };
+}
+/**
+ * Генерирует новый относительный путь для импорта модуля, исключая расширения и индексные файлы.
+ * Проверяет безопасность пути и убеждается, что файл находится внутри корня проекта.
+ *
+ * @param context - Контекст трансформера, содержащий информацию о текущем файле и конфигурации.
+ * @param oldPath - Путь модуля из исходного импорта (например, './utils/index').
+ * @returns Относительный путь без расширения и индекса, или `undefined`, если модуль недопустим.
+ *
+ * @since 0.3.5
+ *
+ **/
+function resolveNewModulePath(context, oldPath) {
+    assertPathIsValid(oldPath);
+    const { 
+    // Текущий обрабатываемый файл.
+    sourceFile: currentSourceFile, 
+    // Актуальная конфигурация TypeScript.
+    compilerOptions, } = context;
+    // Получаем модуль импортированного файла.
+    //
+    const { resolvedModule: importedModule } = ts.resolveModuleName(oldPath, currentSourceFile.fileName, compilerOptions, ts.sys);
+    if (!importedModule)
+        throw AstTransformError.get('moduleNotFound', oldPath, currentSourceFile.fileName);
+    if (!isProjectFile(importedModule.resolvedFileName, context.rootDir))
+        return null;
+    // Получает детали пути импортированного модуля.
+    const pathDetails = getPathDetails(oldPath, importedModule);
+    const { indexType, resolvedBaseNameNoExtension, extName } = pathDetails;
+    let outputBaseName = resolvedBaseNameNoExtension ?? '';
+    if (indexType === IndexType.Implicit && outputBaseName.endsWith('index'))
+        outputBaseName = outputBaseName.slice(0, -5);
+    if (outputBaseName && extName)
+        outputBaseName = `${outputBaseName}${extName}`;
+    // Получает исходный файл импортированного модуля.
+    const importedSourceFile = resolveSourceFile(context, importedModule.resolvedFileName);
+    const newPath = getRelativeOutputPath(currentSourceFile.fileName, importedSourceFile.fileName, outputBaseName);
+    return newPath;
+}
+
+const aliasPattern = /^[@#]/;
+/**
+ * Обновляет спецификатор модуля в узле импорта или экспорта.
+ *
+ * @param factory - Фабрика для создания новых узлов AST.
+ * @param node - Узел импорта или экспорта.
+ * @param newModuleSpecifier - Новый относительный путь.
+ * @returns Обновлённый узел.
+ *
+ * @since 0.3.5
+ *
+ **/
+function updateModuleSpecifier(factory, node, newModuleSpecifier) {
+    if (ts.isImportDeclaration(node)) {
+        return factory.updateImportDeclaration(node, node.modifiers, node.importClause, factory.createStringLiteral(newModuleSpecifier), node.attributes);
+    }
+    else if (ts.isExportDeclaration(node)) {
+        return factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, node.exportClause, factory.createStringLiteral(newModuleSpecifier), node.attributes);
+    }
+    return node;
+}
+/**
+ * Рекурсивно обходит дочерние узлы AST с текущим визитором.
+ */
+function visitChildren(context, node) {
+    return ts.visitEachChild(node, context.getVisitor(), context.transformationContext);
+}
+/**
+ * Визитор для обработки узлов AST, связанных с импортами.
+ *
+ * Обновляет пути модулей, начинающиеся с `#` или `@`, в файлах объявлений TypeScript.
+ *
+ * @param this - Контекст трансформера, предоставляющий инструменты для работы с AST.
+ * @param node - Текущий узел AST, который проверяется и, при необходимости, обновляется.
+ * @returns Обновленный узел AST или результат рекурсивного обхода дочерних узлов.
+ *
+ * @example
+ * ```ts
+ * // Исходный узел импорта:
+ * import { foo } from '#utils/index'
+ *
+ * // После обработки:
+ * import { foo } from './utils'
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+function nodeVisitor(node) {
+    if (!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node))
+        return visitChildren(this, node);
+    const moduleSpecifier = node.moduleSpecifier;
+    if (!moduleSpecifier || !ts.isStringLiteral(moduleSpecifier))
+        return visitChildren(this, node);
+    // Извлекаем путь импорта/экспорта (указывается в кавычках после from).
+    const { text: oldPath } = moduleSpecifier;
+    // Проверяем, относится ли спецификатор к алиасу проекта (`#`) или кастомному алиасу (`@`).
+    // Такие спецификаторы требуют пересчета в относительный путь.
+    //
+    if (!aliasPattern.test(oldPath))
+        return visitChildren(this, node);
+    const cachedNewPath = this.pathsCache.get(oldPath);
+    const newPath = cachedNewPath === undefined
+        ? resolveNewModulePath(this, oldPath)
+        : cachedNewPath;
+    if (cachedNewPath === undefined)
+        this.pathsCache.set(oldPath, newPath);
+    if (!newPath)
+        return node;
+    // Обновляем узел импорта новым значением пути.
+    // Если путь не удалось преобразовать, возвращаем исходный узел.
+    //
+    return updateModuleSpecifier(this.factory, node, newPath);
+}
+
+/**
+ * Фабрика трансформеров для Rollup, предназначенная для обработки файлов объявлений TypeScript (`.d.ts`).
+ * Создаёт трансформер, который модифицирует пути импортов в декларациях, исключая расширения и индексные файлы.
+ *
+ * @param program - Экземпляр программы TypeScript, предоставляющий доступ к всем файлам проекта.
+ * @returns Фабрика трансформеров, применяющаяся ко всем `.d.ts`-файлам.
+ *
+ * @since 0.3.5
+ *
+ **/
+function dtsAliasTransformerFactory(program) {
+    return (context) => {
+        const compilerOptions = program.getCompilerOptions();
+        /**
+         * Базовый контекст для работы с AST-трансформером.
+         * Содержит общие параметры и ссылки на программу TypeScript.
+         *
+         **/
+        const visitorContextBase = {
+            compilerOptions,
+            program,
+            factory: context.factory,
+            transformationContext: context,
+        };
+        return (sourceFile) => {
+            /**
+             * Обработка происходит только для файлов объявлений (`.d.ts`).
+             * Обычные файлы (`*.ts`) игнорируются.
+             *
+             **/
+            if (!sourceFile.isDeclarationFile)
+                return sourceFile;
+            /**
+             * Контекст визитора, расширенный информацией о текущем файле и корне проекта.
+             * Используется для передачи данных в `nodeVisitor`.
+             *
+             **/
+            const visitorContext = {
+                ...visitorContextBase,
+                sourceFile,
+                rootDir: getRootDir(visitorContextBase, sourceFile),
+                pathsCache: new Map(),
+                getVisitor() {
+                    return nodeVisitor.bind(this);
+                },
+            };
+            /**
+             * Рекурсивный обход AST с применением визитора.
+             * Обрабатывает все узлы файла, начиная с корня.
+             *
+             **/
+            return ts.visitEachChild(sourceFile, visitorContext.getVisitor(), context);
+        };
+    };
+}
+
+/**
+ * Экспортируемый трансформер для Rollup, предназначенный для обработки файлов объявлений TypeScript (`.d.ts`).
+ * Используется в фазе `afterDeclarations`, чтобы корректировать пути импортов после генерации типов.
+ *
+ * @returns Объект трансформера, который может быть передан в конфигурацию Rollup.
+ *
+ * @example
+ * Пример использования в конфигурации Rollup:
+ * ```ts
+ * import { dtsAlias } from '#ast/dts-alias';
+ *
+ * export default {
+ *   plugins: [
+ *     typescript({
+ *       transformers: {
+ *         afterDeclarations: [
+ *           dtsAlias()
+ *         ]
+ *       }
+ *     })
+ *   ]
+ * }
+ *
+ * ```
+ * @since 0.3.5
+ *
+ **/
+const dtsAlias = () => ({
+    type: 'program',
+    factory: dtsAliasTransformerFactory,
+});
+
+/**
+ * Создаёт предикат для проверки, следует ли считать модуль внешним по набору правил.
+ *
+ * @param cwd - рабочая директория. Пути за её пределами считаются внешними.
+ * @param externals - список функций или паттернов (строки, RegExp или массивы таких значений), определяющих внешние модули
+ * @returns `true` если модуль считается внешним, `false` в противном случае
+ */
+function createExternalFilter(cwd, ...externals) {
+    /**
+     * Функция-предикат для определения внешнего модуля
+     *
+     * @param target Целевой путь/имя модуля
+     * @param importer Имя файла, который импортирует модуль (если доступно)
+     * @param isResolved Флаг, указывающий, был ли модуль успешно разрешён
+     * @returns `true`, если модуль внешний, иначе false
+     */
+    return (target, importer, isResolved) => {
+        for (const external of externals) {
+            // Шаг 1: Пользовательская функция
+            if (typeof external === 'function') {
+                if (external(target, importer, isResolved))
+                    return true;
+            }
+            else {
+                // Шаг 2: Массив паттернов
+                const isExternal = ensureCompactArray(external).some((item) => {
+                    if (item instanceof RegExp)
+                        return item.test(target);
+                    return item === target;
+                });
+                if (isExternal)
+                    return true;
+            }
+        }
+        // Шаг 3: Путь вне cwd (только для обнаруженных модулей)
+        if (isResolved && cwd && nodePath.isAbsolute(target)) {
+            const relativePath = nodePath.relative(cwd, target);
+            // Если путь вне cwd, отмечаем его как внешний
+            if (relativePath.startsWith('..') || nodePath.isAbsolute(relativePath)) {
+                return true;
+            }
+        }
+        // Шаг 4: По умолчанию — внутренний
+        return false;
+    };
+}
+
+/**
+ * @file Генерирует конфигурации Rollup на основе `package.json`.
+ *
+ * Главная функция — `definePackageConfig`. Она:
+ * - Читает `exports` и сопоставляет с `input`
+ * - Генерирует ESM-бандл и, при необходимости, `.d.ts`
+ * - Поддерживает запуск из корня монорепозитория (через `cwd`)
+ *
+ * Используется для сборки пакетов в монорепозитории.
+ *
+ * @since 0.3.0
+ *
+ **/
+const outDir = 'dist';
+const outDirDts = `${outDir}/dts`;
+/**
+ * Удаляет префикс каталога вывода (`./${outDir}/`) из пути.
+ * @param path Путь к файлу.
+ * @returns Нормализованный путь.
+ *
+ * @since 0.3.5
+ *
+ **/
+function sliceDistPrefix(path) {
+    const prefix = `./${outDir}/`;
+    return path.startsWith(prefix)
+        ? path.slice(prefix.length)
+        : path;
+}
+/**
+ * Нормализует входные данные в массив строк.
+ *
+ * @param input Входные данные (строка, массив или объект).
+ * @returns Массив путей к входным файлам.
+ * @throws {NpmBuildError} Если входная конфигурация пуста.
+ *
+ * @since 0.3.4
+ *
+ **/
+function normalizeInput(input) {
+    const inputs = [];
+    if (typeof input === 'string') {
+        inputs.push(input);
+    }
+    else if (Array.isArray(input)) {
+        inputs.push(...input);
+    }
+    else if (typeof input === 'object') {
+        inputs.push(...Object.values(input));
+    }
+    if (inputs.length === 0)
+        throw NpmBuildError.get('inputEmpty');
+    return inputs;
+}
+/**
+ * Проверяет, является ли объект условной записью экспорта.
+ *
+ * @param source Объект для проверки.
+ * @returns `true`, если объект содержит поле `import`.
+ *
+ * @since 0.3.5
+ *
+ **/
+function isConditionalEntry(source) {
+    return 'import' in source;
+}
+/**
+ * Обрабатывает условную запись экспорта.
+ *
+ * @param source Условная запись.
+ * @returns Объект с полями entry и types.
+ *
+ * @since 0.3.5
+ *
+ **/
+function processConditionalEntry(source) {
+    const result = {};
+    if (source.import) {
+        if (typeof source.import === 'string') {
+            // Путь точки входа определён, типизация отсутствует.
+            result.entry = source.import;
+        }
+        else {
+            result.entry = source.import.default;
+            result.types = source.import.types;
+        }
+    }
+    return result;
+}
+/**
+ * Проверяет наличие точки входа для типизации.
+ *
+ * @param entry Путь к точке входа.
+ * @param types Путь к файлу типов.
+ * @throws {NpmBuildError} Если отсутствует точка входа.
+ *
+ * @since 0.3.5
+ *
+ **/
+function assertTypesHaveEntry(entry, types) {
+    if (types && !entry)
+        throw NpmBuildError.get('exportTypesOnly', types);
+}
+/**
+ * Нормализует поле `exports` из package.json в словарь точек входа.
+ *
+ * @param exportsField Значение поля `exports`.
+ * @returns Словарь точек входа с метаданными.
+ * @throws {NpmBuildError} Если конфигурация экспорта отсутствует или некорректна.
+ *
+ * @since 0.3.5
+ *
+ **/
+function normalizeExports(exportsField) {
+    if (!exportsField)
+        throw NpmBuildError.get('exportEmpty');
+    if (Array.isArray(exportsField))
+        throw NpmBuildError.get('exportDisallowArrayType');
+    const result = {};
+    if (typeof exportsField === 'string') {
+        result[exportsField] = {};
+        return result;
+    }
+    if (isConditionalEntry(exportsField)) {
+        const { entry, types } = processConditionalEntry(exportsField);
+        assertTypesHaveEntry(entry, types);
+        if (entry)
+            result[entry] = types
+                ? { dtsOutputFile: types }
+                : {};
+        return result;
+    }
+    for (const [key, value] of Object.entries(exportsField)) {
+        if (!value)
+            continue;
+        if (!key.startsWith('.'))
+            throw NpmBuildError.get('exportMustStartWithDot', key);
+        let entry, types;
+        if (typeof value === 'string') {
+            // Путь точки входа определён, типизация отсутствует.
+            entry = value;
+        }
+        else if (isConditionalEntry(value)) {
+            ({ entry, types } = processConditionalEntry(value));
+        }
+        else {
+            entry = value.default;
+            types = value.types;
+        }
+        assertTypesHaveEntry(entry, types);
+        if (entry)
+            result[entry] = types
+                ? { dtsOutputFile: types }
+                : {};
+    }
+    return result;
+}
+/**
+ * Сопоставляет входные файлы (`src/*.ts`) с выходными (`./dist/*.mjs`)
+ * на основе поля `exports` из `package.json`.
+ *
+ * @param inputs Локальные пути (`src/index.ts`)
+ * @param normalizedExports Словарь `exportPath → { dtsOutputFile }`
+ * @param skipExports Пропустить проверку (для `bin`-пакетов)
+ * @returns Словарь `input → { outputFile, dtsSourceFile, dtsOutputFile }`
+ *
+ * @throws NpmBuildError если:
+ *   - `input` не начинается с `src/`
+ *   - `input` не имеет соответствия в `exports`
+ *   - `exports` не имеет соответствия в `input`
+ *   - `types` указан без `import`/`default`
+ *
+ * @since 0.3.4
+ *
+ **/
+function createInputBindings(inputs, normalizedExports, skipExports) {
+    // Извлекает относительный путь после префикса `src/` (без расширения).
+    const filePattern = /^(?:.*\/)?src\/(.*)\.[jt]s$/;
+    const result = {};
+    const usedExports = new Set();
+    const producingOutputs = new Set();
+    for (const input of inputs) {
+        if (!input.startsWith('src/'))
+            throw NpmBuildError.get('inputPathRequiresPrefix', input, 'src/');
+        const match = filePattern.exec(input);
+        if (!match)
+            throw NpmBuildError.get('inputFileExtensionNotSupported', input);
+        const outputFile = `${match[1]}.mjs`;
+        if (producingOutputs.has(outputFile))
+            throw NpmBuildError.get('inputGeneratesDuplicateOutput', outputFile);
+        producingOutputs.add(outputFile);
+        const exportEntry = `./${outDir}/${outputFile}`;
+        usedExports.add(exportEntry);
+        const descriptor = normalizedExports[exportEntry];
+        // Проверяет наличие ключа в словаре экспорта (при необходимости).
+        if (!descriptor && !skipExports)
+            throw NpmBuildError.get('inputHasNoExport', input, exportEntry);
+        result[input] = {
+            outputFile,
+            dtsSourceFile: `${outDirDts}/${match[1]}.d.ts`,
+            dtsOutputFile: descriptor?.dtsOutputFile,
+        };
+    }
+    for (const key of Object.keys(normalizedExports)) {
+        // Выявляет незадействованные ключи в словаре экспорта (обратная проверка).
+        if (!usedExports.has(key))
+            throw NpmBuildError.get('exportHasNoInput', key);
+    }
+    return result;
+}
+/**
+ * Создаёт отображение между промежуточными файлами типов `.d.ts` и их финальными выходными путями.
+ * Используется для настройки `entryFileNames` в конфигурации Rollup для `.d.ts`-бандла.
+ *
+ * @param inputBindings Словарь связей входных файлов с выходными путями.
+ * @returns Словарь отображений: ключ — промежуточный путь `.d.ts` (например, `dist/dts/index.d.ts`),
+ *          значение — финальное имя файла (например, `index.d.mts`).
+ * @example
+ * ```ts
+ * const mappings = createDtsMappings({
+ *   'src/index.ts': {
+ *     outputFile: 'index.mjs',
+ *     dtsSourceFile: 'dist/dts/index.d.ts',
+ *     dtsOutputFile: './dist/index.d.mts'
+ *   }
+ * })
+ * // Возвращает: { 'dist/dts/index.d.ts': 'index.d.mts' }
+ * ```
+ * @since 0.4.0
+ *
+ **/
+function createDtsMappings(inputBindings) {
+    const mappings = {};
+    for (const binding of Object.values(inputBindings)) {
+        if (binding?.dtsOutputFile)
+            mappings[binding.dtsSourceFile] = sliceDistPrefix(binding.dtsOutputFile);
+    }
+    return mappings;
+}
+/**
+ * Возвращает относительный путь от корня монорепозитория до пакета с завершающим слешем.
+ *
+ * Используется для:
+ * - Преобразования локальных путей (`src/index.ts`) → глобальные (`packages/name/src/index.ts`)
+ * - Формирования входов для `dts`-сборки (`packages/name/dist/dts/index.d.ts`)
+ *
+ * @param cwdRoot Корень монорепозитория (где запущен Rollup)
+ * @param cwdPackage Директория пакета
+ * @returns Относительный путь вида `'packages/mirta-rollup/'`, или `''`, если это корень
+ *
+ * @example
+ *
+ * ```ts
+ * getPackagePrefix('/repo', '/repo/packages/core') → 'packages/core/'
+ *
+ * ```
+ *
+ * @since 0.4.0
+ *
+ **/
+function getPackagePrefix(cwdRoot, cwdPackage) {
+    const packagePrefix = toPosix(nodePath.relative(cwdRoot, cwdPackage));
+    return packagePrefix
+        ? `${packagePrefix}/`
+        : '';
+}
+// Проверка TypeScript выполняется только для первой конфигурации.
+let hasTsChecked = false;
+/**
+ * Создаёт конфигурации Rollup для пакета на основе его `package.json`.
+ *
+ * Поддерживает:
+ * - ESM-бандл (обязательно)
+ * - `.d.ts`-бандл (если в `exports` указаны `types`)
+ * - Режим запуска из корня монорепозитория (через `packagePrefix`)
+ * - Проверки соответствия `input` ↔ `exports`
+ *
+ * @param options Настройки сборки
+ * @returns Массив конфигураций Rollup
+ *
+ * @example
+ *
+ * ```ts
+ * definePackageConfig({
+ *   cwd: '/repo/packages/my-package',
+ *   input: 'src/index.ts',
+ * })
+ *
+ * ```
+ * @since 0.3.0
+ *
+ **/
+function definePackageConfig(options = {}) {
+    // Реальная директория запуска может отличаться от директории пакета `cwd`.
+    const cwdRoot = process.cwd();
+    const { cwd = cwdRoot, input = 'src/index.ts', external = [], plugins, skipExports = false, } = options;
+    const packagePrefix = getPackagePrefix(cwdRoot, cwd);
+    const outDirPath = nodePath.join(cwd, outDir);
+    const outDirDtsPath = nodePath.join(cwd, outDirDts);
+    const pkgPath = nodePath.resolve(cwd, 'package.json');
+    const externalFilter = createExternalFilter(cwd, [
+        /node_modules/,
+        pkgPath, // Для предотвращения встраивания `package.json` в бандл
+    ], external);
+    const normalizedInput = normalizeInput(input);
+    const { exports: exports$1 = {} } = readPackage(pkgPath);
+    const normalizedExports = !skipExports
+        ? normalizeExports(exports$1)
+        : {};
+    const inputBindings = createInputBindings(normalizedInput, normalizedExports, skipExports);
+    const dtsMappings = createDtsMappings(inputBindings);
+    const dtsInputs = Object.keys(dtsMappings)
+        .map(item => `${packagePrefix}${item}`);
+    const rollupConfigs = [
+        createBuildConfig('mjs', {
+            cwd,
+            input: normalizedInput.map(input => `${packagePrefix}${input}`),
+            external: externalFilter,
+            emitDeclarations: dtsInputs.length > 0,
+            plugins,
+            outPath: outDirPath,
+            outPathDts: outDirDtsPath,
+            output: {
+                dir: outDirPath,
+                format: 'es',
+                importAttributesKey: 'with',
+                entryFileNames(chunk) {
+                    if (chunk.facadeModuleId) {
+                        const localPath = nodePath
+                            .relative(cwd, chunk.facadeModuleId)
+                            .replaceAll(nodePath.sep, nodePath.posix.sep);
+                        const binding = inputBindings[localPath];
+                        if (binding)
+                            return binding.outputFile;
+                    }
+                    return `${chunk.name}.mjs`;
+                },
+                chunkFileNames(chunk) {
+                    // Для чанков с названием `index` использует имя родительской директории
+                    // вместо порядкового номера (`index.mjs`, `index2.mjs`, `index3.mjs`)
+                    //
+                    if (chunk.name === 'index' && chunk.facadeModuleId)
+                        return `${basename(dirname(chunk.facadeModuleId))}.mjs`;
+                    return `${chunk.name}.mjs`;
+                },
+            },
+        }),
+    ];
+    if (dtsInputs.length > 0) {
+        rollupConfigs.push({
+            input: dtsInputs,
+            external: externalFilter,
+            plugins: [
+                nodeResolve(),
+                commonjs(),
+                dts(),
+                del({
+                    targets: outDirDtsPath,
+                    hook: 'closeBundle',
+                }),
+            ],
+            output: {
+                dir: outDirPath,
+                format: 'es',
+                entryFileNames(chunk) {
+                    if (chunk.facadeModuleId) {
+                        const localPath = nodePath
+                            .relative(cwd, chunk.facadeModuleId)
+                            .replaceAll(nodePath.sep, nodePath.posix.sep);
+                        if (dtsMappings[localPath])
+                            return dtsMappings[localPath];
+                    }
+                    return `${chunk.name}.mts`;
+                },
+            },
+        });
+    }
+    return rollupConfigs;
+}
+/**
+ * Создаёт конфигурацию сборки Rollup.
+ *
+ * @param buildName Имя сборки.
+ * @param options Параметры сборки.
+ * @returns Конфигурация Rollup.
+ *
+ * @since 0.3.0
+ *
+ **/
+function createBuildConfig(buildName, options) {
+    const { cwd, external, input, emitDeclarations, plugins = [], outPath, outPathDts, output } = options;
+    output.sourcemap = !!process.env.SOURCE_MAP;
+    output.externalLiveBindings = false;
+    process.env.NODE_ENV === 'production';
+    const tsPlugin = ts$1({
+        tsconfig: nodePath.resolve(cwd, './tsconfig.build.json'),
+        compilerOptions: {
+            noCheck: hasTsChecked,
+            outDir: outPath,
+            declaration: emitDeclarations,
+            declarationDir: emitDeclarations ? outPathDts : void 0,
+        },
+        exclude: [
+            'packages/*/tests',
+        ],
+        transformers: {
+            afterDeclarations: [
+                dtsAlias(),
+            ],
+        },
+    });
+    // При запуске команды build, проверки TS и генерация определений
+    // выполняются единожды - для первой конфигурации.
+    hasTsChecked = true;
+    const assetsSrc = toPosix(nodePath.join(cwd, 'public/*'));
+    return {
+        input,
+        external,
+        plugins: [
+            // Очистка директории dist перед сборкой
+            del({
+                targets: outPath,
+            }),
+            tsPlugin,
+            createReplacePlugin(),
+            nodeResolve(),
+            commonjs(),
+            ...plugins,
+            copy({
+                targets: [
+                    { src: assetsSrc, dest: outPath },
+                ],
+            }),
+        ],
+        output,
+    };
+}
+/**
+ * Создаёт плагин замены значений.
+ *
+ * @param isProduction Признак production-сборки.
+ * @param isBundlerEsmBuild Признак сборки для bundler ESM.
+ * @param isNodeBuild Признак сборки для Node.js.
+ * @returns Плагин замены.
+ *
+ * @since 0.3.0
+ *
+ **/
+function createReplacePlugin(isProduction, isBundlerEsmBuild, isNodeBuild) {
+    const replacements = {
+        // Preserve to be handled by bundlers
+        __DEV__: `(process.env.NODE_ENV !== 'production')`
+            ,
+        __TEST__: `(process.env.NODE_ENV === 'test')`
+            ,
+    };
+    // Allow inline overrides like
+    // __DEV__=true pnpm build
+    Object.keys(replacements).forEach((key) => {
+        if (key in process.env)
+            replacements[key] = process.env[key];
+    });
+    return replace({
+        preventAssignment: true,
+        values: replacements,
+        delimiters: ['\\b', '\\b(?![\\.\\:])'],
+    });
+}
+
+export { definePackageConfig as d };