@linkiez/dxf-renew 5.3.1

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@linkiez/dxf-renew",
+  "version": "5.3.1",
+  "description": "DXF parser for node/browser",
+  "type": "module",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.cjs"
+    }
+  },
+  "packageManager": "yarn@4.12.0",
+  "bin": {
+    "dxf-to-svg": "lib/cli.js"
+  },
+  "engines": {
+    "node": ">=8.9.0"
+  },
+  "scripts": {
+    "compile:ts": "tsc",
+    "compile": "node build.mjs",
+    "build": "npm run compile",
+    "watch": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "dist": "esbuild src/index.ts --bundle --platform=browser --format=iife --global-name=dxf --outfile=dist/dxf.js",
+    "lint": "eslint src",
+    "clean": "rimraf dist/ lib/",
+    "prepublishOnly": "npm run lint && npm run type-check && npm run test && npm run clean && npm run build && npm run dist",
+    "prettier": "prettier --write .",
+    "test": "npm run test:unit",
+    "test:functional": "cd test/functional && webpack-dev-server",
+    "test:unit": "mocha --require tsx --recursive test/unit/** --extensions .ts,.js",
+    "test:unit:watch": "npm run test:unit -- --watch",
+    "prepare": "husky",
+    "semantic-release": "semantic-release",
+    "commit": "git-cz"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/skymakerolof/dxf.git"
+  },
+  "keywords": [
+    "DXF",
+    "Parser",
+    "SVG"
+  ],
+  "author": "Ben Nortier <ben@bjnortier.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/skymakerolof/dxf/issues"
+  },
+  "homepage": "https://github.com/skymakerolof/dxf",
+  "devDependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/eslint-parser": "^7.25.1",
+    "@babel/preset-react": "^7.28.5",
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@types/babel__core": "^7",
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "browserify": "^16.5.2",
+    "commitizen": "^4.3.1",
+    "cz-conventional-changelog": "^3.3.0",
+    "esbuild": "^0.27.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^8.10.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-config-standard-react": "^13.0.0",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "eslint-plugin-react": "^7.35.0",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "expect": "^29.7.0",
+    "husky": "^9.1.7",
+    "mocha": "^10.7.3",
+    "prettier": "^3.3.3",
+    "prop-types": "^15.8.1",
+    "raw-loader": "^4.0.2",
+    "react": "^16.14.0",
+    "react-dom": "^16.14.0",
+    "react-router-dom": "^5.3.4",
+    "rimraf": "^6.0.1",
+    "semantic-release": "^25.0.2",
+    "standard-version": "^9.5.0",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "webpack": "^5.94.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^4.15.2",
+    "xml2js": "^0.6.2"
+  },
+  "dependencies": {
+    "commander": "^2.20.3",
+    "lodash": "^4.17.21",
+    "vecks": "^3.9.2"
+  },
+  "config": {
+    "commitizen": {
+      "path": "cz-conventional-changelog"
+    }
+  },
+  "standard": {
+    "globals": [
+      "describe",
+      "it",
+      "before",
+      "beforeEach",
+      "after"
+    ],
+    "ignore": [
+      "lib/",
+      "dist/"
+    ]
+  }
+}

package/src/Helper.ts

@@ -0,0 +1,71 @@
+import denormalise from './denormalise'
+import groupEntitiesByLayer from './groupEntitiesByLayer'
+import parseString from './parseString'
+import toPolylines from './toPolylines'
+import toSVG from './toSVG'
+import logger from './util/logger'
+
+import type { Entity, LayerGroups, ParsedDXF } from './types'
+
+export default class Helper {
+  private readonly _contents: string
+  private _parsed: ParsedDXF | null
+  private _denormalised: Entity[] | null
+  private _groups: LayerGroups | null
+
+  constructor(contents: string) {
+    if (typeof contents !== 'string') {
+      throw new TypeError('Helper constructor expects a DXF string')
+    }
+    this._contents = contents
+    this._parsed = null
+    this._denormalised = null
+    this._groups = null
+  }
+
+  parse(): ParsedDXF {
+    this._parsed = parseString(this._contents)
+    logger.info('parsed:', this.parsed)
+    return this._parsed
+  }
+
+  get parsed(): ParsedDXF {
+    if (this._parsed === null) {
+      this.parse()
+    }
+    return this._parsed as ParsedDXF
+  }
+
+  denormalise(): Entity[] {
+    this._denormalised = denormalise(this.parsed)
+    logger.info('denormalised:', this._denormalised)
+    return this._denormalised
+  }
+
+  get denormalised(): Entity[] {
+    if (!this._denormalised) {
+      this.denormalise()
+    }
+    return this._denormalised as Entity[]
+  }
+
+  group(): LayerGroups {
+    this._groups = groupEntitiesByLayer(this.denormalised)
+    return this._groups
+  }
+
+  get groups(): LayerGroups {
+    if (!this._groups) {
+      this.group()
+    }
+    return this._groups as LayerGroups
+  }
+
+  toSVG(): string {
+    return toSVG(this.parsed)
+  }
+
+  toPolylines(): ReturnType<typeof toPolylines> {
+    return toPolylines(this.parsed)
+  }
+}

