tsfmt 0.0.0 → 0.2.0

package/README.md

@@ -84,7 +84,7 @@ tsfmt uses a sophisticated pipeline-based architecture:
 **Configuration System**
 
 - Zero-configuration by default with sensible opinions
-- Optional `core.config.ts` file for project-specific customization
+- Optional `tsfmt.config.ts` file for project-specific customization
 - Deep merging of user configuration with defaults
 
 ## Key Features

package/dist/build-plugins/transformGenericsPlugin.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+function transformGenericsPlugin() {
+  function discoverRuleMappings() {
+    try {
+      let sourceCode;
+      const possiblePaths = [
+        path.resolve(__dirname, "../core/pipeline/FormatterPipeline.ts"),
+        path.resolve(__dirname, "../../src/core/pipeline/FormatterPipeline.ts"),
+        path.resolve(process.cwd(), "src/core/pipeline/FormatterPipeline.ts")
+      ];
+      for (const path2 of possiblePaths) {
+        try {
+          sourceCode = fs.readFileSync(path2, "utf8");
+          break;
+        } catch {
+        }
+      }
+      if (!sourceCode) {
+        throw new Error("Could not find FormatterPipeline.ts");
+      }
+      const methodStart = sourceCode.match(/private\s+initializeRules\(\):\s*void\s*\{/);
+      if (!methodStart || methodStart.index === void 0) {
+        throw new Error("Could not find initializeRules method");
+      }
+      const startIndex = methodStart.index + methodStart[0].length;
+      let braceCount = 1;
+      let endIndex = startIndex;
+      for (let i = startIndex; i < sourceCode.length && braceCount > 0; i++) {
+        if (sourceCode[i] === "{") {
+          braceCount++;
+        } else if (sourceCode[i] === "}") {
+          braceCount--;
+        }
+        endIndex = i;
+      }
+      const initRulesBody = sourceCode.substring(startIndex, endIndex);
+      const orderToRuleMap = {};
+      const addRuleRegex = /this\.addRule<([^>]+)>\(FormatterOrder\.([^)]+)\)/g;
+      let match;
+      while ((match = addRuleRegex.exec(initRulesBody)) !== null) {
+        const ruleName = match[1].trim();
+        const orderName = match[2].trim();
+        const orderKey = `ConfigTypes.FormatterOrder.${orderName}`;
+        if (!orderToRuleMap[orderKey]) {
+          orderToRuleMap[orderKey] = [];
+        }
+        orderToRuleMap[orderKey].push(ruleName);
+      }
+      return orderToRuleMap;
+    } catch (error) {
+      throw new Error(`Failed to auto-discover rule mappings from FormatterPipeline.ts: ${error}`);
+    }
+  }
+  return {
+    name: "transform-generics",
+    generateBundle(options, bundle) {
+      for (const fileName in bundle) {
+        const chunk = bundle[fileName];
+        if (chunk.type === "chunk" && fileName.includes("FormatterPipeline.js")) {
+          const orderToRuleMap = discoverRuleMappings();
+          const orderIndices = {};
+          for (const orderType of Object.keys(orderToRuleMap)) {
+            orderIndices[orderType] = 0;
+          }
+          chunk.code = chunk.code.replace(/this\.addRule\s*\(\s*([^)]+)\s*\)/g, (match, orderParam) => {
+            const orderKey = orderParam.trim();
+            if (orderToRuleMap[orderKey]) {
+              const rules = orderToRuleMap[orderKey];
+              const currentIndex = orderIndices[orderKey] || 0;
+              if (currentIndex < rules.length) {
+                const ruleName = rules[currentIndex];
+                orderIndices[orderKey] = currentIndex + 1;
+                return `this.addRuleByName("${ruleName}", ${orderParam})`;
+              }
+            }
+            return match;
+          });
+        }
+      }
+    }
+  };
+}
+exports.transformGenericsPlugin = transformGenericsPlugin;

package/dist/cli.js

