@linkiez/dxf-renew 5.3.1

package/src/handlers/entity/hatch.ts

@@ -0,0 +1,471 @@
+import type { DXFTuple, HatchEntity, HatchLoop, HatchSeed } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'HATCH'
+
+let status: 'IDLE' | 'POLYLINE' | 'SEED' | 'ENT' | 'SPLINE' = 'IDLE'
+let drawEntity: any = {}
+let drawType = 0
+let isPolyline = false
+let seed: HatchSeed | null = null
+let loop: HatchLoop = { references: [], entities: [] }
+let polyPoint: any = null
+
+export const process = (tuples: DXFTuple[]): HatchEntity => {
+  status = 'IDLE'
+  drawEntity = {}
+  drawType = 0
+  isPolyline = false
+  seed = null
+  loop = { references: [], entities: [] }
+  polyPoint = null
+
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 100:
+          status = 'IDLE'
+          break
+        case 2:
+          entity.patternName = value
+          break
+        case 10:
+          if (status === 'IDLE') {
+            entity.elevation ??= { x: 0, y: 0, z: 0 }
+            entity.elevation.x = Number.parseFloat(String(value))
+          }
+          else if (status === 'POLYLINE') {
+            polyPoint = {
+              x: Number.parseFloat(String(value)),
+              y: 0,
+              bulge: 0,
+            }
+            loop.entities[0].points.push(polyPoint)
+          } else if (status === 'SEED') {
+            if (!seed) {
+              seed = { x: 0, y: 0 }
+              entity.seeds ??= { count: 0, seeds: [] }
+              entity.seeds.seeds.push(seed)
+            }
+            seed.x = Number.parseFloat(String(value))
+          } else fillDrawEntity(type, drawType, Number.parseFloat(String(value)))
+          break
+        case 20:
+          if (status === 'IDLE') {
+            entity.elevation ??= { x: 0, y: 0, z: 0 }
+            entity.elevation.y = Number.parseFloat(String(value))
+          }
+          else if (status === 'POLYLINE') polyPoint.y = Number.parseFloat(String(value))
+          else if (status === 'SEED') {
+            if (seed) seed.y = Number.parseFloat(String(value))
+            seed = null
+          } else fillDrawEntity(type, drawType, Number.parseFloat(String(value)))
+          break
+        case 30:
+          entity.elevation ??= { x: 0, y: 0, z: 0 }
+          entity.elevation.z = Number.parseFloat(String(value))
+          break
+        case 63:
+          entity.fillColor = value
+          break
+        case 70:
+          entity.fillType = Number.parseFloat(String(value)) === 1 ? 'SOLID' : 'PATTERN'
+          break
+        case 210:
+          entity.extrusionDir ??= { x: 0, y: 0, z: 1 }
+          entity.extrusionDir.x = Number.parseFloat(String(value))
+          break
+        case 220:
+          entity.extrusionDir ??= { x: 0, y: 0, z: 1 }
+          entity.extrusionDir.y = Number.parseFloat(String(value))
+          break
+        case 230:
+          entity.extrusionDir ??= { x: 0, y: 0, z: 1 }
+          entity.extrusionDir.z = Number.parseFloat(String(value))
+          break
+        case 91:
+          // LOOP COUNT
+          entity.boundary ??= { count: 0, loops: [] }
+          entity.boundary.count = Number.parseFloat(String(value))
+          break
+        case 92:
+          // 0 = Default; 1 = External; 2 = Polyline; 4 = Derived; 8 = Textbox; 16 = Outermost
+          loop = { references: [], entities: [] }
+          entity.boundary ??= { count: 0, loops: [] }
+          entity.boundary.loops.push(loop)
+          loop.type = Number.parseFloat(String(value))
+          isPolyline = (loop.type & 2) === 2
+          if (isPolyline) {
+            const ent = {
+              type: 'POLYLINE',
+              points: [],
+            }
+            loop.entities.push(ent)
+            status = 'POLYLINE'
+          }
+          break
+        case 93:
+          if (status === 'IDLE') status = 'ENT'
+          loop.count = Number.parseFloat(String(value))
+          break
+        case 11:
+        case 21:
+        case 40:
+        case 50:
+        case 51:
+        case 74:
+        case 94:
+        case 95:
+        case 96:
+          if (drawType === 4) status = 'SPLINE'
+          fillDrawEntity(type, drawType, Number.parseFloat(String(value)))
+          break
+        case 42:
+          if (isPolyline) polyPoint.bulge = Number.parseFloat(String(value))
+          else fillDrawEntity(type, drawType, Number.parseFloat(String(value)))
+          break
+        case 72:
+          // !Polyline --> 1 = Line; 2 = Circular arc; 3 = Elliptic arc; 4 = Spline
+          // Polyline -->  hasBulge
+          drawType = Number.parseFloat(String(value))
+          loop[isPolyline ? 'hasBulge' : 'edgeType'] = drawType
+          if (!isPolyline) {
+            drawEntity = createDrawEntity(drawType)
+            loop.entities.push(drawEntity)
+          }
+          break
+        case 73:
+          if (status === 'IDLE' || isPolyline) loop.entities[0].closed = value
+          else fillDrawEntity(type, drawType, Number.parseFloat(String(value)))
+          break
+        case 75:
+          // END OF BOUNDARY PATH DATA
+          status = 'IDLE'
+
+          // 0 = Hatch "odd parity" area (Normal style)
+          // 1 = Hatch outermost area only (Outer style)
+          // 2 = Hatch through entire area (Ignore style)
+          entity.style = Number.parseFloat(String(value))
+          break
+        case 76:
+          // 0 = User-defined; 1 = Predefined; 2 = Custom
+          entity.hatchType = Number.parseFloat(String(value))
+          break
+        case 97:
+          status = 'IDLE'
+          isPolyline = false
+          loop.sourceObjects = Number.parseFloat(String(value))
+          break
+        case 98:
+          status = 'SEED'
+          entity.seeds ??= { count: 0, seeds: [] }
+          entity.seeds.count = Number.parseFloat(String(value))
+          break
+        case 52:
+          entity.shadowPatternAngle = Number.parseFloat(String(value))
+          break
+        case 41:
+          entity.spacing = Number.parseFloat(String(value))
+          break
+        case 77:
+          entity.double = Number.parseFloat(String(value)) === 1
+          break
+        case 78:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.lineCount = Number.parseFloat(String(value))
+          break
+        case 53:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.angle = Number.parseFloat(String(value))
+          break
+        case 43:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.x = Number.parseFloat(String(value))
+          break
+        case 44:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.y = Number.parseFloat(String(value))
+          break
+        case 45:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.offsetX = Number.parseFloat(String(value))
+          break
+        case 46:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.offsetY = Number.parseFloat(String(value))
+          break
+        case 79:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.dashCount = Number.parseFloat(String(value))
+          break
+        case 49:
+          entity.pattern ??= { lineCount: 0, angle: 0, x: 0, y: 0, offsetX: 0, offsetY: 0, dashCount: 0, length: [] }
+          entity.pattern.length.push(value)
+          break
+        case 330:
+          loop.references.push(value)
+          break
+        case 450:
+          entity.solidOrGradient =
+            Number.parseFloat(String(value)) === 0 ? 'SOLID' : 'GRADIENT'
+          break
+        case 453:
+          // 0 = Solid; 2 = Gradient
+          entity.color ??= { count: 0, rotation: 0, gradient: 0, tint: 0 }
+          entity.color.count = Number.parseFloat(String(value))
+          break
+        case 460:
+          entity.color ??= { count: 0, rotation: 0, gradient: 0, tint: 0 }
+          entity.color.rotation = value
+          break
+        case 461:
+          entity.color ??= { count: 0, rotation: 0, gradient: 0, tint: 0 }
+          entity.color.gradient = value
+          break
+        case 462:
+          entity.color ??= { count: 0, rotation: 0, gradient: 0, tint: 0 }
+          entity.color.tint = value
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      elevation: { x: 0, y: 0, z: 0 },
+      extrusionDir: { x: 0, y: 0, z: 1 },
+      pattern: {
+        lineCount: 0,
+        angle: 0,
+        x: 0,
+        y: 0,
+        offsetX: 0,
+        offsetY: 0,
+        dashCount: 0,
+        length: []
+      },
+      boundary: {
+        count: 0,
+        loops: []
+      },
+      seeds: {
+        count: 0,
+        seeds: []
+      },
+      color: {
+        count: 0,
+        rotation: 0,
+        gradient: 0,
+        tint: 0
+      },
+    } as HatchEntity,
+  )
+}
+
+export default { TYPE, process }
+
+/**
+ * Creates a draw entity based on edge type
+ *
+ * @param type - Edge type (1=Line, 2=Arc, 3=Ellipse, 4=Spline)
+ * @returns Draw entity object
+ */
+function createDrawEntity(type: number): any {
+  if (isPolyline) return {}
+
+  // 1 = Line; 2 = Circular arc; 3 = Elliptic arc; 4 = Spline
+  switch (type) {
+    case 1:
+      return {
+        type: 'LINE',
+        start: { x: 0, y: 0 },
+        end: { x: 0, y: 0 },
+      }
+    case 2:
+      return {
+        type: 'ARC',
+        center: { x: 0, y: 0 },
+        radius: 0,
+        startAngle: 0,
+        endAngle: 0,
+        counterClockWise: false,
+      }
+    case 3:
+      return {
+        type: 'ELLIPSE',
+        center: { x: 0, y: 0 },
+        startAngle: 0,
+        endAngle: 0,
+        counterClockWise: false,
+        major: { x: 0, y: 0 },
+        minor: 0,
+      }
+    case 4:
+      return {
+        type: 'SPLINE',
+        degree: 0,
+        rational: 0,
+        periodic: 0,
+        knots: { count: 0, knots: [] },
+        controlPoints: { count: 0, points: [] },
+        weights: 1,
+      }
+  }
+
+  return {}
+}
+
+/**
+ * Fills properties of a draw entity based on DXF code, draw type, and value
+ *
+ * @param type - DXF group code
+ * @param drawType - Entity draw type (1=Line, 2=Arc, 3=Ellipse, 4=Spline)
+ * @param value - Value to set
+ */
+function fillDrawEntity(type: number, drawType: number, value: number): void {
+  switch (type) {
+    case 10:
+      switch (drawType) {
+        case 1:
+          drawEntity.start.x = value
+          break
+        case 2:
+          drawEntity.center.x = value
+          break
+        case 3:
+          drawEntity.center.x = value
+          break
+        case 4:
+          drawEntity.controlPoints.points.push({ x: value, y: 0 })
+          break
+      }
+      break
+    case 20:
+      switch (drawType) {
+        case 1:
+          {
+            drawEntity.start.y = value
+          }
+          break
+        case 2:
+          {
+            drawEntity.center.y = value
+          }
+          break
+        case 3:
+          {
+            drawEntity.center.y = value
+          }
+          break
+        case 4:
+          {
+            drawEntity.controlPoints.points[
+              drawEntity.controlPoints.points.length - 1
+            ].y = value
+          }
+          break
+      }
+      break
+    case 11:
+      switch (drawType) {
+        case 1:
+          drawEntity.end.x = value
+          break
+        case 3:
+          drawEntity.major.x = value
+          break
+      }
+      break
+    case 21:
+      switch (drawType) {
+        case 1:
+          drawEntity.end.y = value
+          break
+        case 3:
+          drawEntity.major.y = value
+          break
+      }
+      break
+    case 40:
+      switch (drawType) {
+        case 2:
+          drawEntity.radius = value
+          break
+        case 3:
+          drawEntity.minor = value
+          break
+        case 4:
+          drawEntity.knots.knots.push(value)
+          break
+      }
+      break
+    case 42:
+      if (drawType === 4) {
+        drawEntity.weights = value
+      }
+      break
+    case 50:
+      switch (drawType) {
+        case 2:
+        case 3:
+          drawEntity.startAngle = value
+          break
+      }
+      break
+    case 51:
+      switch (drawType) {
+        case 2:
+        case 3:
+          drawEntity.endAngle = value
+          break
+      }
+      break
+    case 73:
+      {
+        switch (drawType) {
+          case 2:
+            {
+              drawEntity.counterClockWise = Number.parseFloat(String(value)) === 1
+            }
+            break
+          case 3:
+            {
+              drawEntity.counterClockWise = Number.parseFloat(String(value)) === 1
+            }
+            break
+          case 4:
+            {
+              drawEntity.rational = value
+            }
+            break
+        }
+      }
+      break
+    case 74:
+      if (drawType === 4) {
+        drawEntity.periodic = value
+      }
+      break
+    case 94:
+      if (drawType === 4) {
+        drawEntity.degree = value
+      }
+      break
+    case 95:
+      if (drawType === 4) {
+        drawEntity.knots.count = value
+      }
+      break
+    case 96:
+      if (drawType === 4) {
+        drawEntity.controlPoints.count = value
+      }
+      break
+  }
+}