package/src/applyTransforms.ts

@@ -0,0 +1,54 @@
+/**
+ * Apply the transforms to the polyline.
+ *
+ * @param polyline the polyline
+ * @param transforms the transforms array
+ * @returns the transformed polyline
+ */
+
+import type { PointTuple, Transform } from './types'
+
+type Point = PointTuple
+
+export default function applyTransforms(
+  polyline: Point[],
+  transforms?: Transform[],
+): Point[] {
+  if (!transforms) {
+    return polyline
+  }
+
+  let result = polyline
+  for (const transform of transforms) {
+    result = result.map((p) => {
+      // Use a copy to avoid side effects
+      let p2: Point = [p[0], p[1]]
+      if (transform.scaleX) {
+        p2[0] = p2[0] * transform.scaleX
+      }
+      if (transform.scaleY) {
+        p2[1] = p2[1] * transform.scaleY
+      }
+      if (transform.rotation) {
+        const angle = (transform.rotation / 180) * Math.PI
+        p2 = [
+          p2[0] * Math.cos(angle) - p2[1] * Math.sin(angle),
+          p2[1] * Math.cos(angle) + p2[0] * Math.sin(angle),
+        ]
+      }
+      if (transform.x) {
+        p2[0] = p2[0] + transform.x
+      }
+      if (transform.y) {
+        p2[1] = p2[1] + transform.y
+      }
+      // Observed once in a sample DXF - some cad applications
+      // use negative extruxion Z for flipping
+      if (transform.extrusionZ === -1) {
+        p2[0] = -p2[0]
+      }
+      return p2
+    })
+  }
+  return result
+}

package/src/cli.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { Command } from 'commander'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+
+import { denormalise, groupEntitiesByLayer, parseString, toSVG } from './'
+
+const require = createRequire(
+  typeof __filename === 'string' ? __filename : import.meta.url,
+)
+const { version } = require('../package.json')
+
+const program = new Command()
+
+program
+  .version(version)
+  .description('Converts a dxf file to a svg file.')
+  .arguments('<dxfFile> [svgFile]')
+  .option('-v --verbose', 'Verbose output')
+  .action((dxfFile: string, svgFile: string | undefined, options: { verbose?: boolean }) => {
+    const parsed = parseString(fs.readFileSync(dxfFile, 'utf-8'))
+
+    if (options.verbose) {
+      const groups = groupEntitiesByLayer(denormalise(parsed))
+      console.log('[layer : number of entities]')
+      for (const layer of Object.keys(groups)) {
+        console.log(`${layer} : ${groups[layer].length}`)
+      }
+    }
+
+    fs.writeFileSync(
+      svgFile || `${dxfFile.split('.').slice(0, -1).join('.')}.svg`,
+      toSVG(parsed),
+      'utf-8',
+    )
+  })
+  .parse(process.argv)
+
+if (!process.argv.slice(2).length) {
+  program.help()
+}

package/src/config.ts

@@ -0,0 +1,10 @@
+import type { Config } from './types'
+
+const config: Config = {
+  verbose: false,
+  interpolationsPerSplineSegment: 100,
+  layers: [],
+}
+
+export default config
+

package/src/constants.ts

@@ -0,0 +1,14 @@
+import type { ZeroTransform } from './types'
+
+export const ZERO_TRANSFORM: ZeroTransform = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1,
+  scaleZ: 1,
+  rotation: 0,
+  extrusionX: 0,
+  extrusionY: 0,
+  extrusionZ: 1,
+}
+

package/src/denormalise.ts

