@hexaijs/plugin-contracts-generator 0.1.1 → 0.2.0

package/dist/file-copier.js

@@ -1,758 +0,0 @@
-"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.FileCopier = void 0;
-const path = __importStar(require("path"));
-const ts = __importStar(require("typescript"));
-const errors_1 = require("./errors");
-const file_system_1 = require("./file-system");
-const domain_1 = require("./domain");
-const class_analyzer_1 = require("./class-analyzer");
-const CONTRACTS_GENERATOR_MODULE = "@hexaijs/plugin-contracts-generator";
-const CONTRACT_DECORATORS = new Set([
-    "PublicCommand",
-    "PublicEvent",
-    "PublicQuery",
-]);
-const TS_EXTENSION_PATTERN = /\.ts$/;
-const TS_EXTENSION = ".ts";
-const REQUEST_SUFFIX = "Request";
-const QUERY_SUFFIX = "Query";
-class FileCopier {
-    fs;
-    constructor(options = {}) {
-        this.fs = options.fileSystem ?? file_system_1.nodeFileSystem;
-    }
-    async copyFiles(options) {
-        const { sourceRoot, outputDir, fileGraph, pathAliasRewrites, removeDecorators, responseTypesToExport, messageTypes, decoratorNames, } = options;
-        const copiedFiles = [];
-        const rewrittenImports = new Map();
-        const { entryContents, usedLocalImports } = await this.preprocessEntryFiles(fileGraph, messageTypes, decoratorNames, sourceRoot);
-        this.expandTransitiveDependencies(usedLocalImports, fileGraph);
-        for (const node of fileGraph.nodes.values()) {
-            const content = await this.resolveNodeContent(node, entryContents, usedLocalImports, messageTypes);
-            if (content === null) {
-                continue;
-            }
-            const transformedContent = this.applyTransformations(content, node, fileGraph, sourceRoot, removeDecorators, responseTypesToExport, pathAliasRewrites);
-            const outputPath = await this.writeOutputFile(outputDir, node.relativePath, transformedContent.content);
-            copiedFiles.push(outputPath);
-            if (transformedContent.rewrites.length > 0) {
-                rewrittenImports.set(outputPath, transformedContent.rewrites);
-            }
-        }
-        return { copiedFiles, rewrittenImports };
-    }
-    async preprocessEntryFiles(fileGraph, messageTypes, decoratorNames, sourceRoot) {
-        const entryContents = new Map();
-        const usedLocalImports = new Set();
-        if (!messageTypes?.length) {
-            return { entryContents, usedLocalImports };
-        }
-        for (const node of fileGraph.nodes.values()) {
-            if (!node.isEntryPoint) {
-                continue;
-            }
-            const rawContent = await this.readFileContent(node.absolutePath);
-            const { content: extractedContent, usedModuleSpecifiers } = this.extractSymbolsFromEntry(rawContent, node.absolutePath, messageTypes, decoratorNames);
-            entryContents.set(node.absolutePath, extractedContent);
-            for (const specifier of usedModuleSpecifiers) {
-                const importInfo = node.imports.find((i) => i.moduleSpecifier === specifier);
-                if (importInfo?.resolvedPath && !importInfo.isExternal) {
-                    usedLocalImports.add(importInfo.resolvedPath);
-                }
-            }
-        }
-        return { entryContents, usedLocalImports };
-    }
-    expandTransitiveDependencies(usedLocalImports, fileGraph) {
-        let changed = true;
-        while (changed) {
-            changed = false;
-            for (const importPath of usedLocalImports) {
-                const node = fileGraph.nodes.get(importPath);
-                if (!node)
-                    continue;
-                for (const imp of node.imports) {
-                    const isUnusedLocalImport = imp.resolvedPath &&
-                        !imp.isExternal &&
-                        !usedLocalImports.has(imp.resolvedPath);
-                    if (isUnusedLocalImport) {
-                        usedLocalImports.add(imp.resolvedPath);
-                        changed = true;
-                    }
-                }
-            }
-        }
-    }
-    async resolveNodeContent(node, entryContents, usedLocalImports, messageTypes) {
-        if (node.isEntryPoint && messageTypes?.length) {
-            return (entryContents.get(node.absolutePath) ??
-                (await this.readFileContent(node.absolutePath)));
-        }
-        const isUnusedDependency = messageTypes?.length && !usedLocalImports.has(node.absolutePath);
-        if (isUnusedDependency) {
-            return null;
-        }
-        return await this.readFileContent(node.absolutePath);
-    }
-    applyTransformations(content, node, fileGraph, sourceRoot, removeDecorators, responseTypesToExport, pathAliasRewrites) {
-        const rewrites = [];
-        let transformedContent = content;
-        transformedContent = this.processExcludedImports(transformedContent, node, fileGraph.excludedPaths, rewrites);
-        transformedContent = this.processDecoratorRemoval(transformedContent, node.absolutePath, removeDecorators, rewrites);
-        transformedContent = this.processTypeExports(transformedContent, node.absolutePath, responseTypesToExport?.get(node.absolutePath), rewrites);
-        transformedContent = this.processInternalPathAliases(transformedContent, node, fileGraph, sourceRoot, rewrites);
-        transformedContent = this.processExternalPathAliases(transformedContent, pathAliasRewrites, rewrites);
-        return { content: transformedContent, rewrites };
-    }
-    generateBarrelExport(copiedFiles, outputDir) {
-        const lines = [];
-        for (const filePath of copiedFiles) {
-            const relativePath = path.relative(outputDir, filePath);
-            lines.push(this.createExportStatement(relativePath));
-        }
-        return lines.join("\n");
-    }
-    async readFileContent(absolutePath) {
-        try {
-            return await this.fs.readFile(absolutePath);
-        }
-        catch (error) {
-            throw new errors_1.FileReadError(absolutePath, { cause: error });
-        }
-    }
-    async writeOutputFile(outputDir, relativePath, content) {
-        const outputPath = path.join(outputDir, relativePath);
-        const outputDirPath = path.dirname(outputPath);
-        await this.fs.mkdir(outputDirPath, { recursive: true });
-        try {
-            await this.fs.writeFile(outputPath, content);
-        }
-        catch (error) {
-            throw new errors_1.FileWriteError(outputPath, { cause: error });
-        }
-        return outputPath;
-    }
-    processExcludedImports(content, node, excludedPaths, rewrites) {
-        if (excludedPaths.size === 0) {
-            return content;
-        }
-        const excludedResult = this.removeExcludedImports(content, node, excludedPaths);
-        rewrites.push(...excludedResult.changes);
-        return excludedResult.content;
-    }
-    processDecoratorRemoval(content, filePath, removeDecorators, rewrites) {
-        if (!removeDecorators) {
-            return content;
-        }
-        const decoratorResult = this.removeContractDecorators(content, filePath);
-        rewrites.push(...decoratorResult.changes);
-        return decoratorResult.content;
-    }
-    processTypeExports(content, filePath, typesToExport, rewrites) {
-        if (!typesToExport || typesToExport.length === 0) {
-            return content;
-        }
-        const exportResult = this.addExportToTypes(content, filePath, typesToExport);
-        rewrites.push(...exportResult.changes);
-        return exportResult.content;
-    }
-    processInternalPathAliases(content, node, fileGraph, sourceRoot, rewrites) {
-        const internalResult = this.rewriteInternalPathAliases(content, node, fileGraph, sourceRoot);
-        rewrites.push(...internalResult.rewrites);
-        return internalResult.content;
-    }
-    processExternalPathAliases(content, pathAliasRewrites, rewrites) {
-        if (!pathAliasRewrites) {
-            return content;
-        }
-        const aliasResult = this.applyPathAliasRewrites(content, pathAliasRewrites);
-        rewrites.push(...aliasResult.rewrites);
-        return aliasResult.content;
-    }
-    createExportStatement(relativePath) {
-        const exportPath = "./" + relativePath.replace(TS_EXTENSION_PATTERN, "");
-        return `export * from '${exportPath}'`;
-    }
-    rewriteInternalPathAliases(content, node, fileGraph, sourceRoot) {
-        let transformedContent = content;
-        const appliedRewrites = [];
-        for (const importInfo of node.imports) {
-            if (this.isExternalOrRelativeImport(importInfo)) {
-                continue;
-            }
-            const targetNode = this.resolveInternalImport(importInfo, fileGraph);
-            if (!targetNode) {
-                continue;
-            }
-            const relativePath = this.computeRelativePath(node.relativePath, targetNode.relativePath);
-            const rewriteResult = this.rewriteModuleSpecifier(transformedContent, importInfo.moduleSpecifier, relativePath);
-            if (rewriteResult.wasRewritten) {
-                transformedContent = rewriteResult.content;
-                appliedRewrites.push(`${importInfo.moduleSpecifier} → ${relativePath}`);
-            }
-        }
-        return { content: transformedContent, rewrites: appliedRewrites };
-    }
-    isExternalOrRelativeImport(importInfo) {
-        return (importInfo.isExternal || importInfo.moduleSpecifier.startsWith("."));
-    }
-    resolveInternalImport(importInfo, fileGraph) {
-        if (!importInfo.resolvedPath ||
-            !fileGraph.nodes.has(importInfo.resolvedPath)) {
-            return undefined;
-        }
-        return fileGraph.nodes.get(importInfo.resolvedPath);
-    }
-    rewriteModuleSpecifier(content, originalSpecifier, newSpecifier) {
-        const importPattern = new RegExp(`(from\\s+['"])${this.escapeRegex(originalSpecifier)}(['"])`, "g");
-        if (!importPattern.test(content)) {
-            return { content, wasRewritten: false };
-        }
-        const rewrittenContent = content.replace(importPattern, `$1${newSpecifier}$2`);
-        return { content: rewrittenContent, wasRewritten: true };
-    }
-    computeRelativePath(fromRelative, toRelative) {
-        const fromDir = path.dirname(fromRelative);
-        let relativePath = path.relative(fromDir, toRelative);
-        relativePath = relativePath.replace(TS_EXTENSION_PATTERN, "");
-        if (!relativePath.startsWith(".")) {
-            relativePath = "./" + relativePath;
-        }
-        return relativePath;
-    }
-    applyPathAliasRewrites(content, rewrites) {
-        let transformedContent = content;
-        const appliedRewrites = [];
-        for (const [from, to] of rewrites) {
-            if (transformedContent.includes(from)) {
-                transformedContent = transformedContent.replace(new RegExp(this.escapeRegex(from), "g"), to);
-                appliedRewrites.push(`${from} → ${to}`);
-            }
-        }
-        return { content: transformedContent, rewrites: appliedRewrites };
-    }
-    escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-    removeExcludedImports(content, node, excludedPaths) {
-        const excludedModuleSpecifiers = this.findExcludedModuleSpecifiers(node, excludedPaths);
-        if (excludedModuleSpecifiers.size === 0) {
-            return { content, changes: [] };
-        }
-        const changes = Array.from(excludedModuleSpecifiers).map((specifier) => `removed import: ${specifier}`);
-        const visitorFactory = this.createExcludedImportsVisitor(excludedModuleSpecifiers);
-        const transformedContent = this.transformSourceFile(content, node.absolutePath, visitorFactory);
-        return { content: transformedContent, changes };
-    }
-    findExcludedModuleSpecifiers(node, excludedPaths) {
-        const excludedModuleSpecifiers = new Set();
-        for (const importInfo of node.imports) {
-            if (importInfo.resolvedPath &&
-                excludedPaths.has(importInfo.resolvedPath)) {
-                excludedModuleSpecifiers.add(importInfo.moduleSpecifier);
-            }
-        }
-        return excludedModuleSpecifiers;
-    }
-    createExcludedImportsVisitor(excludedModuleSpecifiers) {
-        return (context) => {
-            const visit = (node) => {
-                if (this.isImportFromExcludedModule(node, excludedModuleSpecifiers)) {
-                    return undefined;
-                }
-                if (this.isExportFromExcludedModule(node, excludedModuleSpecifiers)) {
-                    return undefined;
-                }
-                return ts.visitEachChild(node, visit, context);
-            };
-            return visit;
-        };
-    }
-    isImportFromExcludedModule(node, excludedModules) {
-        if (!ts.isImportDeclaration(node)) {
-            return false;
-        }
-        const moduleSpecifier = node.moduleSpecifier.text;
-        return excludedModules.has(moduleSpecifier);
-    }
-    isExportFromExcludedModule(node, excludedModules) {
-        if (!ts.isExportDeclaration(node) || !node.moduleSpecifier) {
-            return false;
-        }
-        const moduleSpecifier = node.moduleSpecifier.text;
-        return excludedModules.has(moduleSpecifier);
-    }
-    removeContractDecorators(content, filePath) {
-        const changes = [];
-        const visitorFactory = this.createDecoratorRemovalVisitor(changes);
-        const transformedContent = this.transformSourceFile(content, filePath, visitorFactory);
-        return { content: transformedContent, changes };
-    }
-    createDecoratorRemovalVisitor(changes) {
-        return (context) => {
-            const visit = (node) => {
-                if (ts.isImportDeclaration(node)) {
-                    return this.processContractGeneratorImport(node, changes);
-                }
-                if (ts.isClassDeclaration(node) && node.modifiers) {
-                    return this.removeContractDecoratorsFromClass(node, changes);
-                }
-                return ts.visitEachChild(node, visit, context);
-            };
-            return visit;
-        };
-    }
-    processContractGeneratorImport(node, changes) {
-        const moduleSpecifier = node.moduleSpecifier.text;
-        const isContractGeneratorModule = moduleSpecifier === CONTRACTS_GENERATOR_MODULE ||
-            moduleSpecifier.startsWith(CONTRACTS_GENERATOR_MODULE + "/");
-        if (!isContractGeneratorModule) {
-            return node;
-        }
-        const namedBindings = node.importClause?.namedBindings;
-        if (!namedBindings || !ts.isNamedImports(namedBindings)) {
-            return node;
-        }
-        const remainingElements = namedBindings.elements.filter((el) => !CONTRACT_DECORATORS.has(el.name.text));
-        if (remainingElements.length === 0) {
-            changes.push(`removed import: ${moduleSpecifier}`);
-            return undefined;
-        }
-        if (remainingElements.length < namedBindings.elements.length) {
-            changes.push(`removed decorators from import: ${moduleSpecifier}`);
-            return this.createImportWithFilteredBindings(node, remainingElements);
-        }
-        return node;
-    }
-    createImportWithFilteredBindings(originalImport, remainingElements) {
-        const newNamedImports = ts.factory.createNamedImports(remainingElements);
-        const newImportClause = ts.factory.createImportClause(originalImport.importClause.isTypeOnly, originalImport.importClause.name, newNamedImports);
-        return ts.factory.createImportDeclaration(originalImport.modifiers, newImportClause, originalImport.moduleSpecifier, originalImport.attributes);
-    }
-    removeContractDecoratorsFromClass(node, changes) {
-        const filteredModifiers = node.modifiers.filter((modifier) => {
-            if (!ts.isDecorator(modifier)) {
-                return true;
-            }
-            const decoratorName = this.extractDecoratorName(modifier);
-            if (decoratorName && CONTRACT_DECORATORS.has(decoratorName)) {
-                const decoratorSuffix = this.isDecoratorCallExpression(modifier)
-                    ? "()"
-                    : "";
-                changes.push(`removed decorator: @${decoratorName}${decoratorSuffix}`);
-                return false;
-            }
-            return true;
-        });
-        if (filteredModifiers.length === node.modifiers.length) {
-            return node;
-        }
-        return ts.factory.createClassDeclaration(filteredModifiers, node.name, node.typeParameters, node.heritageClauses, node.members);
-    }
-    extractDecoratorName(decorator) {
-        const expression = decorator.expression;
-        if (ts.isCallExpression(expression) &&
-            ts.isIdentifier(expression.expression)) {
-            return expression.expression.text;
-        }
-        if (ts.isIdentifier(expression)) {
-            return expression.text;
-        }
-        return undefined;
-    }
-    isDecoratorCallExpression(decorator) {
-        return ts.isCallExpression(decorator.expression);
-    }
-    hasExportModifier(node) {
-        return (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
-    }
-    prependExportModifier(modifiers) {
-        const exportModifier = ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
-        return modifiers ? [exportModifier, ...modifiers] : [exportModifier];
-    }
-    addExportToTypes(content, filePath, typeNames) {
-        const changes = [];
-        const typeNamesSet = new Set(typeNames);
-        const visitorFactory = this.createExportAdditionVisitor(typeNamesSet, changes);
-        const transformedContent = this.transformSourceFile(content, filePath, visitorFactory);
-        return { content: transformedContent, changes };
-    }
-    createExportAdditionVisitor(typeNamesSet, changes) {
-        return (context) => {
-            const visit = (node) => {
-                if (ts.isTypeAliasDeclaration(node)) {
-                    return this.addExportToTypeAlias(node, typeNamesSet, changes);
-                }
-                if (ts.isInterfaceDeclaration(node)) {
-                    return this.addExportToInterface(node, typeNamesSet, changes);
-                }
-                return ts.visitEachChild(node, visit, context);
-            };
-            return visit;
-        };
-    }
-    addExportToTypeAlias(node, typeNamesSet, changes) {
-        const typeName = node.name.text;
-        if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
-            return node;
-        }
-        changes.push(`added export: type ${typeName}`);
-        return ts.factory.createTypeAliasDeclaration(this.prependExportModifier(node.modifiers), node.name, node.typeParameters, node.type);
-    }
-    addExportToInterface(node, typeNamesSet, changes) {
-        const typeName = node.name.text;
-        if (!typeNamesSet.has(typeName) || this.hasExportModifier(node)) {
-            return node;
-        }
-        changes.push(`added export: interface ${typeName}`);
-        return ts.factory.createInterfaceDeclaration(this.prependExportModifier(node.modifiers), node.name, node.typeParameters, node.heritageClauses, node.members);
-    }
-    transformSourceFile(content, filePath, visitorFactory) {
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-        const transformer = (context) => {
-            return (sf) => {
-                const visitor = visitorFactory(context);
-                return ts.visitNode(sf, visitor);
-            };
-        };
-        const result = ts.transform(sourceFile, [transformer]);
-        const transformedSourceFile = result.transformed[0];
-        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-        const transformedContent = printer.printFile(transformedSourceFile);
-        result.dispose();
-        return transformedContent;
-    }
-    extractSymbolsFromEntry(content, filePath, messageTypes, decoratorNames) {
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-        const decoratorToMessageType = this.buildDecoratorToMessageTypeMap(decoratorNames);
-        const context = {
-            sourceFile,
-            content,
-            messageTypes,
-            decoratorToMessageType,
-        };
-        const { targetClassNames, targetClasses } = this.findTargetClasses(context);
-        if (targetClasses.length === 0) {
-            return { content, usedModuleSpecifiers: new Set() };
-        }
-        const relatedTypeNames = this.computeRelatedTypeNames(targetClassNames);
-        const usedIdentifiers = this.collectUsedIdentifiers(targetClasses);
-        const localTypeDeclarations = this.collectLocalTypeDeclarations(sourceFile);
-        const includedLocalTypes = this.resolveIncludedLocalTypes(usedIdentifiers, relatedTypeNames, localTypeDeclarations);
-        const extractedSymbols = {
-            targetClassNames,
-            targetClasses,
-            usedIdentifiers,
-            includedLocalTypes,
-            localTypeDeclarations,
-        };
-        return this.generateExtractedOutput(context, extractedSymbols);
-    }
-    buildDecoratorToMessageTypeMap(decoratorNames) {
-        const names = { ...domain_1.DEFAULT_DECORATOR_NAMES, ...decoratorNames };
-        return {
-            [names.event]: "event",
-            [names.command]: "command",
-            [names.query]: "query",
-        };
-    }
-    findTargetClasses(context) {
-        const targetClassNames = new Set();
-        const targetClasses = [];
-        const findClasses = (node) => {
-            if (ts.isClassDeclaration(node) && node.name) {
-                for (const [decoratorName, messageType] of Object.entries(context.decoratorToMessageType)) {
-                    if ((0, class_analyzer_1.hasDecorator)(node, decoratorName) &&
-                        context.messageTypes.includes(messageType)) {
-                        targetClassNames.add(node.name.text);
-                        targetClasses.push(node);
-                        break;
-                    }
-                }
-            }
-            ts.forEachChild(node, findClasses);
-        };
-        findClasses(context.sourceFile);
-        return { targetClassNames, targetClasses };
-    }
-    computeRelatedTypeNames(targetClassNames) {
-        const relatedTypeNames = new Set();
-        for (const className of targetClassNames) {
-            if (className.endsWith(REQUEST_SUFFIX)) {
-                const baseName = className.slice(0, -REQUEST_SUFFIX.length);
-                relatedTypeNames.add(baseName + "Response");
-                relatedTypeNames.add(baseName + "Payload");
-            }
-            else if (className.endsWith(QUERY_SUFFIX)) {
-                const baseName = className.slice(0, -QUERY_SUFFIX.length);
-                relatedTypeNames.add(baseName + "QueryResult");
-                relatedTypeNames.add(baseName + "Payload");
-            }
-            relatedTypeNames.add(className + "Response");
-            relatedTypeNames.add(className + "Payload");
-        }
-        return relatedTypeNames;
-    }
-    collectUsedIdentifiers(targetClasses) {
-        const usedIdentifiers = new Set();
-        const collectIdentifiers = (node) => {
-            if (ts.isTypeReferenceNode(node) &&
-                ts.isIdentifier(node.typeName)) {
-                usedIdentifiers.add(node.typeName.text);
-            }
-            if (ts.isExpressionWithTypeArguments(node) &&
-                ts.isIdentifier(node.expression)) {
-                usedIdentifiers.add(node.expression.text);
-            }
-            if (ts.isIdentifier(node) && node.parent) {
-                const isHeritageOrTypeRef = ts.isHeritageClause(node.parent.parent) ||
-                    ts.isTypeReferenceNode(node.parent);
-                if (isHeritageOrTypeRef) {
-                    usedIdentifiers.add(node.text);
-                }
-            }
-            if (ts.isDecorator(node)) {
-                this.collectDecoratorIdentifier(node, usedIdentifiers);
-            }
-            if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-                usedIdentifiers.add(node.expression.text);
-            }
-            ts.forEachChild(node, collectIdentifiers);
-        };
-        for (const cls of targetClasses) {
-            collectIdentifiers(cls);
-        }
-        return usedIdentifiers;
-    }
-    collectDecoratorIdentifier(decorator, usedIdentifiers) {
-        const expr = decorator.expression;
-        if (ts.isIdentifier(expr)) {
-            usedIdentifiers.add(expr.text);
-        }
-        else if (ts.isCallExpression(expr) &&
-            ts.isIdentifier(expr.expression)) {
-            usedIdentifiers.add(expr.expression.text);
-        }
-    }
-    collectLocalTypeDeclarations(sourceFile) {
-        const localTypeDeclarations = new Map();
-        const collectLocalTypes = (node) => {
-            if (ts.isInterfaceDeclaration(node) && node.name) {
-                this.addToDeclarationMap(localTypeDeclarations, node.name.text, node);
-            }
-            if (ts.isTypeAliasDeclaration(node) && node.name) {
-                this.addToDeclarationMap(localTypeDeclarations, node.name.text, node);
-            }
-            if (ts.isVariableStatement(node)) {
-                for (const decl of node.declarationList.declarations) {
-                    if (ts.isIdentifier(decl.name)) {
-                        this.addToDeclarationMap(localTypeDeclarations, decl.name.text, node);
-                    }
-                }
-            }
-            ts.forEachChild(node, collectLocalTypes);
-        };
-        collectLocalTypes(sourceFile);
-        return localTypeDeclarations;
-    }
-    addToDeclarationMap(map, name, node) {
-        const existing = map.get(name) ?? [];
-        existing.push(node);
-        map.set(name, existing);
-    }
-    resolveIncludedLocalTypes(usedIdentifiers, relatedTypeNames, localTypeDeclarations) {
-        const includedLocalTypes = new Set();
-        const queue = [...usedIdentifiers, ...relatedTypeNames];
-        while (queue.length > 0) {
-            const identifier = queue.shift();
-            if (includedLocalTypes.has(identifier))
-                continue;
-            const typeNodes = localTypeDeclarations.get(identifier);
-            if (!typeNodes || typeNodes.length === 0)
-                continue;
-            includedLocalTypes.add(identifier);
-            const typeIdentifiers = this.collectTypeIdentifiersFromNodes(typeNodes);
-            for (const id of typeIdentifiers) {
-                if (!includedLocalTypes.has(id)) {
-                    queue.push(id);
-                    usedIdentifiers.add(id);
-                }
-            }
-        }
-        return includedLocalTypes;
-    }
-    collectTypeIdentifiersFromNodes(nodes) {
-        const typeIdentifiers = new Set();
-        const collectFromType = (node) => {
-            if (ts.isTypeReferenceNode(node) &&
-                ts.isIdentifier(node.typeName)) {
-                typeIdentifiers.add(node.typeName.text);
-            }
-            if (ts.isExpressionWithTypeArguments(node) &&
-                ts.isIdentifier(node.expression)) {
-                typeIdentifiers.add(node.expression.text);
-            }
-            if (ts.isComputedPropertyName(node)) {
-                this.collectComputedPropertyIdentifier(node, typeIdentifiers);
-            }
-            ts.forEachChild(node, collectFromType);
-        };
-        for (const typeNode of nodes) {
-            collectFromType(typeNode);
-        }
-        return typeIdentifiers;
-    }
-    collectComputedPropertyIdentifier(node, typeIdentifiers) {
-        const expr = node.expression;
-        if (ts.isPropertyAccessExpression(expr) &&
-            ts.isIdentifier(expr.expression)) {
-            typeIdentifiers.add(expr.expression.text);
-        }
-        if (ts.isIdentifier(expr)) {
-            typeIdentifiers.add(expr.text);
-        }
-    }
-    generateExtractedOutput(context, symbols) {
-        const output = [];
-        const importMap = this.buildImportMap(context.sourceFile);
-        const filteredImports = this.filterImports(symbols.usedIdentifiers, importMap, symbols.includedLocalTypes);
-        this.appendImportStatements(output, filteredImports);
-        this.appendLocalTypeDeclarations(output, context, symbols);
-        this.appendTargetClasses(output, context, symbols.targetClasses);
-        const usedModuleSpecifiers = new Set(filteredImports.keys());
-        return {
-            content: output.join("\n"),
-            usedModuleSpecifiers,
-        };
-    }
-    buildImportMap(sourceFile) {
-        const importMap = new Map();
-        const collectImports = (node) => {
-            if (ts.isImportDeclaration(node)) {
-                const moduleSpecifier = node.moduleSpecifier.text;
-                const namedBindings = node.importClause?.namedBindings;
-                const isTypeOnly = node.importClause?.isTypeOnly ?? false;
-                if (namedBindings && ts.isNamedImports(namedBindings)) {
-                    for (const element of namedBindings.elements) {
-                        importMap.set(element.name.text, {
-                            moduleSpecifier,
-                            isTypeOnly,
-                        });
-                    }
-                }
-            }
-            ts.forEachChild(node, collectImports);
-        };
-        collectImports(sourceFile);
-        return importMap;
-    }
-    filterImports(usedIdentifiers, importMap, includedLocalTypes) {
-        const filteredImports = new Map();
-        for (const identifier of usedIdentifiers) {
-            const importInfo = importMap.get(identifier);
-            if (!importInfo || includedLocalTypes.has(identifier)) {
-                continue;
-            }
-            const existing = filteredImports.get(importInfo.moduleSpecifier);
-            if (existing) {
-                existing.identifiers.add(identifier);
-            }
-            else {
-                filteredImports.set(importInfo.moduleSpecifier, {
-                    identifiers: new Set([identifier]),
-                    isTypeOnly: importInfo.isTypeOnly,
-                });
-            }
-        }
-        return filteredImports;
-    }
-    appendImportStatements(output, filteredImports) {
-        for (const [moduleSpecifier, info] of filteredImports) {
-            const identifiers = [...info.identifiers].sort().join(", ");
-            const typeOnlyPrefix = info.isTypeOnly ? "type " : "";
-            output.push(`import ${typeOnlyPrefix}{ ${identifiers} } from "${moduleSpecifier}";`);
-        }
-        if (output.length > 0) {
-            output.push("");
-        }
-    }
-    appendLocalTypeDeclarations(output, context, symbols) {
-        const outputNodes = new Set();
-        for (const typeName of symbols.includedLocalTypes) {
-            const typeNodes = symbols.localTypeDeclarations.get(typeName);
-            if (!typeNodes)
-                continue;
-            for (const typeNode of typeNodes) {
-                if (outputNodes.has(typeNode))
-                    continue;
-                outputNodes.add(typeNode);
-                this.appendNodeWithExport(output, context, typeNode);
-            }
-        }
-    }
-    appendTargetClasses(output, context, targetClasses) {
-        for (const cls of targetClasses) {
-            this.appendNodeWithExport(output, context, cls);
-        }
-    }
-    appendNodeWithExport(output, context, node) {
-        const nodeText = context.content
-            .substring(node.getStart(context.sourceFile), node.end)
-            .trim();
-        const hasExport = this.nodeHasExportKeyword(node);
-        if (hasExport) {
-            output.push(nodeText);
-        }
-        else {
-            output.push("export " + nodeText);
-        }
-        output.push("");
-    }
-    nodeHasExportKeyword(node) {
-        const isExportableDeclaration = ts.isInterfaceDeclaration(node) ||
-            ts.isTypeAliasDeclaration(node) ||
-            ts.isVariableStatement(node) ||
-            ts.isClassDeclaration(node);
-        if (!isExportableDeclaration) {
-            return false;
-        }
-        const declarationNode = node;
-        return (declarationNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
-    }
-}
-exports.FileCopier = FileCopier;
-//# sourceMappingURL=file-copier.js.map