@@ -0,0 +1,173 @@
+"use strict";
+const fs = require("fs");
+const glob = require("glob");
+const path = require("path");
+require("reflect-metadata");
+require("typescript");
+require("./core/config/ConfigDefaults.js");
+const ConfigLoader = require("./core/config/ConfigLoader.js");
+const Container = require("./core/di/Container.js");
+const ServiceRegistration = require("./core/di/ServiceRegistration.js");
+require("fs/promises");
+const sortPackage = require("./sortPackage.js");
+const sortTSConfig = require("./sortTSConfig.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const glob__namespace = /* @__PURE__ */ _interopNamespaceDefault(glob);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+async function formatDirectory(targetDir, config, dryRun) {
+  const container = new Container.Container();
+  ServiceRegistration.ServiceRegistration.registerServices(container, config);
+  const include = config.sorting?.include || ["**/*.{ts,tsx,js,jsx}"];
+  const exclude = config.sorting?.exclude || [];
+  const criticalExcludes = ["node_modules/**", "dist/**", "build/**", "vendor/**", "bin/**"];
+  const finalExclude = [.../* @__PURE__ */ new Set([...exclude, ...criticalExcludes])];
+  const files = include.flatMap((pattern) => glob__namespace.sync(pattern, {
+    cwd: targetDir,
+    ignore: finalExclude,
+    absolute: true
+  }));
+  if (files.length === 0) {
+    console.info("No files found to format.");
+    return;
+  }
+  console.info(`Formatting ${files.length} files...`);
+  const pipeline = container.resolve("FormatterPipeline");
+  let formattedCount = 0;
+  for (const file of files) {
+    try {
+      const context = await pipeline.formatFile(file, dryRun);
+      if (context.changed) {
+        formattedCount++;
+        if (!dryRun) {
+          console.log(`📊  Formatted: ${path__namespace.relative(targetDir, file)}`);
+        }
+      }
+    } catch (error) {
+      console.error(`Error formatting file ${file}:`, error.message);
+    }
+  }
+  if (dryRun) {
+    console.info(`Would format ${formattedCount} of ${files.length} files.`);
+  } else {
+    console.info(`Formatted ${formattedCount} of ${files.length} files.`);
+  }
+}
+async function formatSingleFile(filePath, config, dryRun) {
+  const container = new Container.Container();
+  ServiceRegistration.ServiceRegistration.registerServices(container, config);
+  const pipeline = container.resolve("FormatterPipeline");
+  try {
+    const context = await pipeline.formatFile(filePath, dryRun);
+    if (context.changed) {
+      if (dryRun) {
+        console.info(`Would format: ${filePath}`);
+      } else {
+        console.log(`📊  Formatted: ${filePath}`);
+      }
+    } else {
+      console.info(`No changes needed: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`Error formatting file ${filePath}:`, error.message);
+  }
+}
+function isSupportedFile(filePath) {
+  const supportedExtensions = [".ts", ".tsx", ".js", ".jsx"];
+  return supportedExtensions.some((ext) => filePath.endsWith(ext));
+}
+async function main() {
+  const args = process.argv.slice(2);
+  let target = process.cwd();
+  let dryRun = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dry") {
+      dryRun = true;
+    } else if (!arg.startsWith("-")) {
+      target = path__namespace.resolve(arg);
+    } else {
+      console.error(`Error: Unsupported option "${arg}". Only --dry is supported.`);
+      process.exit(1);
+    }
+  }
+  try {
+    const targetStat = fs__namespace.existsSync(target) ? fs__namespace.statSync(target) : null;
+    const isFile = targetStat?.isFile() ?? false;
+    const isDirectory = targetStat?.isDirectory() ?? false;
+    if (!targetStat) {
+      console.error(`Error: Target "${target}" does not exist.`);
+      process.exit(1);
+    }
+    const configDir = isFile ? path__namespace.dirname(target) : target;
+    const config = ConfigLoader.ConfigLoader.loadConfig(configDir);
+    if (ConfigLoader.ConfigLoader.hasConfigFile(configDir)) {
+      console.log("Using custom configuration from tsfmt.config.ts");
+    }
+    if (isFile) {
+      if (!isSupportedFile(target)) {
+        console.error(`Error: Unsupported file type. Supported: .ts, .tsx, .js, .jsx`);
+        process.exit(1);
+      }
+      if (config.codeStyle?.enabled || config.imports?.enabled || config.sorting?.enabled || config.spacing?.enabled) {
+        await formatSingleFile(target, config, dryRun);
+      }
+      if (dryRun) {
+        console.info("Dry run completed. No files were modified.");
+      } else {
+        console.info("Formatting completed successfully.");
+      }
+      return;
+    }
+    if (isDirectory) {
+      if (config.packageJson?.enabled) {
+        const packagePath = path__namespace.join(target, "package.json");
+        if (fs__namespace.existsSync(packagePath)) {
+          console.log(`📦  Processing ${packagePath}...`);
+          sortPackage.sortPackageFile(packagePath, {
+            customSortOrder: config.packageJson.customSortOrder,
+            indentation: config.packageJson.indentation,
+            dryRun
+          });
+        }
+      }
+      if (config.tsConfig?.enabled) {
+        const tsconfigPath = path__namespace.join(target, "tsconfig.json");
+        if (fs__namespace.existsSync(tsconfigPath)) {
+          console.log(`🔧  Processing ${tsconfigPath}...`);
+          sortTSConfig.sortTsConfigFile(tsconfigPath, {
+            indentation: config.tsConfig.indentation,
+            dryRun
+          });
+        }
+      }
+      if (config.codeStyle?.enabled || config.imports?.enabled || config.sorting?.enabled || config.spacing?.enabled) {
+        await formatDirectory(target, config, dryRun);
+      }
+      if (dryRun) {
+        console.info("Dry run completed. No files were modified.");
+      } else {
+        console.info("Formatting completed successfully.");
+      }
+    }
+  } catch (error) {
+    console.error("Error during formatting:", error.message);
+    process.exit(1);
+  }
+}
+main();

package/dist/core/ast/ASTAnalyzer.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class ASTAnalyzer {
+  /**
+  * Extracts all identifier references from a node
+  * This is the core traversal function that recursively visits the AST
+  */
+  static extractReferences(node, scopeFilter) {
+    const identifiers = /* @__PURE__ */ new Set();
+    const thisReferences = /* @__PURE__ */ new Set();
+    const directCalls = /* @__PURE__ */ new Set();
+    function visit(currentNode) {
+      if (ts__namespace.isPropertyAccessExpression(currentNode)) {
+        if (currentNode.expression.kind === ts__namespace.SyntaxKind.ThisKeyword) {
+          const propName = currentNode.name.text;
+          if (!scopeFilter || scopeFilter(propName)) {
+            thisReferences.add(propName);
+            identifiers.add(propName);
+          }
+        }
+      }
+      if (ts__namespace.isIdentifier(currentNode)) {
+        const name = currentNode.text;
+        if (!scopeFilter || scopeFilter(name)) {
+          identifiers.add(name);
+          const parent = currentNode.parent;
+          if (parent && ts__namespace.isCallExpression(parent) && parent.expression === currentNode) {
+            directCalls.add(name);
+          }
+        }
+      }
+      if (ts__namespace.isElementAccessExpression(currentNode)) {
+        if (currentNode.expression.kind === ts__namespace.SyntaxKind.ThisKeyword) {
+          if (ts__namespace.isStringLiteral(currentNode.argumentExpression)) {
+            const propName = currentNode.argumentExpression.text;
+            if (!scopeFilter || scopeFilter(propName)) {
+              thisReferences.add(propName);
+              identifiers.add(propName);
+            }
+          }
+        }
+      }
+      ts__namespace.forEachChild(currentNode, visit);
+    }
+    visit(node);
+    return { identifiers, thisReferences, directCalls };
+  }
+  /**
+  * Extract references from a class member
+  * Only considers references to members in availableMembers set
+  */
+  static extractClassMemberReferences(member, availableMembers) {
+    if (ts__namespace.isConstructorDeclaration(member)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const refs = this.extractReferences(member, (name) => availableMembers.has(name));
+    return /* @__PURE__ */ new Set([...refs.thisReferences, ...refs.identifiers]);
+  }
+  /**
+  * Extract references from a file-level declaration
+  * Only considers references to declarations in availableDeclarations set
+  */
+  static extractFileDeclarationReferences(declaration, availableDeclarations) {
+    if (ts__namespace.isImportDeclaration(declaration) || ts__namespace.isImportEqualsDeclaration(declaration) || ts__namespace.isExportDeclaration(declaration)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const refs = this.extractReferences(declaration, (name) => availableDeclarations.has(name));
+    return refs.identifiers;
+  }
+  /** Get the name of a class member */
+  static getClassMemberName(member) {
+    if (ts__namespace.isConstructorDeclaration(member)) {
+      return "constructor";
+    }
+    if (ts__namespace.isPropertyDeclaration(member) || ts__namespace.isMethodDeclaration(member) || ts__namespace.isGetAccessorDeclaration(member) || ts__namespace.isSetAccessorDeclaration(member)) {
+      if (ts__namespace.isIdentifier(member.name)) {
+        return member.name.text;
+      }
+      if (ts__namespace.isStringLiteral(member.name)) {
+        return member.name.text;
+      }
+    }
+    return "";
+  }
+  /** Get the name of a file-level declaration */
+  static getDeclarationName(declaration) {
+    if (ts__namespace.isInterfaceDeclaration(declaration) || ts__namespace.isTypeAliasDeclaration(declaration) || ts__namespace.isEnumDeclaration(declaration) || ts__namespace.isFunctionDeclaration(declaration) || ts__namespace.isClassDeclaration(declaration)) {
+      return declaration.name?.text || "";
+    }
+    if (ts__namespace.isVariableStatement(declaration)) {
+      const firstDecl = declaration.declarationList.declarations[0];
+      if (ts__namespace.isIdentifier(firstDecl.name)) {
+        return firstDecl.name.text;
+      }
+    }
+    return "";
+  }
+  /** Check if a node has a specific modifier */
+  static hasModifier(node, kind) {
+    const modifiers = ts__namespace.canHaveModifiers(node) ? ts__namespace.getModifiers(node) : void 0;
+    return modifiers?.some((m) => m.kind === kind) || false;
+  }
+  /** Check if a statement is a default export */
+  static isDefaultExport(node) {
+    if (ts__namespace.isExportAssignment(node)) {
+      return true;
+    }
+    return this.hasModifier(node, ts__namespace.SyntaxKind.DefaultKeyword);
+  }
+  /** Check if a statement has an export modifier */
+  static isExported(node) {
+    if (ts__namespace.isExportAssignment(node)) {
+      return true;
+    }
+    return this.hasModifier(node, ts__namespace.SyntaxKind.ExportKeyword);
+  }
+}
+exports.ASTAnalyzer = ASTAnalyzer;

package/dist/core/ast/ASTTransformer.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class ASTTransformer {
+  /** Create a source file from source code */
+  static createSourceFile(source, filePath) {
+    const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts__namespace.ScriptKind.TSX : ts__namespace.ScriptKind.TS;
+    return ts__namespace.createSourceFile(filePath, source, ts__namespace.ScriptTarget.Latest, true, scriptKind);
+  }
+  /** Print a node to string using TypeScript printer */
+  static printNode(node, sourceFile, removeComments = false) {
+    const printer = ts__namespace.createPrinter({
+      newLine: ts__namespace.NewLineKind.LineFeed,
+      removeComments
+    });
+    return printer.printNode(ts__namespace.EmitHint.Unspecified, node, sourceFile);
+  }
+  /**
+  * Print a source file to string
+  * Extracts and deduplicates leading comments to prevent duplication during formatting
+  */
+  static printSourceFile(sourceFile) {
+    const fullText = sourceFile.getFullText();
+    const leadingCommentsMatch = fullText.match(/^((?:\/\*[\s\S]*?\*\/\s*)+)/);
+    let leadingComments = leadingCommentsMatch ? leadingCommentsMatch[1].trim() : "";
+    if (leadingComments) {
+      const commentBlocks = leadingComments.match(/\/\*[\s\S]*?\*\//g) || [];
+      const uniqueBlocks = new Set(commentBlocks.map((block) => block.trim()));
+      leadingComments = Array.from(uniqueBlocks).join("\n");
+    }
+    const printer = ts__namespace.createPrinter({
+      newLine: ts__namespace.NewLineKind.LineFeed,
+      removeComments: false
+    });
+    let printed = printer.printFile(sourceFile);
+    printed = printed.replace(/(\n;)+\s*$/, "\n");
+    if (leadingComments) {
+      const printedWithoutLeadingComments = printed.replace(/^((?:\/\*[\s\S]*?\*\/\s*)+)/, "").trimStart();
+      return leadingComments + "\n\n" + printedWithoutLeadingComments;
+    }
+    return printed;
+  }
+  /** Create a new class declaration with reordered members */
+  static reorderClassMembers(classNode, orderedMembers) {
+    return ts__namespace.factory.updateClassDeclaration(classNode, classNode.modifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, orderedMembers);
+  }
+  /** Create a new source file with reordered statements */
+  static reorderSourceFileStatements(sourceFile, orderedStatements) {
+    return ts__namespace.factory.updateSourceFile(sourceFile, orderedStatements, sourceFile.isDeclarationFile, sourceFile.referencedFiles, sourceFile.typeReferenceDirectives, sourceFile.hasNoDefaultLib, sourceFile.libReferenceDirectives);
+  }
+  /** Transform a source file by visiting all nodes */
+  static transformSourceFile(sourceFile, visitor) {
+    const transformer = (context) => {
+      const visit = (node) => {
+        const result2 = visitor(node);
+        if (result2)
+          return result2;
+        return ts__namespace.visitEachChild(node, visit, context);
+      };
+      return (node) => ts__namespace.visitNode(node, visit);
+    };
+    const result = ts__namespace.transform(sourceFile, [transformer]);
+    const transformedSourceFile = result.transformed[0];
+    result.dispose();
+    return transformedSourceFile;
+  }
+}
+exports.ASTTransformer = ASTTransformer;

package/dist/core/ast/DependencyResolver.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class DependencyResolver {
+  /**
+  * Find strongly connected components (circular dependency groups)
+  * Using Tarjan's algorithm
+  */
+  static findStronglyConnectedComponents(nodes) {
+    const index = /* @__PURE__ */ new Map();
+    const lowLink = /* @__PURE__ */ new Map();
+    const onStack = /* @__PURE__ */ new Set();
+    const stack = [];
+    const sccs = [];
+    let currentIndex = 0;
+    function strongConnect(nodeName) {
+      index.set(nodeName, currentIndex);
+      lowLink.set(nodeName, currentIndex);
+      currentIndex++;
+      stack.push(nodeName);
+      onStack.add(nodeName);
+      const node = nodes.get(nodeName);
+      for (const dep of node.dependencies) {
+        if (!index.has(dep)) {
+          strongConnect(dep);
+          lowLink.set(nodeName, Math.min(lowLink.get(nodeName), lowLink.get(dep)));
+        } else if (onStack.has(dep)) {
+          lowLink.set(nodeName, Math.min(lowLink.get(nodeName), index.get(dep)));
+        }
+      }
+      if (lowLink.get(nodeName) === index.get(nodeName)) {
+        const scc = /* @__PURE__ */ new Set();
+        let w;
+        do {
+          w = stack.pop();
+          onStack.delete(w);
+          scc.add(w);
+        } while (w !== nodeName);
+        if (scc.size > 1 || node.dependencies.has(nodeName)) {
+          sccs.push(scc);
+        }
+      }
+    }
+    for (const nodeName of nodes.keys()) {
+      if (!index.has(nodeName)) {
+        strongConnect(nodeName);
+      }
+    }
+    return sccs;
+  }
+  /** Builds a dependency graph from a list of items */
+  static buildGraph(items, getName, getDependencies) {
+    const nodes = /* @__PURE__ */ new Map();
+    items.forEach((item, index) => {
+      const name = getName(item);
+      if (!name)
+        return;
+      nodes.set(name, {
+        name,
+        dependencies: getDependencies(item),
+        originalIndex: index,
+        sortedIndex: index
+      });
+    });
+    const allNames = new Set(nodes.keys());
+    nodes.forEach((node) => {
+      node.dependencies = new Set(Array.from(node.dependencies).filter((dep) => allNames.has(dep)));
+    });
+    const circularGroups = this.findStronglyConnectedComponents(nodes);
+    return { nodes, circularGroups };
+  }
+  /**
+  * Performs topological sort respecting the ideal sorted order
+  * Returns array of names in dependency-aware order
+  */
+  static topologicalSort(graph, sortedNames) {
+    const result = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const circularNodes = /* @__PURE__ */ new Set();
+    graph.circularGroups.forEach((group) => {
+      group.forEach((name) => circularNodes.add(name));
+    });
+    function visit(name) {
+      if (visited.has(name))
+        return true;
+      if (visiting.has(name)) {
+        return false;
+      }
+      const node = graph.nodes.get(name);
+      if (!node)
+        return true;
+      visiting.add(name);
+      for (const dep of node.dependencies) {
+        if (circularNodes.has(dep) && circularNodes.has(name)) {
+          continue;
+        }
+        if (!visit(dep)) {
+          return false;
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+      result.push(name);
+      return true;
+    }
+    for (const name of sortedNames) {
+      visit(name);
+    }
+    return result;
+  }
+  /**
+  * Reorders items to respect dependencies while minimizing changes
+  * from the ideal sorted order
+  */
+  static reorderWithDependencies(items, getName) {
+    const getDeps = (item) => {
+      const member = item;
+      return member.dependencies || /* @__PURE__ */ new Set();
+    };
+    const graph = this.buildGraph(items, getName, getDeps);
+    const sortedNames = items.map(getName);
+    const dependencyOrder = this.topologicalSort(graph, sortedNames);
+    const nameToItem = /* @__PURE__ */ new Map();
+    items.forEach((item) => {
+      const name = getName(item);
+      if (name)
+        nameToItem.set(name, item);
+    });
+    const result = [];
+    for (const name of dependencyOrder) {
+      const item = nameToItem.get(name);
+      if (item) {
+        result.push(item);
+      }
+    }
+    items.forEach((item) => {
+      if (!result.includes(item)) {
+        result.push(item);
+      }
+    });
+    return result;
+  }
+}
+exports.DependencyResolver = DependencyResolver;