TypeScript कंपाइलर API: AST मॅनिप्युलेशन आणि कोड ट्रान्सफॉर्मेशनमध्ये प्रभुत्व

TypeScript कंपाइलर API हे TypeScript आणि JavaScript कोडचे विश्लेषण, हाताळणी आणि निर्मिती करण्यासाठी एक शक्तिशाली इंटरफेस प्रदान करते. याच्या केंद्रस्थानी ॲबस्ट्रॅक्ट सिंटॅक्स ट्री (AST) आहे, जे तुमच्या सोर्स कोडचे एक संरचित प्रतिनिधित्व आहे. AST सोबत कसे काम करायचे हे समजल्याने लिंटर्स, कोड फॉर्मेटर्स, स्टॅटिक ॲनालायझर्स आणि कस्टम कोड जनरेटर्स यांसारखी प्रगत साधने तयार करण्याची क्षमता मिळते.

TypeScript कंपाइलर API म्हणजे काय?

TypeScript कंपाइलर API हे TypeScript इंटरफेस आणि फंक्शन्सचा एक संच आहे जे TypeScript कंपाइलरच्या अंतर्गत कार्यप्रणाली उघड करते. हे डेव्हलपर्सना केवळ कोड संकलित करण्यापलीकडे जाऊन, प्रोग्रामॅटिकरित्या संकलन प्रक्रियेशी संवाद साधण्याची परवानगी देते. तुम्ही याचा वापर यासाठी करू शकता:

• कोडचे विश्लेषण करा: कोडची रचना तपासा, संभाव्य समस्या ओळखा आणि सिमेंटिक माहिती मिळवा.
• कोडचे रूपांतर करा: विद्यमान कोडमध्ये बदल करा, नवीन वैशिष्ट्ये जोडा किंवा कोड स्वयंचलितपणे रिफॅक्टर करा.
• कोड तयार करा: टेम्पलेट्स किंवा इतर इनपुटवर आधारित सुरवातीपासून नवीन कोड तयार करा.

हे API प्रगत विकास साधने तयार करण्यासाठी आवश्यक आहे जे कोडची गुणवत्ता सुधारतात, पुनरावृत्ती होणारी कार्ये स्वयंचलित करतात आणि डेव्हलपरची उत्पादकता वाढवतात.

ॲबस्ट्रॅक्ट सिंटॅक्स ट्री (AST) समजून घेणे

AST हे तुमच्या कोडच्या रचनेचे एक वृक्षासारखे (tree-like) प्रतिनिधित्व आहे. ट्रीमधील प्रत्येक नोड व्हेरिएबल डिक्लेरेशन, फंक्शन कॉल किंवा कंट्रोल फ्लो स्टेटमेंट यासारख्या वाक्यात्मक रचनेचे प्रतिनिधित्व करतो. TypeScript कंपाइलर API हे AST मधून फिरण्यासाठी, त्याचे नोड्स तपासण्यासाठी आणि त्यात बदल करण्यासाठी साधने पुरवते.

हा सोपा TypeScript कोड विचारात घ्या:

function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(greet("World"));

या कोडसाठी AST फंक्शन डिक्लेरेशन, रिटर्न स्टेटमेंट, टेम्पलेट लिटरल, console.log कॉल आणि कोडच्या इतर घटकांचे प्रतिनिधित्व करेल. AST चे व्हिज्युअलायझेशन करणे आव्हानात्मक असू शकते, परंतु AST एक्सप्लोरर (astexplorer.net) सारखी साधने मदत करू शकतात. ही साधने तुम्हाला कोड प्रविष्ट करण्याची आणि त्याचे संबंधित AST वापरकर्त्यासाठी अनुकूल स्वरूपात पाहण्याची परवानगी देतात. AST एक्सप्लोरर वापरल्याने तुम्हाला कोणत्या प्रकारच्या कोड स्ट्रक्चरमध्ये फेरफार करायचा आहे हे समजण्यास मदत होईल.

मुख्य AST नोड प्रकार

TypeScript कंपाइलर API विविध AST नोड प्रकार परिभाषित करते, प्रत्येक भिन्न वाक्यात्मक रचनेचे प्रतिनिधित्व करतो. येथे काही सामान्य नोड प्रकार आहेत:

