Template Compilation

/**
 * Compiles template source to executable JavaScript string
 * @param source - Dust template source code
 * @param name - Optional template name for registration and error reporting
 * @returns String of compiled JavaScript code
 * @throws SyntaxError with location information for invalid template syntax
 */
function compile(source: string, name?: string): string;

const dust = require('dustjs-linkedin');

// Basic template compilation
const source = 'Hello {name}! Welcome to {site}.';
const compiled = dust.compile(source, 'greeting');
console.log(compiled);
// Output: JavaScript function string

// Load and use compiled template
dust.loadSource(compiled);
dust.render('greeting', { name: 'Alice', site: 'My Site' }, (err, output) => {
  console.log(output); // "Hello Alice! Welcome to My Site."
});

// Complex template with sections and conditionals
const complexSource = `
{#users}
  <div class="user {?active}active{/active}">
    <h3>{name}</h3>
    {#email}<p>Email: {email}</p>{/email}
    {^email}<p>No email provided</p>{/email}
  </div>
{/users}
{^users}
  <p>No users found</p>
{/users}
`;

try {
  const compiledComplex = dust.compile(complexSource, 'user-list');
  dust.loadSource(compiledComplex);
} catch (err) {
  console.error('Compilation error:', err.message);
  console.error('Location:', err.location);
}

/**
 * Compiles template and returns executable function
 * @param source - Dust template source code
 * @param name - Optional template name
 * @returns Executable template function
 * @throws SyntaxError with location information for invalid template syntax
 */
function compileFn(source: string, name?: string): TemplateFunction;

// Compile to function directly
const templateFn = dust.compileFn('Goodbye {name}!', 'farewell');

// Use template function directly
dust.render(templateFn, { name: 'Bob' }, (err, output) => {
  console.log(output); // "Goodbye Bob!"
});

// Template function can be registered manually
dust.register('my-farewell', templateFn);
dust.render('my-farewell', { name: 'Charlie' }, console.log);

// Template functions have special properties
console.log(templateFn.__dustBody); // true
console.log(templateFn.templateName); // 'farewell' (if provided)

/**
 * Complete compiler instance with all compilation methods
 */
const compiler: {
  compile(source: string, name?: string): string;
  filterNode(context: any, node: ASTNode): ASTNode;
  optimizers: OptimizerMap;
  pragmas: PragmaMap;
  compileNode(context: any, node: ASTNode): string;
  nodes: NodeHandlerMap;
};

interface OptimizerMap {
  body: (context: any, node: ASTNode) => ASTNode;
  buffer: (context: any, node: ASTNode) => ASTNode;
  format: (context: any, node: ASTNode) => ASTNode;
  reference: (context: any, node: ASTNode) => ASTNode;
  section: (context: any, node: ASTNode) => ASTNode;
  exists: (context: any, node: ASTNode) => ASTNode;
  notexists: (context: any, node: ASTNode) => ASTNode;
  block: (context: any, node: ASTNode) => ASTNode;
  partial: (context: any, node: ASTNode) => ASTNode;
  helper: (context: any, node: ASTNode) => ASTNode;
  [key: string]: (context: any, node: ASTNode) => ASTNode;
}

interface NodeHandlerMap {
  body: (context: any, node: ASTNode) => string;
  buffer: (context: any, node: ASTNode) => string;
  format: (context: any, node: ASTNode) => string;
  reference: (context: any, node: ASTNode) => string;
  section: (context: any, node: ASTNode) => string;
  exists: (context: any, node: ASTNode) => string;
  notexists: (context: any, node: ASTNode) => string;
  block: (context: any, node: ASTNode) => string;
  partial: (context: any, node: ASTNode) => string;
  helper: (context: any, node: ASTNode) => string;
  [key: string]: (context: any, node: ASTNode) => string;
}

interface PragmaMap {
  [pragmaName: string]: (compiler: any, context: any, bodies: any, params: any) => any;
}

// Direct compiler access
const ast = dust.parse('Hello {name}!');
const optimizedAst = dust.compiler.filterNode({}, ast);
const compiledCode = dust.compiler.compileNode({}, optimizedAst);

// Custom node optimization
const customOptimizer = (context, node) => {
  // Custom AST transformation logic
  return node;
};

// Extend compiler with custom optimizer
dust.compiler.optimizers.customType = customOptimizer;

// Deprecated - use dust.compiler.filterNode instead
function filterNode(context: any, node: ASTNode): ASTNode;

// Deprecated - use dust.compiler.optimizers instead
const optimizers: OptimizerMap;

// Deprecated - use dust.compiler.pragmas instead
const pragmas: PragmaMap;

// Deprecated - use dust.compiler.compileNode instead
function compileNode(context: any, node: ASTNode): string;

// Deprecated - use dust.compiler.nodes instead
const nodes: NodeHandlerMap;

interface TemplateFunction {
  /** Main template execution function */
  (chunk: Chunk, context: Context): Chunk;

  /** Always true for template functions */
  __dustBody: true;

  /** Template name when registered */
  templateName?: string;
}

const templateFn = dust.compileFn('Hello {name}!', 'greeting');

// Check if function is a template
console.log(templateFn.__dustBody); // true
console.log(dust.isTemplateFn(templateFn)); // true

// Template name property
console.log(templateFn.templateName); // 'greeting'

// Templates registered in cache get their name set
dust.register('my-template', templateFn);
console.log(dust.cache['my-template'].templateName); // 'my-template'

// Whitespace preservation
dust.config.whitespace = true; // Preserve whitespace in templates

// AMD module generation
dust.config.amd = true; // Generate AMD-compatible modules

// CommonJS module generation
dust.config.cjs = true; // Generate CommonJS-compatible modules

try {
  const compiled = dust.compile('{invalid syntax}', 'test-template');
} catch (err) {
  console.log(err.name); // 'SyntaxError'
  console.log(err.message); // Detailed error message
  console.log(err.location); // Location object with start/end positions

  // Location includes: { start: { offset, line, column }, end: { offset, line, column } }
  if (err.location) {
    console.log(`Error at line ${err.location.start.line}, column ${err.location.start.column}`);
  }
}

// Template name is included in error messages for debugging
try {
  const compiled = dust.compile('{#unclosed', 'my-template');
} catch (err) {
  console.log(err.message); // Includes '[my-template:1:10]' location info
}

// Parse template to AST
const source = 'Hello {name}!';
const ast = dust.parse(source);

// Apply custom AST transformations
const transformedAst = dust.compiler.filterNode({}, ast);

// Compile AST to executable code
const code = dust.compiler.compileNode({}, transformedAst);

// Load the compiled code
const templateFn = dust.loadSource(code);

// Configure for AMD modules
dust.config.amd = true;
const amdTemplate = dust.compile('Hello {name}!', 'greeting');
// Generated code will be AMD-compatible

// Configure for CommonJS modules
dust.config.cjs = true;
const cjsTemplate = dust.compile('Hello {name}!', 'greeting');
// Generated code will be CommonJS-compatible

// Reset to default behavior
dust.config.amd = false;
dust.config.cjs = false;