AST Operations

/**
 * Transform from an existing AST
 * @param {Object} ast - Pre-parsed AST object
 * @param {string} code - Optional source code string (for source maps)
 * @param {Object} opts - Transformation options
 * @returns {Object} Transform result object
 */
function transformFromAst(ast, code, opts);

const babel = require("babel-core");
const babylon = require("babylon");

// Parse code to AST first
const code = "const greeting = () => 'Hello World';";
const ast = babylon.parse(code, { 
  sourceType: "module",
  allowReturnOutsideFunction: true 
});

// Transform from AST
const result = babel.transformFromAst(ast, code, {
  presets: ["es2015"]
});
console.log(result.code); // transformed code
console.log(result.map);  // source map

// Transform AST without original code (no source maps)
const result = babel.transformFromAst(ast, null, {
  presets: ["es2015"],
  sourceMaps: false
});
console.log(result.code); // transformed code

/**
 * Analyze code without generating output
 * @param {string} code - Source code to analyze
 * @param {Object} opts - Analysis options (optional, defaults to {})
 * @param {Object} visitor - Optional visitor object for custom analysis
 * @returns {Object} Metadata object with analysis results
 */
function analyse(code, opts, visitor);

// AnalysisMetadata object structure:
// {
//   usedHelpers: Array<string>,     // Helper functions used
//   marked: Array<Object>,          // Marked nodes
//   modules: {
//     imports: Array<Object>,       // Import declarations found
//     exports: {
//       exported: Array<Object>,    // Export declarations
//       specifiers: Array<Object>   // Export specifiers
//     }
//   }
// }

const babel = require("babel-core");

// Basic analysis
const metadata = babel.analyse(`
  import React from 'react';
  export const MyComponent = () => <div>Hello</div>;
`, {
  presets: ["react"]
});

console.log(metadata.modules.imports);  // Import information
console.log(metadata.modules.exports);  // Export information
console.log(metadata.usedHelpers);      // Helper functions used

// Analysis with custom visitor
const metadata = babel.analyse(`
  function myFunction() {
    const x = 1;
    return x * 2;
  }
`, {}, {
  FunctionDeclaration(path) {
    console.log("Found function:", path.node.id.name);
  },
  VariableDeclarator(path) {
    console.log("Found variable:", path.node.id.name);
  }
});

/**
 * Pipeline class for advanced transformation control
 */
class Pipeline {
  /**
   * Transform code string
   * @param {string} code - Source code
   * @param {Object} opts - Options
   * @returns {Object} Transform result
   */
  transform(code, opts);
  
  /**
   * Transform from AST
   * @param {Object} ast - AST object
   * @param {string} code - Source code
   * @param {Object} opts - Options  
   * @returns {Object} Transform result
   */
  transformFromAst(ast, code, opts);
  
  /**
   * Analyze code
   * @param {string} code - Source code
   * @param {Object} opts - Options
   * @param {Object} visitor - Visitor object
   * @returns {Object} Metadata
   */
  analyse(code, opts, visitor);
  
  /**
   * Lint code (analysis mode)
   * @param {string} code - Source code
   * @param {Object} opts - Options
   * @returns {Object} Lint result
   */
  lint(code, opts);
  
  /**
   * Pre-transform (parse only)
   * @param {string} code - Source code
   * @param {Object} opts - Options
   * @returns {Object} File object
   */
  pretransform(code, opts);
}

// Access pipeline instance
const Pipeline = babel.Pipeline;
const pipeline = new Pipeline();

const babel = require("babel-core");

// Direct pipeline usage
const Pipeline = babel.Pipeline;
const pipeline = new Pipeline();

const result = pipeline.transform("const x = 1;", {
  presets: ["es2015"]
});
console.log(result.code);

// Linting mode (no code generation)
const lintResult = pipeline.lint("const x = 1;", {
  plugins: ["syntax-jsx"]
});
console.log(lintResult.metadata); // Analysis metadata only

/**
 * File class for advanced file processing
 */
class File {
  /**
   * Create new File instance
   * @param {Object} opts - Options
   * @param {Pipeline} pipeline - Pipeline instance
   */
  constructor(opts, pipeline);
  
  /**
   * Perform transformation
   * @returns {Object} Transform result
   */
  transform();
  
  /**
   * Parse code string to AST
   * @param {string} code - Source code
   * @returns {Object} AST
   */
  parse(code);
  
  /**
   * Generate code from AST
   * @returns {Object} Generation result
   */
  generate();
  
  /**
   * Add helper function
   * @param {string} name - Helper name
   * @returns {Object} Helper identifier
   */
  addHelper(name);
  
  /**
   * Add import statement
   * @param {string} source - Import source
   * @param {string} imported - Imported name
   * @param {string} name - Local name (optional)
   * @returns {Object} Import identifier
   */
  addImport(source, imported, name);
  
  /**
   * Wrap transformation with error handling
   * @param {string} code - Source code
   * @param {Function} callback - Transformation callback
   * @returns {Object} Result with error handling
   */
  wrap(code, callback);
}

// Access File class
const File = babel.File;

// Re-exported AST utilities
const types = babel.types;     // babel-types (AST node utilities)
const traverse = babel.traverse; // babel-traverse (AST traversal)
const template = babel.template; // babel-template (AST templates)

const babel = require("babel-core");
const t = babel.types;

// Create AST nodes
const identifier = t.identifier("myVariable");
const literal = t.stringLiteral("Hello World");
const assignment = t.assignmentExpression("=", identifier, literal);

// Check node types
console.log(t.isIdentifier(identifier)); // true
console.log(t.isStringLiteral(literal)); // true

// AST traversal
const code = "function test() { return 42; }";
const ast = babel.transform(code, { code: false }).ast;

babel.traverse(ast, {
  FunctionDeclaration(path) {
    console.log("Function name:", path.node.id.name);
  },
  ReturnStatement(path) {
    console.log("Return value:", path.node.argument.value);
  }
});

// Template usage
const buildRequire = babel.template(`
  var %%importName%% = require(%%source%%);
`);

const requireAst = buildRequire({
  importName: t.identifier("fs"),
  source: t.stringLiteral("fs")
});

// AnalysisOptions object structure:
const analysisOptions = {
  // Core options  
  ast: Boolean,           // Include AST in result (default: true)
  code: Boolean,          // Generate code (default: true for transform, false for analyse)
  
  // Parser configuration
  sourceType: String,     // Parse mode: "script" or "module"
  parserOpts: {
    allowImportExportEverywhere: Boolean,
    allowReturnOutsideFunction: Boolean,
    plugins: Array,         // Parser plugins
    ranges: Boolean,        // Include node ranges
    tokens: Boolean         // Include token information
  },
  
  // Analysis-specific
  plugins: Array,         // Plugins for visitor-based analysis
  presets: Array          // Presets for transformation analysis
};

// Analyze imports and exports
const metadata = babel.analyse(sourceCode, {
  sourceType: "module"
});

metadata.modules.imports.forEach(imp => {
  console.log("Import:", imp.source, imp.specifiers);
});

metadata.modules.exports.exported.forEach(exp => {
  console.log("Export:", exp.name);
});

// Multi-step AST transformation
const babylon = require("babylon");

// 1. Parse
const ast = babylon.parse(code, { sourceType: "module" });

// 2. First transformation
const step1 = babel.transformFromAst(ast, code, {
  plugins: ["transform-es2015-arrow-functions"]
});

// 3. Second transformation on result
const step2 = babel.transformFromAst(step1.ast, step1.code, {
  plugins: ["transform-es2015-classes"]
});

console.log(step2.code); // Final transformed code