• SourceFile: संपूर्ण TypeScript फाईलचे प्रतिनिधित्व करते.
• FunctionDeclaration: फंक्शनच्या व्याख्येचे प्रतिनिधित्व करते.
• VariableDeclaration: व्हेरिएबलच्या डिक्लेरेशनचे प्रतिनिधित्व करते.
• Identifier: आयडेंटिफायरचे (उदा., व्हेरिएबलचे नाव, फंक्शनचे नाव) प्रतिनिधित्व करते.
• StringLiteral: स्ट्रिंग लिटरलचे प्रतिनिधित्व करते.
• CallExpression: फंक्शन कॉलचे प्रतिनिधित्व करते.
• ReturnStatement: रिटर्न स्टेटमेंटचे प्रतिनिधित्व करते.

प्रत्येक नोड प्रकारात असे गुणधर्म असतात जे संबंधित कोड घटकाबद्दल माहिती देतात. उदाहरणार्थ, `FunctionDeclaration` नोडमध्ये त्याचे नाव, पॅरामीटर्स, रिटर्न प्रकार आणि बॉडीसाठी गुणधर्म असू शकतात.

कंपाइलर API सह प्रारंभ करणे

कंपाइलर API वापरण्यास प्रारंभ करण्यासाठी, तुम्हाला TypeScript इंस्टॉल करणे आणि TypeScript सिंटॅक्सची मूलभूत माहिती असणे आवश्यक आहे. येथे एक सोपे उदाहरण आहे जे TypeScript फाईल कशी वाचायची आणि त्याचे AST कसे प्रिंट करायचे हे दर्शवते:

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015, // Target ECMAScript version
  true // SetParentNodes: true to retain parent references in the AST
);

function printAST(node: ts.Node, indent = 0) {
  const indentStr = "  ".repeat(indent);
  console.log(`${indentStr}${ts.SyntaxKind[node.kind]}`);

  node.forEachChild(child => printAST(child, indent + 1));
}

printAST(sourceFile);

स्पष्टीकरण:

1. मॉड्यूल्स इम्पोर्ट करा: `typescript` मॉड्यूल आणि फाईल सिस्टम ऑपरेशन्ससाठी `fs` मॉड्यूल इम्पोर्ट करते.
2. सोर्स फाईल वाचा: `example.ts` नावाच्या TypeScript फाईलची सामग्री वाचते. हे काम करण्यासाठी तुम्हाला एक `example.ts` फाईल तयार करावी लागेल.
3. SourceFile तयार करा: एक `SourceFile` ऑब्जेक्ट तयार करते, जे AST च्या मूळ (root) चे प्रतिनिधित्व करते. `ts.createSourceFile` फंक्शन सोर्स कोड पार्स करते आणि AST तयार करते.
4. AST प्रिंट करा: एक रिकर्सिव्ह फंक्शन `printAST` परिभाषित करते जे AST मधून फिरते आणि प्रत्येक नोडचा प्रकार प्रिंट करते.
5. printAST कॉल करा: रूट `SourceFile` नोडमधून AST प्रिंट करणे सुरू करण्यासाठी `printAST` ला कॉल करते.

हा कोड चालवण्यासाठी, तो `.ts` फाईल म्हणून सेव्ह करा (उदा., `ast-example.ts`), काही TypeScript कोडसह `example.ts` फाईल तयार करा आणि नंतर कोड कंपाइल करून चालवा:

tsc ast-example.ts
node ast-example.js

हे तुमच्या `example.ts` फाईलचे AST कन्सोलवर प्रिंट करेल. आउटपुट नोड्सची श्रेणी आणि त्यांचे प्रकार दर्शवेल. उदाहरणार्थ, ते `FunctionDeclaration`, `Identifier`, `Block` आणि इतर नोड प्रकार दर्शवू शकते.

AST मधून फिरणे (Traversing)

कंपाइलर API AST मधून फिरण्यासाठी अनेक मार्ग प्रदान करते. सर्वात सोपा मार्ग म्हणजे `forEachChild` पद्धत वापरणे, जसे मागील उदाहरणात दाखवले आहे. ही पद्धत दिलेल्या नोडच्या प्रत्येक चाइल्ड नोडला भेट देते.

