Command Line Interface

# Basic command syntax
dustc [options] [path1 [path2 path3...]]

# Installation provides global binary
npm install dustjs-linkedin
# Binary available at: node_modules/.bin/dustc

# Compile single template
dustc templates/user.dust

# Compile multiple templates
dustc templates/header.dust templates/footer.dust templates/main.dust

# Compile all templates in directory
dustc templates/*.dust

# Use glob patterns
dustc templates/**/*.dust

# Template naming
-n, --name <string>         # Template name for single file compilation

# Output control
-o, --output <path>         # Concatenate all output to this file
-s, --split                 # Create separate output files per input

# Path handling
--pwd <string>              # Base directory for template names

# Formatting
-w, --whitespace           # Preserve whitespace in templates

# Module formats
-a, --amd                  # Output AMD modules
--cjs                      # Output CommonJS modules (auto-enables --split)

# Development
--watch                    # Watch files for changes and recompile

# Compile with custom name
dustc -n "greeting" templates/hello.dust

# Concatenate multiple files
dustc --output=compiled.js templates/*.dust

# Create separate output files
dustc --split templates/*.dust

# Set base directory for template names
dustc --pwd=templates templates/user/*.dust

# Preserve whitespace
dustc -w templates/formatted.dust

# Generate AMD modules
dustc -a --split templates/*.dust

# Generate CommonJS modules (automatically splits)
dustc --cjs templates/*.dust

# Watch for changes during development
dustc --watch --split templates/**/*.dust

# Read from stdin
echo "Hello {name}!" | dustc -n "greeting"

# Pipe from other commands
cat template.dust | dustc -n "template"

# No template name (creates anonymous template)
echo "{message}" | dustc

# Compile template from stdin
echo "Welcome {user.name}!" | dustc -n "welcome" > welcome.js

# Process template through pipeline
curl https://templates.example.com/header.dust | dustc -n "header" -a > header-amd.js

# Batch processing with build tools
find templates -name "*.dust" -exec cat {} \; | dustc -n "combined"

# Default output format
dustc templates/example.dust

# Produces JavaScript like:
# (function(){dust.register("example",body_0);function body_0(chk,ctx){...}})();

# Compile to default format
dustc templates/user-profile.dust > user-profile.js

# Load in Node.js
dust.loadSource(fs.readFileSync('user-profile.js', 'utf8'));

# Load in browser
<script src="user-profile.js"></script>

# Generate AMD modules
dustc -a templates/*.dust

# Produces AMD modules like:
# define("dust-template-name", ["dust"], function(dust) {
#   dust.register("template-name", body_0);
#   function body_0(chk,ctx){...}
#   return "template-name";
# });

# Generate AMD modules with split output
dustc -a --split templates/*.dust

# Use with RequireJS
require(['dust-template-user'], function(templateName) {
  dust.render(templateName, userData, callback);
});

# Build system integration
dustc -a --output=dist/templates.js src/templates/**/*.dust

# Generate CommonJS modules (automatically enables --split)
dustc --cjs templates/*.dust

# Produces CommonJS modules like:
# var dust = require("dustjs-linkedin");
# dust.register("template-name", body_0);
# function body_0(chk,ctx){...}
# module.exports = "template-name";

# Generate CommonJS modules
dustc --cjs templates/*.dust

# Use in Node.js
const templateName = require('./templates/user.js');
dust.render(templateName, userData, callback);

# Use with bundlers (Webpack, Browserify)
const userTemplate = require('./templates/user.js');

# Enable file watching
dustc --watch [other-options] templates/**/*.dust

# Watch with specific output configuration
dustc --watch --split --output-dir=compiled templates/*.dust

# Watch and recompile on changes
dustc --watch --split templates/**/*.dust

# Watch with AMD output
dustc --watch -a --split templates/*.dust

# Development server integration
dustc --watch --cjs --output=dist/templates/ src/templates/**/*.dust &
node server.js

# Automatic naming rules:
# templates/user/profile.dust -> "user/profile"
# src/views/header.dust -> "views/header"
# main.dust -> "main"