@@ -0,0 +1,153 @@
+import cloneDeep from 'lodash/cloneDeep'
+
+import logger from './util/logger'
+
+import type {
+  ArcEntity,
+  Block,
+  CircleEntity,
+  EllipseEntity,
+  Entity,
+  InsertEntity,
+  LineEntity,
+  ParsedDXF,
+  PolylineEntity,
+  SplineEntity,
+  Transform,
+} from './types'
+
+export default function denormalise(parseResult: ParsedDXF): Entity[] {
+  const blocksByName = parseResult.blocks.reduce(
+    (acc: { [name: string]: Block }, b: Block) => {
+      acc[b.name] = b
+      return acc
+    },
+    {},
+  )
+
+  const gatherEntities = (
+    entities: Entity[],
+    transforms: Transform[],
+  ): Entity[] => {
+    let current: Entity[] = []
+    for (const e of entities) {
+      if (e.type === 'INSERT') {
+        const insert = e as InsertEntity
+        const block = blocksByName[insert.block]
+        if (!block) {
+          logger.error('no block found for insert. block:', insert.block)
+          continue
+        }
+
+        const rowCount = insert.rowCount ?? 1
+        const columnCount = insert.columnCount ?? 1
+        const rowSpacing = insert.rowSpacing ?? 0
+        const columnSpacing = insert.columnSpacing ?? 0
+        const rotation = insert.rotation ?? 0
+
+        // It appears that the rectangular array is affected by rotation, but NOT by scale.
+        let rowVec: { x: number; y: number }
+        let colVec: { x: number; y: number }
+        if (rowCount > 1 || columnCount > 1) {
+          const cos = Math.cos((rotation * Math.PI) / 180)
+          const sin = Math.sin((rotation * Math.PI) / 180)
+          rowVec = { x: -sin * rowSpacing, y: cos * rowSpacing }
+          colVec = { x: cos * columnSpacing, y: sin * columnSpacing }
+        } else {
+          rowVec = { x: 0, y: 0 }
+          colVec = { x: 0, y: 0 }
+        }
+
+        // For rectangular arrays, add the block entities for each location in the array
+        for (let r = 0; r < rowCount; r++) {
+          for (let c = 0; c < columnCount; c++) {
+            // Adjust insert transform by row and column for rectangular arrays
+            const t: Transform = {
+              x: insert.x + rowVec.x * r + colVec.x * c,
+              y: insert.y + rowVec.y * r + colVec.y * c,
+              scaleX: insert.scaleX,
+              scaleY: insert.scaleY,
+              scaleZ: insert.scaleZ,
+              extrusionX: insert.extrusionX,
+              extrusionY: insert.extrusionY,
+              extrusionZ: insert.extrusionZ,
+              rotation: insert.rotation,
+            }
+            // Add the insert transform and recursively add entities
+            const transforms2 = transforms.slice(0)
+            transforms2.push(t)
+
+            // Use the insert layer
+            const blockEntities = block.entities.map((be: Entity) => {
+              const be2 = cloneDeep(be)
+              be2.layer = insert.layer
+              // https://github.com/bjnortier/dxf/issues/52
+              // See Issue 52. If we don't modify the
+              // entity coordinates here it creates an issue with the
+              // transformation matrices (which are only applied AFTER
+              // block insertion modifications has been applied).
+              switch (be2.type) {
+                case 'LINE': {
+                  const line = be2 as LineEntity
+                  line.start.x -= block.x
+                  line.start.y -= block.y
+                  line.end.x -= block.x
+                  line.end.y -= block.y
+                  break
+                }
+                case 'LWPOLYLINE':
+                case 'POLYLINE': {
+                  const poly = be2 as PolylineEntity
+                  for (const v of poly.vertices) {
+                    if (v.x !== undefined) v.x -= block.x
+                    if (v.y !== undefined) v.y -= block.y
+                  }
+                  break
+                }
+                case 'CIRCLE': {
+                  const circle = be2 as CircleEntity
+                  circle.x -= block.x
+                  circle.y -= block.y
+                  break
+                }
+                case 'ELLIPSE': {
+                  const ellipse = be2 as EllipseEntity
+                  ellipse.x -= block.x
+                  ellipse.y -= block.y
+                  break
+                }
+                case 'ARC': {
+                  const arc = be2 as ArcEntity
+                  arc.x -= block.x
+                  arc.y -= block.y
+                  break
+                }
+                case 'SPLINE': {
+                  const spline = be2 as SplineEntity
+                  for (const cp of spline.controlPoints) {
+                    cp.x -= block.x
+                    cp.y -= block.y
+                  }
+                  break
+                }
+              }
+              return be2
+            })
+            current = current.concat(gatherEntities(blockEntities, transforms2))
+          }
+        }
+      } else {
+        // Top-level entity. Clone and add the transforms
+        // The transforms are reversed so they occur in
+        // order of application - i.e. the transform of the
+        // top-level insert is applied last
+        const e2 = cloneDeep(e)
+        e2.transforms = transforms.slice().reverse()
+        current.push(e2)
+      }
+    }
+    return current
+  }
+
+  return gatherEntities(parseResult.entities, [])
+}