अधिक जटिल ट्रॅव्हर्सल परिस्थितींसाठी, तुम्ही `Visitor` पॅटर्न वापरू शकता. व्हिजिटर एक ऑब्जेक्ट आहे जो विशिष्ट नोड प्रकारांसाठी कॉल केल्या जाणार्‍या पद्धती परिभाषित करतो. हे तुम्हाला ट्रॅव्हर्सल प्रक्रिया सानुकूलित करण्यास आणि नोड प्रकारावर आधारित क्रिया करण्यास अनुमती देते.

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

class IdentifierVisitor {
  visit(node: ts.Node) {
    if (ts.isIdentifier(node)) {
      console.log(`Found identifier: ${node.text}`);
    }

    ts.forEachChild(node, n => this.visit(n));
  }
}

const visitor = new IdentifierVisitor();
visitor.visit(sourceFile);

स्पष्टीकरण:

1. IdentifierVisitor क्लास: `visit` पद्धतीसह `IdentifierVisitor` नावाचा क्लास परिभाषित करतो.
2. Visit पद्धत: `visit` पद्धत तपासते की वर्तमान नोड `Identifier` आहे का. जर असेल, तर ते आयडेंटिफायरचा मजकूर प्रिंट करते. त्यानंतर चाइल्ड नोड्सला भेट देण्यासाठी ते रिकर्सिव्हली `ts.forEachChild` ला कॉल करते.
3. व्हिजिटर तयार करा: `IdentifierVisitor` चा एक इन्स्टन्स तयार करते.
4. ट्रॅव्हर्सल सुरू करा: ट्रॅव्हर्सल सुरू करण्यासाठी `SourceFile` वर `visit` पद्धत कॉल करते.

हे उदाहरण AST मधील सर्व आयडेंटिफायर्स कसे शोधायचे हे दर्शवते. तुम्ही इतर नोड प्रकार शोधण्यासाठी आणि भिन्न क्रिया करण्यासाठी हा पॅटर्न वापरू शकता.

AST चे रूपांतर करणे (Transforming)

कंपाइलर API ची खरी शक्ती AST चे रूपांतर करण्याच्या क्षमतेमध्ये आहे. तुम्ही तुमच्या कोडची रचना आणि वर्तन बदलण्यासाठी AST मध्ये बदल करू शकता. कोड रिफॅक्टरिंग टूल्स, कोड जनरेटर्स आणि इतर प्रगत टूलिंगचा हा आधार आहे.

AST चे रूपांतर करण्यासाठी, तुम्हाला `ts.transform` फंक्शन वापरावे लागेल. हे फंक्शन एक `SourceFile` आणि `TransformerFactory` फंक्शन्सची यादी घेते. `TransformerFactory` एक फंक्शन आहे जे `TransformationContext` घेते आणि `Transformer` फंक्शन परत करते. `Transformer` फंक्शन AST मधील नोड्सला भेट देण्यास आणि त्यांचे रूपांतर करण्यास जबाबदार आहे.

येथे एक सोपे उदाहरण आहे जे TypeScript फाईलच्या सुरुवातीला एक कमेंट कशी जोडायची हे दर्शवते:

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

const transformerFactory: ts.TransformerFactory = context => {
  return transformer => {
    return node => {
      if (ts.isSourceFile(node)) {
        // Create a leading comment
        const comment = ts.addSyntheticLeadingComment(
          node,
          ts.SyntaxKind.MultiLineCommentTrivia,
          " This file was automatically transformed ",
          true // hasTrailingNewLine
        );

        return node;
      }

      return node;
    };
  };
};

const { transformed } = ts.transform(sourceFile, [transformerFactory]);

const printer = ts.createPrinter({
  newLine: ts.NewLineKind.LineFeed
});

const result = printer.printFile(transformed[0]);

fs.writeFileSync("example.transformed.ts", result);

स्पष्टीकरण:

1. TransformerFactory: एक `TransformerFactory` फंक्शन परिभाषित करते जे `Transformer` फंक्शन परत करते.
2. ट्रान्सफॉर्मर: `Transformer` फंक्शन तपासते की वर्तमान नोड `SourceFile` आहे का. जर असेल, तर ते `ts.addSyntheticLeadingComment` वापरून नोडमध्ये एक लीडिंग कमेंट जोडते.
3. ts.transform: `SourceFile` वर रूपांतरण लागू करण्यासाठी `ts.transform` ला कॉल करते.
4. प्रिंटर: रूपांतरित AST मधून कोड तयार करण्यासाठी एक `Printer` ऑब्जेक्ट तयार करते.
5. प्रिंट आणि लिहा: रूपांतरित कोड प्रिंट करते आणि त्याला `example.transformed.ts` नावाच्या नवीन फाईलमध्ये लिहिते.

हे उदाहरण एक साधे रूपांतरण दर्शवते, परंतु तुम्ही कोड रिफॅक्टर करणे, लॉगिंग स्टेटमेंट्स जोडणे किंवा डॉक्युमेंटेशन तयार करणे यासारखी अधिक जटिल रूपांतरणे करण्यासाठी समान पॅटर्न वापरू शकता.

प्रगत रूपांतरण तंत्र

येथे काही प्रगत रूपांतरण तंत्र आहेत जे तुम्ही कंपाइलर API सह वापरू शकता:

• नवीन नोड्स तयार करणे: नवीन AST नोड्स तयार करण्यासाठी `ts.createXXX` फंक्शन्स वापरा. उदाहरणार्थ, `ts.createVariableDeclaration` एक नवीन व्हेरिएबल डिक्लेरेशन नोड तयार करते.
• नोड्स बदलणे: `ts.visitEachChild` फंक्शन वापरून विद्यमान नोड्सला नवीन नोड्ससह बदला.
• नोड्स जोडणे: `ts.updateXXX` फंक्शन्स वापरून AST मध्ये नवीन नोड्स जोडा. उदाहरणार्थ, `ts.updateBlock` नवीन स्टेटमेंट्ससह ब्लॉक स्टेटमेंट अपडेट करते.
• नोड्स काढून टाकणे: ट्रान्सफॉर्मर फंक्शनमधून `undefined` परत करून AST मधून नोड्स काढून टाका.

कोड जनरेशन

AST चे रूपांतर केल्यानंतर, तुम्हाला त्यातून कोड तयार करावा लागेल. कंपाइलर API या उद्देशासाठी एक `Printer` ऑब्जेक्ट प्रदान करते. `Printer` एक AST घेतो आणि कोडचे स्ट्रिंग प्रतिनिधित्व तयार करतो.

ts.createPrinter` फंक्शन एक `Printer` ऑब्जेक्ट तयार करते. तुम्ही प्रिंटरला विविध पर्यायांसह कॉन्फिगर करू शकता, जसे की वापरण्यासाठी न्यूलाइन कॅरॅक्टर आणि कमेंट्स एमिट करायच्या की नाही.

printer.printFile` पद्धत `SourceFile` घेते आणि कोडचे स्ट्रिंग प्रतिनिधित्व परत करते. तुम्ही नंतर ही स्ट्रिंग फाईलमध्ये लिहू शकता.

कंपाइलर API चे व्यावहारिक उपयोग

TypeScript कंपाइलर API चे सॉफ्टवेअर डेव्हलपमेंटमध्ये असंख्य व्यावहारिक उपयोग आहेत. येथे काही उदाहरणे आहेत:

• लिंटर्स: कोडिंग मानके लागू करण्यासाठी आणि तुमच्या कोडमधील संभाव्य समस्या ओळखण्यासाठी कस्टम लिंटर्स तयार करा.
• कोड फॉर्मेटर्स: तुमच्या कोडला विशिष्ट शैली मार्गदर्शिकेनुसार स्वयंचलितपणे फॉरमॅट करण्यासाठी कोड फॉर्मेटर्स तयार करा.
• स्टॅटिक ॲनालायझर्स: तुमच्या कोडमधील बग, सुरक्षा भेद्यता आणि कार्यप्रदर्शन अडथळे शोधण्यासाठी स्टॅटिक ॲनालायझर्स विकसित करा.
• कोड जनरेटर्स: टेम्पलेट्स किंवा इतर इनपुटमधून कोड तयार करा, पुनरावृत्ती होणारी कार्ये स्वयंचलित करा आणि बॉयलरप्लेट कोड कमी करा. उदाहरणार्थ, वर्णन फाईलमधून API क्लायंट किंवा डेटाबेस स्कीमा तयार करणे.
• रिफॅक्टरिंग टूल्स: व्हेरिएबल्सचे नाव बदलण्यासाठी, फंक्शन्स काढण्यासाठी किंवा फाईल्समध्ये कोड हलवण्यासाठी स्वयंचलितपणे रिफॅक्टरिंग टूल्स तयार करा.
• आंतरराष्ट्रीयीकरण (i18n) ऑटोमेशन: तुमच्या TypeScript कोडमधून भाषांतर करण्यायोग्य स्ट्रिंग्स स्वयंचलितपणे काढा आणि वेगवेगळ्या भाषांसाठी लोकलायझेशन फाईल्स तयार करा. उदाहरणार्थ, एखादे साधन `translate()` फंक्शनला पास केलेल्या स्ट्रिंग्ससाठी कोड स्कॅन करू शकते आणि त्यांना स्वयंचलितपणे भाषांतर रिसोर्स फाईलमध्ये जोडू शकते.

उदाहरण: एक साधा लिंटर तयार करणे

चला एक साधा लिंटर तयार करूया जो TypeScript कोडमधील न वापरलेल्या व्हेरिएबल्सची तपासणी करतो. हा लिंटर अशा व्हेरिएबल्सना ओळखेल जे घोषित केले आहेत परंतु कधीही वापरले नाहीत.

import * as ts from "typescript";
import * as fs from "fs";

const fileName = "example.ts";
const sourceCode = fs.readFileSync(fileName, "utf8");

const sourceFile = ts.createSourceFile(
  fileName,
  sourceCode,
  ts.ScriptTarget.ES2015,
  true
);

function findUnusedVariables(sourceFile: ts.SourceFile) {
  const usedVariables = new Set();

  function visit(node: ts.Node) {
    if (ts.isIdentifier(node)) {
      usedVariables.add(node.text);
    }

    ts.forEachChild(node, visit);
  }

  visit(sourceFile);

  const unusedVariables: string[] = [];

  function checkVariableDeclaration(node: ts.Node) {
    if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
      const variableName = node.name.text;
      if (!usedVariables.has(variableName)) {
        unusedVariables.push(variableName);
      }
    }

    ts.forEachChild(node, checkVariableDeclaration);
  }

  checkVariableDeclaration(sourceFile);

  return unusedVariables;
}

const unusedVariables = findUnusedVariables(sourceFile);

if (unusedVariables.length > 0) {
  console.log("Unused variables:");
  unusedVariables.forEach(variable => console.log(`- ${variable}`));
} else {
  console.log("No unused variables found.");
}

स्पष्टीकरण:

1. findUnusedVariables फंक्शन: `findUnusedVariables` नावाचे फंक्शन परिभाषित करते जे `SourceFile` इनपुट म्हणून घेते.
2. usedVariables सेट: वापरलेल्या व्हेरिएबल्सची नावे संग्रहित करण्यासाठी एक `Set` तयार करते.
3. visit फंक्शन: एक रिकर्सिव्ह फंक्शन `visit` परिभाषित करते जे AST मधून फिरते आणि सर्व आयडेंटिफायर्सची नावे `usedVariables` सेटमध्ये जोडते.
4. checkVariableDeclaration फंक्शन: एक रिकर्सिव्ह फंक्शन `checkVariableDeclaration` परिभाषित करते जे व्हेरिएबल डिक्लेरेशन न वापरलेले आहे की नाही हे तपासते. जर असेल, तर ते व्हेरिएबलचे नाव `unusedVariables` ॲरेमध्ये जोडते.
5. unusedVariables परत करा: न वापरलेल्या व्हेरिएबल्सची नावे असलेली एक ॲरे परत करते.
6. आउटपुट: न वापरलेल्या व्हेरिएबल्सना कन्सोलवर प्रिंट करते.