package/src/handlers/entity/insert.ts

@@ -0,0 +1,73 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+import type { InsertEntity } from '../../types'
+
+export const TYPE = 'INSERT'
+
+
+export const process = (tuples: DXFTuple[]): InsertEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 2:
+          entity.block = value as string
+          break
+        case 10:
+          entity.x = value as number
+          break
+        case 20:
+          entity.y = value as number
+          break
+        case 30:
+          entity.z = value as number
+          break
+        case 41:
+          entity.scaleX = value as number
+          break
+        case 42:
+          entity.scaleY = value as number
+          break
+        case 43:
+          entity.scaleZ = value as number
+          break
+        case 44:
+          entity.columnSpacing = value as number
+          break
+        case 45:
+          entity.rowSpacing = value as number
+          break
+        case 50:
+          entity.rotation = value as number
+          break
+        case 70:
+          entity.columnCount = value as number
+          break
+        case 71:
+          entity.rowCount = value as number
+          break
+        case 210:
+          entity.extrusionX = value as number
+          break
+        case 220:
+          entity.extrusionY = value as number
+          break
+        case 230:
+          entity.extrusionZ = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+    } as InsertEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/line.ts

@@ -0,0 +1,56 @@
+import type { DXFTuple, PartialPoint3D } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'LINE'
+
+interface LineEntity {
+  type: typeof TYPE
+  start: PartialPoint3D
+  end: PartialPoint3D
+  thickness?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): LineEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          entity.start.x = value as number
+          break
+        case 20:
+          entity.start.y = value as number
+          break
+        case 30:
+          entity.start.z = value as number
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        case 11:
+          entity.end.x = value as number
+          break
+        case 21:
+          entity.end.y = value as number
+          break
+        case 31:
+          entity.end.z = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      start: {},
+      end: {},
+    } as LineEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/lwpolyline.ts

@@ -0,0 +1,54 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+import type { Point3D, PolylineEntity } from '../../types'
+
+export const TYPE = 'LWPOLYLINE'
+
+
+interface PolylineVertex extends Point3D {
+  bulge?: number
+}
+
+export const process = (tuples: DXFTuple[]): PolylineEntity => {
+  let vertex: PolylineVertex | undefined
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 70:
+          entity.closed = ((value as number) & 1) === 1
+          break
+        case 10:
+          vertex = {
+            x: value as number,
+            y: 0,
+          } as PolylineVertex
+          entity.vertices.push(vertex)
+          break
+        case 20:
+          if (vertex) vertex.y = value as number
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        case 42:
+          // Bulge (multiple entries; one entry for each vertex)  (optional; default = 0).
+          if (vertex) vertex.bulge = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      vertices: [],
+    } as PolylineEntity,
+  )
+}
+
+export default { TYPE, process }