## Description
`dwg2dxf-converter` is a highly optimized, professional **libredwg nodejs wrapper** designed to easily **convert dwg file nodejs** applications need to process. It allows you to **convert dwg to dxf node** or **convert dwg to dxf nodejs** formats (compatible with AutoCAD 2000/2004/2018 and higher).
If you are looking for an **open source dwg converter** or a **dwg converter without autocad** to convert **dwg to dxf node** without any heavy native software or cloud APIs on your server, this package is the ultimate production-grade solution.
Built for rigorous production environments, this package is **100% standalone and offline**. It requires no external system dependencies (no need to install LibreDWG, Python, or C++ compilers on the target server). The GNU LibreDWG conversion engine (v0.13.4) is pre-compiled to **WebAssembly (Wasm)**, making it universally compatible (Windows, macOS, Linux) and blazing fast.
## Why dwg2dxf-converter?
| Feature | dwg2dxf-converter | Other solutions |
|---|---|---|
| Zero system dependencies | ✅ | ❌ Requires LibreDWG install |
| Works on Windows/Mac/Linux | ✅ | ⚠️ Often Linux only |
| Powered by WebAssembly | ✅ | ❌ |
| All DWG versions (R12→2018+) | ✅ | ⚠️ Partial |
| Open-source (MIT) | ✅ | ⚠️ Often GPL only |
| TypeScript support | ✅ | ❌ |
## Installation
Simply install via npm (no native configuration required):
```bash
npm install dwg2dxf-converter
```
## Quick Start
Here is a minimal example to convert a file in 5 lines of code:
```javascript
const { convertDwgToDxf } = require('dwg2dxf-converter');
(async () => {
const result = await convertDwgToDxf('./plan.dwg', './plan.dxf');
console.log(result.success ? "Conversion successful!" : "Error:", result.error);
})();
```
### TypeScript / ES Modules
This package includes native, first-class TypeScript typings (`index.d.ts`). You can import and use it in TS / ES Modules directly:
```typescript
import { convertDwgToDxf, ConversionResult } from 'dwg2dxf-converter';
async function main() {
const result: ConversionResult = await convertDwgToDxf('./plan.dwg', './plan.dxf');
if (result.success) {
console.log(`DXF generated successfully. Size: ${result.fileSize} bytes.`);
} else {
console.error(`Conversion failed: ${result.error}`);
}
}
```
## Advanced Usage
### Asynchronous Error and Warning Handling
For complete handling in an asynchronous environment (e.g., a backend API), you can inspect warnings for non-critical elements while still generating a valid DXF file:
```javascript
const { convertDwgToDxf, checkWasm } = require('dwg2dxf-converter');
async function processFile(inputPath, outputPath) {
// 1. Check engine availability
const isReady = await checkWasm();
if (!isReady) throw new Error("Conversion engine is unavailable.");
// 2. Start conversion with a timeout (e.g., 15 seconds)
const result = await convertDwgToDxf(inputPath, outputPath, { timeout: 15000 });
if (!result.success) {
console.error(`❌ Conversion failed: ${result.error}`);
return;
}
console.log(`✅ DXF successfully generated in ${result.duration}ms`);
console.log(`📁 Output file size: ${(result.fileSize / 1024).toFixed(2)} KB`);
// 3. Inspect warnings (non-critical issues)
if (result.warnings) {
console.warn(`⚠️ Conversion completed with warnings:`);
result.warnings.forEach(warning => console.warn(` - ${warning}`));
}
}
processFile('./data/input_constraints.dwg', './data/output.dxf');
```
### Batch Conversion (Multiple Files)
You can convert multiple files at once by passing an array of paths. The batch processor will run the conversions sequentially to keep execution safe, prevent WebAssembly memory spikes, and avoid concurrent file locking.
```javascript
const { convertDwgToDxf } = require('dwg2dxf-converter');
async function batchConvert() {
const inputFiles = ['./plan1.dwg', './plan2.dwg', './plan3.dwg'];
const outputDir = './output_dxf/';
console.log("Starting batch conversion...");
const results = await convertDwgToDxf(inputFiles, outputDir);
results.forEach((result, index) => {
if (result.success) {
console.log(`[${index + 1}] Success: ${result.outputPath}`);
} else {
console.error(`[${index + 1}] Failed converting ${inputFiles[index]}: ${result.error}`);
}
});
}
batchConvert();
```
## CLI Usage
`dwg2dxf-converter` comes with an integrated, zero-dependency command line interface utilizing beautiful, color-coded logging.
### Standard Conversion (Single File)
```bash
npx dwg2dxf-converter input.dwg output.dxf
```
### Batch Conversion (Directory Output)
Convert multiple DWG files into a target directory using the `--batch` or `-b` flag:
```bash
npx dwg2dxf-converter --batch plan1.dwg plan2.dwg -o ./output/
```
### CLI Options
- `-h, --help` : Show help instructions.
- `-v, --version` : Show package version and pre-compiled LibreDWG version.
- `-b, --batch` : Convert multiple files. The last argument (or `-o` path) will be used as the output folder.
- `-o, --output` : Explicitly set the output folder or file path.
- `--timeout ` : Conversion timeout limit in milliseconds per file (default: 30000).
## API Reference
### `convertDwgToDxf(inputPath, outputPath, [options])`
Main asynchronous conversion function.
- `inputPath` *(string | string[])*: Absolute or relative path to the input `.dwg` file (or array of paths for batch conversion).
- `outputPath` *(string)*: Destination path for the generated `.dxf` file (or output directory path for batch conversion).
- `options` *(Object)*:
- `timeout` *(number)*: Maximum time allowed for the conversion in milliseconds per file. Default: `30000` (30s).
**Returns a `Promise