# Control base path with --pwd
dustc --pwd=templates templates/user/profile.dust
# Results in template name: "user/profile"

dustc --pwd=src src/views/header.dust
# Results in template name: "views/header"

# Default naming (includes directory structure)
dustc templates/components/header.dust
# Template name: "templates/components/header"

# Set base directory
dustc --pwd=templates templates/components/header.dust
# Template name: "components/header"

# Single file with explicit name
dustc -n "app-header" templates/components/header.dust
# Template name: "app-header"

# Single template with custom name
dustc -n "custom-name" template.dust

# Note: --name only works with single input file
# For multiple files, use --pwd to control automatic naming

# Makefile integration
templates: $(DUST_FILES)
	dustc --split --output-dir=dist/templates/ src/templates/**/*.dust

# NPM scripts
{
  "scripts": {
    "build:templates": "dustc --cjs --split src/templates/**/*.dust",
    "dev:templates": "dustc --watch --cjs --split src/templates/**/*.dust",
    "build": "npm run build:templates && webpack"
  }
}

# Gulp integration
gulp.task('templates', () => {
  return exec('dustc --amd --split src/templates/**/*.dust');
});

# Webpack integration (as npm script)
"prebuild": "dustc --cjs --split src/templates/**/*.dust"

# GitHub Actions
- name: Compile Dust templates
  run: |
    dustc --cjs --split src/templates/**/*.dust
    ls -la templates/

# Docker build
RUN npm install dustjs-linkedin && \
    dustc --cjs --split templates/**/*.dust && \
    rm -rf node_modules

# Production build script
#!/bin/bash
set -e
echo "Compiling Dust templates..."
dustc --amd --output=dist/templates.js src/templates/**/*.dust
echo "Templates compiled successfully"

# Syntax errors include file and line information
dustc templates/broken.dust
# Error: Template syntax error in templates/broken.dust:5:12
# Expected closing tag but found EOF

# Missing file errors
dustc non-existent.dust
# Error: ENOENT: no such file or directory, open 'non-existent.dust'

# Use Node.js DEBUG environment variable
DEBUG=dust dustc templates/*.dust

# Enable verbose logging
NODE_ENV=development dustc templates/*.dust

# Check compiled output
dustc templates/test.dust && cat test.js

# Issue: Templates not found at runtime
# Solution: Ensure template names match registration
dustc --pwd=templates templates/user.dust  # Creates "user" template
dust.render("user", data, callback);       # Correct reference

# Issue: Module format compatibility
# Solution: Match output format to usage environment
dustc --cjs templates/*.dust              # For Node.js/bundlers
dustc --amd templates/*.dust              # For RequireJS
dustc templates/*.dust                    # For direct browser loading

# Issue: File watching not working
# Solution: Use glob patterns and check file permissions
dustc --watch "templates/**/*.dust"       # Quote glob patterns

#!/usr/bin/env node

const { exec } = require('child_process');
const fs = require('fs');
const path = require('path');

// Custom build script using dustc
function buildTemplates() {
  const templateDir = 'src/templates';
  const outputDir = 'dist/templates';

  // Ensure output directory exists
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  // Compile templates
  const command = `dustc --cjs --split ${templateDir}/**/*.dust`;

  exec(command, (error, stdout, stderr) => {
    if (error) {
      console.error('Template compilation failed:', error);
      process.exit(1);
    }

    console.log('Templates compiled successfully');
    console.log(stdout);
  });
}

buildTemplates();

# Preprocess templates before compilation
for file in templates/*.dust; do
  # Apply preprocessing (example: variable substitution)
  sed 's/{{VERSION}}/'$VERSION'/g' "$file" > "processed/$(basename $file)"
done

# Compile processed templates
dustc --split processed/*.dust

# Clean up
rm -rf processed/

# Parallel compilation for large projects
find templates -name "*.dust" -print0 | xargs -0 -n 10 -P 4 dustc --split

# Incremental compilation (only changed files)
find templates -name "*.dust" -newer dist/templates.json -exec dustc --split {} +

# Memory optimization for large template sets
NODE_OPTIONS="--max-old-space-size=4096" dustc templates/**/*.dust