हे उदाहरण एक साधा लिंटर दर्शवते. तुम्ही इतर कोडिंग मानकांची तपासणी करण्यासाठी आणि तुमच्या कोडमधील इतर संभाव्य समस्या ओळखण्यासाठी ते वाढवू शकता. उदाहरणार्थ, तुम्ही न वापरलेले इम्पोर्ट्स, जास्त क्लिष्ट फंक्शन्स किंवा संभाव्य सुरक्षा भेद्यता तपासू शकता. मुख्य गोष्ट म्हणजे AST मधून कसे फिरायचे आणि तुम्हाला ज्या विशिष्ट नोड प्रकारांमध्ये स्वारस्य आहे ते कसे ओळखायचे हे समजून घेणे.

सर्वोत्तम पद्धती आणि विचार

• AST समजून घ्या: AST ची रचना समजून घेण्यासाठी वेळ द्या. तुमच्या कोडचे AST व्हिज्युअलाइज करण्यासाठी AST एक्सप्लोरर सारख्या साधनांचा वापर करा.
• टाईप गार्ड्स वापरा: तुम्ही योग्य नोड प्रकारांसह काम करत आहात याची खात्री करण्यासाठी टाईप गार्ड्स (`ts.isXXX`) वापरा.
• कार्यक्षमतेचा विचार करा: AST रूपांतरणे संगणकीय दृष्ट्या महाग असू शकतात. तुम्ही भेट देत असलेल्या आणि रूपांतरित करत असलेल्या नोड्सची संख्या कमी करण्यासाठी तुमचा कोड ऑप्टिमाइझ करा.
• त्रुटी हाताळा: त्रुटी योग्यरित्या हाताळा. तुम्ही AST वर अवैध ऑपरेशन्स करण्याचा प्रयत्न केल्यास कंपाइलर API अपवाद टाकू शकते.
• संपूर्णपणे चाचणी करा: तुमच्या रूपांतरणांची संपूर्णपणे चाचणी करा जेणेकरून ते इच्छित परिणाम देतात आणि नवीन बग्स तयार करत नाहीत याची खात्री होईल.
• विद्यमान लायब्ररी वापरा: कंपाइलर API वर उच्च-स्तरीय ॲबस्ट्रॅक्शन्स प्रदान करणार्‍या विद्यमान लायब्ररी वापरण्याचा विचार करा. या लायब्ररी सामान्य कार्ये सोपी करू शकतात आणि तुम्हाला लिहाव्या लागणाऱ्या कोडचे प्रमाण कमी करू शकतात. उदाहरणांमध्ये `ts-morph` आणि `typescript-eslint` यांचा समावेश आहे.

निष्कर्ष

TypeScript कंपाइलर API हे प्रगत विकास साधने तयार करण्यासाठी एक शक्तिशाली साधन आहे. AST सह कसे काम करायचे हे समजून घेऊन, तुम्ही लिंटर्स, कोड फॉर्मेटर्स, स्टॅटिक ॲनालायझर्स आणि इतर साधने तयार करू शकता जे कोडची गुणवत्ता सुधारतात, पुनरावृत्ती होणारी कार्ये स्वयंचलित करतात आणि डेव्हलपरची उत्पादकता वाढवतात. API जरी क्लिष्ट असले तरी, त्यात प्रभुत्व मिळवण्याचे फायदे लक्षणीय आहेत. हे सर्वसमावेशक मार्गदर्शक तुम्हाला तुमच्या प्रकल्पांमध्ये कंपाइलर API प्रभावीपणे शोधण्यासाठी आणि वापरण्यासाठी एक पाया प्रदान करते. AST एक्सप्लोरर सारख्या साधनांचा फायदा घेणे, नोड प्रकार काळजीपूर्वक हाताळणे आणि तुमच्या रूपांतरणांची संपूर्णपणे चाचणी करणे लक्षात ठेवा. सराव आणि समर्पणाने, तुम्ही TypeScript कंपाइलर API ची पूर्ण क्षमता अनलॉक करू शकता आणि सॉफ्टवेअर डेव्हलपमेंटच्या क्षेत्रात नाविन्यपूर्ण उपाय तयार करू शकता.

पुढील अन्वेषण:

• TypeScript कंपाइलर API डॉक्युमेंटेशन: [https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API](https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API)
• AST एक्सप्लोरर: [https://astexplorer.net/](https://astexplorer.net/)
• ts-morph लायब्ररी: [https://ts-morph.com/](https://ts-morph.com/)
• typescript-eslint: [https://typescript-eslint.io/](https://typescript-eslint.io/)