@pure-ds/core 0.3.0

package/packages/pds-cli/bin/generate-manifest.js

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+
+/**
+ * Generate Custom Elements Manifest
+ * Creates custom-elements.json with metadata for all PDS components
+ */
+
+import { writeFile, mkdir, readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '../../../');
+
+// Colors for terminal output
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+};
+
+const shouldLogToStderr = () => process.env.PDS_LOG_STREAM === 'stderr' || process.env.PDS_POSTINSTALL === '1';
+const log = (msg, color = 'reset') => {
+  const colorCode = COLORS[color] || '';
+  const text = `${colorCode}${msg}${COLORS.reset}`;
+  if (shouldLogToStderr()) {
+    process.stderr.write(`${text}\n`);
+  } else {
+    console.log(text);
+  }
+};
+
+async function copyBundledManifest(targetDir) {
+  try {
+    const sourceManifest = path.join(repoRoot, 'custom-elements.json');
+    if (!existsSync(sourceManifest)) {
+      log('⚠️  Packaged custom-elements.json not found; skipping manifest copy.', 'yellow');
+      return false;
+    }
+
+    if (targetDir) {
+      await mkdir(targetDir, { recursive: true });
+      const manifestContent = await readFile(sourceManifest, 'utf-8');
+      const manifestTarget = path.join(targetDir, 'custom-elements.json');
+      await writeFile(manifestTarget, manifestContent, 'utf-8');
+      log(`✅ Manifest copied to ${path.relative(process.cwd(), manifestTarget)}`, 'green');
+    } else {
+      log('✅ Packaged custom-elements.json is available', 'green');
+    }
+
+    const packagedVscodeData = path.join(repoRoot, 'public/assets/pds/vscode-custom-data.json');
+    if (targetDir && existsSync(packagedVscodeData)) {
+      const vscodeContent = await readFile(packagedVscodeData, 'utf-8');
+      const vscodeTarget = path.join(targetDir, 'vscode-custom-data.json');
+      await writeFile(vscodeTarget, vscodeContent, 'utf-8');
+      log(`✅ VS Code custom data copied to ${path.relative(process.cwd(), vscodeTarget)}`, 'green');
+    }
+
+    return true;
+  } catch (error) {
+    log(`❌ Failed to copy packaged manifest: ${error?.message || error}`, 'red');
+    return false;
+  }
+}
+
+/**
+ * Convert Custom Elements Manifest to VS Code Custom Data format
+ */
+async function convertToVSCodeFormat(manifest) {
+  const tags = [];
+  
+  // Load icon configuration
+  let availableIcons = [];
+  try {
+    const configPath = path.join(repoRoot, 'src/js/pds-core/pds-config.js');
+    const { presets } = await import(pathToFileURL(configPath).href);
+    
+    // Get icons from default preset
+    const iconConfig = presets?.default?.icons?.include || {};
+    
+    // Extract all icon names from all categories
+    availableIcons = Array.from(new Set(
+      Object.values(iconConfig).flat()
+    )).filter(Boolean).sort();
+    
+    if (availableIcons.length > 0) {
+      log(`🎨 Found ${availableIcons.length} icons in configuration`, 'blue');
+    }
+  } catch (error) {
+    log(`⚠️  Could not load icon configuration: ${error.message}`, 'yellow');
+  }
+  
+  // Load enhancers for data attribute autocomplete
+  let enhancerAttributes = [];
+  try {
+    const pdsPath = path.join(repoRoot, 'src/js/pds.js');
+    const pdsModule = await import(pathToFileURL(pdsPath).href);
+    const enhancers = pdsModule?.PDS?.defaultEnhancers || [];
+    
+    for (const enhancer of enhancers) {
+      // Extract data-* attributes from selectors
+      const selectorMatch = enhancer.selector.match(/\[data-([^\]]+)\]/);
+      if (selectorMatch) {
+        const attrName = `data-${selectorMatch[1]}`;
+        let demoCode = '';
+        
+        // Get demo HTML if available
+        if (enhancer.demoHtml) {
+          try {
+            demoCode = typeof enhancer.demoHtml === 'function' 
+              ? enhancer.demoHtml() 
+              : enhancer.demoHtml;
+            // Clean up the demo code
+            demoCode = demoCode.trim().replace(/\n\s+/g, '\n').replace(/\n{3,}/g, '\n\n');
+          } catch (e) {
+            demoCode = '';
+          }
+        }
+        
+        enhancerAttributes.push({
+          name: attrName,
+          description: enhancer.description || `Progressive enhancement: ${enhancer.selector}`,
+          demoCode: demoCode,
+          selector: enhancer.selector
+        });
+      }
+    }
+    
+    if (enhancerAttributes.length > 0) {
+      log(`🔧 Found ${enhancerAttributes.length} enhancement attributes`, 'blue');
+    }
+  } catch (error) {
+    log(`⚠️  Could not load enhancers: ${error.message}`, 'yellow');
+  }
+  
+  manifest.modules?.forEach(module => {
+    module.declarations?.forEach(declaration => {
+      if (declaration.tagName && declaration.customElement) {
+        const tag = {
+          name: declaration.tagName,
+          description: declaration.description || `${declaration.name} component`
+        };
+        
+        // Add attributes
+        if (declaration.attributes && declaration.attributes.length > 0) {
+          tag.attributes = declaration.attributes.map(attr => {
+            const attribute = {
+              name: attr.name,
+              description: attr.description || ''
+            };
+            
+            // Special handling for pds-icon's icon attribute - add available icon names
+            if (declaration.tagName === 'pds-icon' && attr.name === 'icon' && availableIcons.length > 0) {
+              attribute.values = availableIcons.map(iconName => ({ 
+                name: iconName,
+                description: `${iconName} icon`
+              }));
+            }
+            // Check if type indicates enum values
+            else if (attr.type?.text) {
+              const typeText = attr.type.text;
+              // Match patterns like "bottom" | "top" | "left" | "right"
+              const enumMatch = typeText.match(/"([^"]+)"/g);
+              if (enumMatch && enumMatch.length > 1) {
+                attribute.values = enumMatch.map(val => ({ name: val.replace(/"/g, '') }));
+              }
+            }
+            
+            // Add boolean value set for boolean types
+            if (attr.type?.text === 'boolean') {
+              attribute.valueSet = 'v';
+            }
+            
+            return attribute;
+          });
+        }
+        
+        tags.push(tag);
+      }
+    });
+  });
+  
+  // Build global attributes for data-* enhancements
+  const globalAttributes = enhancerAttributes.map(attr => {
+    const description = attr.demoCode 
+      ? `${attr.description}\n\nExample:\n${attr.demoCode}`
+      : attr.description;
+    
+    return {
+      name: attr.name,
+      description: description,
+      valueSet: 'v' // Boolean-like attributes
+    };
+  });
+  
+  return {
+    version: 1.1,
+    tags,
+    globalAttributes: globalAttributes.length > 0 ? globalAttributes : undefined
+  };
+}
+
+/**
+ * Create pds.html-data.json in project root
+ */
+async function createHtmlDataConfig(vscodeDataPath) {
+  const config = {
+    "html.customData": [vscodeDataPath]
+  };
+  
+  const configPath = path.join(repoRoot, 'pds.html-data.json');
+  await writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  log(`✅ Created pds.html-data.json`, 'green');
+  return configPath;
+}
+
+/**
+ * Reload VS Code window
+ */
+function reloadVSCode() {
+  // Note: Automatic reload would require VS Code extension API
+  // For now, just inform the user to reload manually
+  log('⚠️  Please reload VS Code to activate the updated custom data:', 'yellow');
+  log('   Press Ctrl+Shift+P → "Developer: Reload Window"', 'blue');
+}
+
+/**
+ * Analyze components and generate manifest
+ */
+async function generateManifest(targetDir) {
+  try {
+    log('📋 Generating Custom Elements Manifest...', 'bold');
+    
+    const analyzerInstalled = existsSync(path.join(repoRoot, 'node_modules/@custom-elements-manifest/analyzer'));
+    const runningFromPostinstall = process.env.PDS_POSTINSTALL === '1';
+
+    if (!analyzerInstalled || runningFromPostinstall) {
+      if (!analyzerInstalled) {
+        const color = runningFromPostinstall ? 'blue' : 'yellow';
+        log('ℹ️  Using packaged Custom Elements manifest (analyzer not available).', color);
+        if (!runningFromPostinstall) {
+          log('   Install @custom-elements-manifest/analyzer to enable manifest regeneration.', 'yellow');
+        }
+      } else {
+        log('ℹ️  Skipping analyzer during postinstall; using packaged manifest.', 'blue');
+      }
+      return copyBundledManifest(targetDir);
+    }
+
+    // Run the analyzer
+    const configPath = path.join(repoRoot, 'custom-elements-manifest.config.js');
+    
+    log('🔍 Analyzing components...', 'blue');
+    
+    try {
+      execSync(`npx cem analyze --config ${configPath}`, {
+        cwd: repoRoot,
+        stdio: 'inherit'
+      });
+      
+      // Post-process: Remove private members from the generated manifest
+      const sourceManifest = path.join(repoRoot, 'custom-elements.json');
+      if (existsSync(sourceManifest)) {
+        log('🧹 Cleaning private members from manifest...', 'blue');
+        const manifestContent = await readFile(sourceManifest, 'utf-8');
+        const manifest = JSON.parse(manifestContent);
+        
+        // Filter out private members from all declarations
+        manifest.modules?.forEach(module => {
+          module.declarations?.forEach(declaration => {
+            if (declaration.members) {
+              declaration.members = declaration.members.filter(member => {
+                // Keep only public members (exclude private and those starting with #)
+                return member.privacy !== 'private' && !member.name?.startsWith('#');
+              });
+            }
+          });
+        });
+        
+        // Write cleaned manifest back
+        await writeFile(sourceManifest, JSON.stringify(manifest, null, 2), 'utf-8');
+        log('✅ Private members removed', 'green');
+      }
+      
+      // Copy manifest to target directory if specified
+      if (targetDir) {
+        const targetManifest = path.join(targetDir, 'custom-elements.json');
+        
+        if (existsSync(sourceManifest)) {
+          await mkdir(path.dirname(targetManifest), { recursive: true });
+          const manifestContent = await readFile(sourceManifest, 'utf-8');
+          await writeFile(targetManifest, manifestContent, 'utf-8');
+          log(`✅ Manifest copied to ${path.relative(process.cwd(), targetManifest)}`, 'green');
+        }
+      }
+      
+      log('✅ Custom Elements Manifest generated', 'green');
+      
+      // Step 1: Generate VS Code custom data file
+      log('🔧 Generating VS Code custom data...', 'blue');
+      const manifestContent = await readFile(sourceManifest, 'utf-8');
+      const manifest = JSON.parse(manifestContent);
+      const vscodeData = await convertToVSCodeFormat(manifest);
+      
+      // Write to both locations
+      const vscodeDataPath = path.join(repoRoot, 'public/assets/pds/vscode-custom-data.json');
+      await mkdir(path.dirname(vscodeDataPath), { recursive: true });
+      await writeFile(vscodeDataPath, JSON.stringify(vscodeData, null, 2), 'utf-8');
+      log(`✅ VS Code custom data generated at ${path.relative(repoRoot, vscodeDataPath)}`, 'green');
+      
+      // Also copy to target directory if specified
+      if (targetDir) {
+        const targetVSCodeData = path.join(targetDir, 'vscode-custom-data.json');
+        await writeFile(targetVSCodeData, JSON.stringify(vscodeData, null, 2), 'utf-8');
+        log(`✅ VS Code custom data copied to ${path.relative(process.cwd(), targetVSCodeData)}`, 'green');
+      }
+      
+      // Step 2: Create pds.html-data.json in project root
+      const relativePath = 'public/assets/pds/vscode-custom-data.json';
+      await createHtmlDataConfig(relativePath);
+      
+      // Step 3: Reload VS Code window
+      log('🔄 Reloading VS Code...', 'blue');
+      reloadVSCode();
+      
+      return true;
+    } catch (error) {
+      log(`❌ Manifest generation failed: ${error.message}`, 'red');
+      return false;
+    }
+    
+  } catch (error) {
+    log(`❌ Error: ${error.message}`, 'red');
+    return false;
+  }
+}
+
+export { generateManifest };
+
+// Run if called directly
+if (process.argv[1] && process.argv[1].endsWith('generate-manifest.js')) {
+  const targetDir = process.argv[2] || null;
+  generateManifest(targetDir).then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}

package/packages/pds-cli/bin/pds-build-icons.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * PDS Build Icons CLI
+ *
+ * Rebuilds the SVG sprite (pds-icons.svg) into the consumer app's configured static root.
+ * Output path: [public.root]/icons/pds-icons.svg
+ *
+ * Usage: node node_modules/@pure-ds/core/packages/pds-cli/bin/pds-build-icons.js
+ */
+
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { resolvePublicAssetDirectory, ensurePdsPath } from '../lib/asset-roots.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '../../../');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+};
+const shouldLogToStderr = () => process.env.PDS_LOG_STREAM === 'stderr' || process.env.PDS_POSTINSTALL === '1';
+const log = (msg, color = 'reset') => {
+  const colorCode = COLORS[color] || '';
+  const text = `${colorCode}${msg}${COLORS.reset}`;
+  if (shouldLogToStderr()) {
+    process.stderr.write(`${text}\n`);
+  } else {
+    console.log(text);
+  }
+};
+
+async function loadConsumerConfig() {
+  const cwd = process.cwd();
+  for (const fname of ['pds.config.js', 'pds-config.js']) {
+    const p = path.join(cwd, fname);
+    try { await access(p); } catch { continue; }
+    const mod = await import(pathToFileURL(p).href);
+    return mod.config || mod.default || mod.presets?.default || null;
+  }
+  const internal = await import(pathToFileURL(path.join(repoRoot, 'src/js/pds-core/pds-config.js')).href);
+  return internal.presets?.default || null;
+}
+
+async function fetchText(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.text();
+}
+
+async function fetchIcon(set, name, weight = 'regular', variant = 'outline') {
+  switch (set) {
+    case 'phosphor':
+      return fetchText(`https://unpkg.com/@phosphor-icons/core@2.1.1/assets/${weight}/${name}.svg`);
+    case 'lucide':
+      return fetchText(`https://unpkg.com/lucide-static@latest/icons/${name}.svg`);
+    case 'heroicons':
+      return fetchText(`https://unpkg.com/heroicons@2.0.18/24/${variant}/${name}.svg`);
+    case 'tabler':
+      return fetchText(`https://unpkg.com/@tabler/icons@latest/icons/outline/${name}.svg`);
+    default:
+      throw new Error(`Unknown icon set: ${set}`);
+  }
+}
+
+function svgToSymbol(svgContent, id) {
+  const viewBox = (svgContent.match(/viewBox="([^"]+)"/) || [])[1] || '0 0 256 256';
+  const inner = (svgContent.match(/<svg[^>]*>([\s\S]*?)<\/svg>/) || [])[1] || '';
+  const clean = inner.replace(/fill="[^"]*"/g, 'fill="currentColor"')
+                     .replace(/stroke="[^"]*"/g, 'stroke="currentColor"');
+  return `  <symbol id="${id}" viewBox="${viewBox}">\n${clean.trim().split('\n').map(l=>`    ${l}`).join('\n')}\n  </symbol>`;
+}
+
+async function main() {
+  try {
+    log('\n🎨 PDS Build Icons • starting...', 'bold');
+    const config = await loadConsumerConfig();
+
+    const envRoot = process.env.PDS_STATIC_ROOT;
+    let staticRoot;
+    if (envRoot && typeof envRoot === 'string') {
+      const resolved = path.isAbsolute(envRoot)
+        ? envRoot
+        : path.resolve(process.cwd(), envRoot);
+      staticRoot = ensurePdsPath(resolved);
+    } else {
+      staticRoot = resolvePublicAssetDirectory(config);
+    }
+
+    const outDir = path.join(staticRoot, 'icons');
+    const outFile = path.join(outDir, 'pds-icons.svg');
+
+    // Determine icon set configuration (consumer overrides internal defaults)
+    const internal = await import(pathToFileURL(path.join(repoRoot, 'src/js/pds-core/pds-config.js')).href);
+    const internalIcons = internal.presets?.default?.icons || {};
+    const consumerIcons = config?.icons || {};
+    const set = consumerIcons.set || internalIcons.set || 'phosphor';
+    const weight = consumerIcons.weight || internalIcons.weight || 'regular';
+    const include = consumerIcons.include || internalIcons.include || {};
+
+    const names = Array.from(new Set(Object.values(include).flat()))
+      .filter(Boolean);
+    log(`📦 Icon set: ${set}`, 'blue');
+    if (set === 'phosphor') log(`⚖️  Weight: ${weight}`, 'blue');
+    log(`📝 Total icons: ${names.length}`, 'blue');
+
+    const symbols = [];
+    let ok = 0, fail = 0;
+    for (const name of names) {
+      try {
+        const svg = await fetchIcon(set, name, weight);
+        symbols.push(svgToSymbol(svg, name));
+        ok++; log(`  ✓ ${name}`, 'green');
+      } catch (e) {
+        fail++; log(`  ✗ ${name}: ${e?.message || e}`, 'red');
+      }
+    }
+
+    const sprite = `<?xml version="1.0" encoding="UTF-8"?>\n<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="display:none">\n${symbols.join('\n\n')}\n</svg>\n`;
+
+    await mkdir(outDir, { recursive: true });
+    await writeFile(outFile, sprite, 'utf-8');
+
+    log('\n────────────────────────────────────────────', 'bold');
+    log('✅ Icons sprite built', 'green');
+    log(`📁 Output: ${path.relative(process.cwd(), outFile)}`);
+    log(`✓ ${ok} icons included${fail?`, ✗ ${fail} failed`:''}`);
+    log('────────────────────────────────────────────\n', 'bold');
+  } catch (err) {
+    console.error('❌ pds:build-icons failed:', err?.message || err);
+    process.exit(1);
+  }
+}
+
+// Execute when run directly from Node or via bin entry (including symlinks on macOS/Linux)
+if (process.argv[1]) {
+  const scriptPath = fileURLToPath(import.meta.url);
+  const argPath = process.argv[1];
+  // Check if this is the main module being executed
+  if (argPath === scriptPath || argPath.endsWith('pds-build-icons.js') || argPath.endsWith('pds-build-icons')) {
+    main();
+  }
+}
+
+export { main as runPdsBuildIcons };

package/packages/pds-cli/bin/pds-dx.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * PDS Developer Experience (DX) Script
+ * Runs all IntelliSense and tooling generation:
+ * - Custom Elements Manifest (HTML IntelliSense)
+ * - CSS Custom Data (CSS IntelliSense)
+ * 
+ * This provides complete IDE support for consuming projects
+ */
+
+import { generateManifest } from './generate-manifest.js';
+import { generateCSSData } from './generate-css-data.js';
+
+// Colors for terminal output
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+};
+const log = (msg, color = 'reset') => console.log(`${COLORS[color]}${msg}${COLORS.reset}`);
+
+/**
+ * Run all DX tooling generation
+ */
+async function generateDXTools(targetDir) {
+  try {
+    log('\n╔════════════════════════════════════════════════════════════╗', 'cyan');
+    log('║  🚀 PDS Developer Experience (DX) Tool Generator          ║', 'cyan');
+    log('╚════════════════════════════════════════════════════════════╝\n', 'cyan');
+
+    let allSuccess = true;
+
+    // Step 1: Generate Custom Elements Manifest (HTML IntelliSense)
+    log('┌─────────────────────────────────────────────────────────┐', 'blue');
+    log('│ Step 1: HTML IntelliSense (Custom Elements Manifest)   │', 'blue');
+    log('└─────────────────────────────────────────────────────────┘\n', 'blue');
+    
+    const manifestSuccess = await generateManifest(targetDir);
+    if (!manifestSuccess) {
+      log('⚠️  Custom Elements Manifest generation had issues', 'yellow');
+      allSuccess = false;
+    }
+
+    log('\n'); // Spacing between steps
+
+    // Step 2: Generate CSS Custom Data (CSS IntelliSense)
+    log('┌─────────────────────────────────────────────────────────┐', 'blue');
+    log('│ Step 2: CSS IntelliSense (CSS Custom Data)             │', 'blue');
+    log('└─────────────────────────────────────────────────────────┘\n', 'blue');
+    
+    const cssDataSuccess = await generateCSSData(targetDir);
+    if (!cssDataSuccess) {
+      log('⚠️  CSS custom data generation had issues', 'yellow');
+      allSuccess = false;
+    }
+
+    // Summary
+    log('\n╔════════════════════════════════════════════════════════════╗', allSuccess ? 'green' : 'yellow');
+    log(`║  ${allSuccess ? '✅ All DX Tools Generated Successfully!' : '⚠️  DX Tools Generated with Warnings'}              ║`, allSuccess ? 'green' : 'yellow');
+    log('╚════════════════════════════════════════════════════════════╝\n', allSuccess ? 'green' : 'yellow');
+
+    if (allSuccess) {
+      log('📦 Generated files:', 'bold');
+      log('   HTML: custom-elements.json, vscode-custom-data.json', 'cyan');
+      log('   CSS:  pds.css-data.json, pds-css-complete.json', 'cyan');
+      log('\n💡 VS Code Setup:', 'bold');
+      log('   Add to .vscode/settings.json:', 'blue');
+      log('   {', 'cyan');
+      log('     "html.customData": ["./pds.html-data.json"],', 'cyan');
+      log('     "css.customData": ["./pds.css-data.json"]', 'cyan');
+      log('   }', 'cyan');
+      log('\n🔄 Reload VS Code:', 'bold');
+      log('   Press Ctrl+Shift+P → "Developer: Reload Window"', 'blue');
+    }
+
+    return allSuccess;
+  } catch (error) {
+    log(`\n❌ Fatal error in DX tool generation: ${error.message}`, 'red');
+    console.error(error);
+    return false;
+  }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const targetDir = process.argv[2] || null;
+  
+  if (process.argv.includes('--help') || process.argv.includes('-h')) {
+    log('PDS Developer Experience Tool Generator', 'bold');
+    log('\nUsage:', 'cyan');
+    log('  pds-dx [target-directory]', 'blue');
+    log('\nDescription:', 'cyan');
+    log('  Generates all IntelliSense data for IDE support:', 'blue');
+    log('  - Custom Elements Manifest (HTML autocomplete)', 'blue');
+    log('  - CSS Custom Data (CSS tokens & classes)', 'blue');
+    log('\nExamples:', 'cyan');
+    log('  pds-dx                          # Generate in default location', 'blue');
+    log('  pds-dx public/assets/pds        # Generate in specific directory', 'blue');
+    log('  npm run pds:dx                  # Run via npm script', 'blue');
+    process.exit(0);
+  }
+
+  generateDXTools(targetDir).then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}
+
+export { generateDXTools };