@linkiez/dxf-renew 7.1.0 → 7.2.0

package/src/entityToPolyline.ts

@@ -9,8 +9,13 @@ import type {
   EllipseEntity,
   EntityToPolylineOptions,
   HandlerVertex,
+  LeaderEntity,
   LineEntity,
+  RayEntity,
+  ShapeEntity,
   SplineEntity,
+  WipeoutEntity,
+  XLineEntity,
 } from './types'
 import type { PointTuple } from './types/common'
 
@@ -35,7 +40,17 @@ interface LocalPolylineEntity {
 
 type Entity =
   | LineEntity
+  | LeaderEntity
+  | RayEntity
+  | XLineEntity
+  | ShapeEntity
+  | WipeoutEntity
   | (LocalPolylineEntity & { type: 'LWPOLYLINE' | 'POLYLINE' })
+  | {
+      type: 'SOLID' | 'TRACE'
+      corners?: Array<{ x: number; y: number }>
+      points?: Array<{ x: number; y: number }>
+    }
   | CircleEntity
   | EllipseEntity
   | ArcEntity
@@ -151,7 +166,7 @@ export const interpolateBSpline = (
   return polyline
 }
 
-export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => {
+export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => { // NOSONAR
   const vertices: Array<{ x: number; y: number }> = []
   const faces: Array<{ indices: number[]; hiddens: boolean[] }> = []
 
@@ -219,13 +234,21 @@ export const polyfaceOutline = (entity: LocalPolylineEntity): Point[][] => {
  * the DXF in SVG, Canvas, WebGL etc., without depending on native support
  * of primitive objects (ellispe, spline etc.)
  */
-export default function entityToPolyline(
+export default function entityToPolyline( // NOSONAR
   entity: Entity,
   options?: EntityToPolylineOptions,
 ): Point[] {
   options = options || {}
   let polyline: Point[] | undefined
 
+  const INFINITE_LINE_LENGTH = 1000
+
+  const normalize2 = (x: number, y: number): { x: number; y: number } | null => {
+    const len = Math.hypot(x, y)
+    if (len === 0) return null
+    return { x: x / len, y: y / len }
+  }
+
   if (entity.type === 'LINE') {
     polyline = [
       [entity.start.x, entity.start.y],
@@ -233,6 +256,92 @@ export default function entityToPolyline(
     ]
   }
 
+  if (entity.type === 'LEADER') {
+    if (entity.vertices.length >= 2) {
+      polyline = entity.vertices.map((v) => [v.x, v.y])
+    } else {
+      logger.warn('LEADER entity with insufficient vertices')
+      polyline = []
+    }
+  }
+
+  if (entity.type === 'RAY') {
+    const dir = normalize2(entity.direction.x, entity.direction.y)
+    if (dir === null) {
+      logger.warn('RAY entity with zero direction vector')
+      polyline = []
+    } else {
+      polyline = [
+        [entity.start.x, entity.start.y],
+        [
+          entity.start.x + dir.x * INFINITE_LINE_LENGTH,
+          entity.start.y + dir.y * INFINITE_LINE_LENGTH,
+        ],
+      ]
+    }
+  }
+
+  if (entity.type === 'XLINE') {
+    const dir = normalize2(entity.direction.x, entity.direction.y)
+    if (dir === null) {
+      logger.warn('XLINE entity with zero direction vector')
+      polyline = []
+    } else {
+      polyline = [
+        [
+          entity.basePoint.x - dir.x * INFINITE_LINE_LENGTH,
+          entity.basePoint.y - dir.y * INFINITE_LINE_LENGTH,
+        ],
+        [
+          entity.basePoint.x + dir.x * INFINITE_LINE_LENGTH,
+          entity.basePoint.y + dir.y * INFINITE_LINE_LENGTH,
+        ],
+      ]
+    }
+  }
+
+  if (entity.type === 'SHAPE') {
+    const x = entity.insertionPoint?.x ?? 0
+    const y = entity.insertionPoint?.y ?? 0
+    const size = entity.size ?? 0
+    const scaleX = entity.relativeXScale ?? 1
+    const length = size * scaleX
+    polyline = [
+      [x, y],
+      [x + length, y],
+    ]
+  }
+
+  if (entity.type === 'WIPEOUT') {
+    const verts = entity.clipBoundaryVertices
+    if (!verts || verts.length < 2) {
+      logger.warn('WIPEOUT entity with missing clip boundary vertices')
+      polyline = []
+    } else {
+      const insX = entity.insertionPoint?.x ?? 0
+      const insY = entity.insertionPoint?.y ?? 0
+
+      const ux = entity.uVector?.x ?? 1
+      const uy = entity.uVector?.y ?? 0
+
+      const vx = entity.vVector?.x ?? 0
+      const vy = entity.vVector?.y ?? 1
+
+      polyline = verts.map((p) => [
+        insX + ux * p.x + vx * p.y,
+        insY + uy * p.x + vy * p.y,
+      ])
+
+      if (polyline.length > 0) {
+        const first = polyline[0]
+        const last = polyline[polyline.length - 1]
+        if (first[0] !== last[0] || first[1] !== last[1]) {
+          polyline.push(first)
+        }
+      }
+    }
+  }
+
   if (entity.type === 'LWPOLYLINE' || entity.type === 'POLYLINE') {
     polyline = []
     if (entity.polyfaceMesh) {
@@ -330,6 +439,19 @@ export default function entityToPolyline(
     )
   }
 
+  if (entity.type === 'SOLID' || entity.type === 'TRACE') {
+    const corners = entity.corners ?? entity.points
+    if (corners && corners.length >= 4) {
+      polyline = [
+        [corners[0].x, corners[0].y],
+        [corners[1].x, corners[1].y],
+        [corners[2].x, corners[2].y],
+        [corners[3].x, corners[3].y],
+        [corners[0].x, corners[0].y],
+      ]
+    }
+  }
+
   if (!polyline) {
     logger.warn('unsupported entity for converting to polyline:', entity.type)
     return []

package/src/handlers/entities.ts

@@ -10,7 +10,6 @@ import circle from './entity/circle'
 import dgnUnderlay from './entity/dgnUnderlay'
 import dimension from './entity/dimension'
 import dwfUnderlay from './entity/dwfUnderlay'
-import pdfUnderlay from './entity/pdfUnderlay'
 import ellipse from './entity/ellipse'
 import hatch from './entity/hatch'
 import image from './entity/image'
@@ -18,17 +17,28 @@ import insert from './entity/insert'
 import leader from './entity/leader'
 import line from './entity/line'
 import lwpolyline from './entity/lwpolyline'
+import mleader from './entity/mleader'
+import mline from './entity/mline'
 import mtext from './entity/mtext'
 import ole2Frame from './entity/ole2Frame'
+import oleFrame from './entity/oleframe'
+import pdfUnderlay from './entity/pdfUnderlay'
 import point from './entity/point'
 import polyline from './entity/polyline'
+import ray from './entity/ray'
+import region from './entity/region'
+import shape from './entity/shape'
 import solid from './entity/solid'
 import spline from './entity/spline'
+import table from './entity/table'
 import text from './entity/text'
 import threeDFace from './entity/threeDFace'
 import tolerance from './entity/tolerance'
+import trace from './entity/trace'
 import vertex from './entity/vertex'
 import viewport from './entity/viewport'
+import wipeout from './entity/wipeout'
+import xline from './entity/xline'
 
 interface EntityHandler {
   TYPE: string
@@ -39,19 +49,26 @@ const handlers: Record<string, EntityHandler> = [
   point,
   line,
   lwpolyline,
+  mline,
+  mleader,
   polyline,
   vertex,
   circle,
   arc,
   ellipse,
   spline,
+  table,
   solid,
+  trace,
   hatch,
   image,
   leader,
+  ray,
+  region,
   dwfUnderlay,
   dgnUnderlay,
   pdfUnderlay,
+  shape,
   mtext,
   tolerance,
   attdef,
@@ -62,6 +79,9 @@ const handlers: Record<string, EntityHandler> = [
   threeDFace,
   viewport,
   ole2Frame,
+  oleFrame,
+  xline,
+  wipeout,
 ].reduce((acc, mod) => {
   acc[mod.TYPE] = mod
   return acc

package/src/handlers/entity/mleader.ts

@@ -0,0 +1,46 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'MLEADER'
+
+interface MLeaderEntity {
+  type: typeof TYPE
+
+  styleName?: string
+  text?: string
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): MLeaderEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const code = tuple[0]
+      const value = tuple[1]
+
+      switch (code) {
+        // Style name
+        case 2:
+          entity.styleName = String(value)
+          break
+
+        // Text string (simplified). MLEADER text can also be stored in more complex structures.
+        case 1:
+          entity.text = String(value)
+          break
+
+        default:
+          Object.assign(entity, common(code, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+    } as MLeaderEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/mline.ts

@@ -0,0 +1,74 @@
+import type { DXFTuple, PartialPoint3D } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'MLINE'
+
+interface MLineEntity {
+  type: typeof TYPE
+
+  startPoint?: PartialPoint3D
+  endPoint?: PartialPoint3D
+
+  vertexCount?: number
+  styleName?: string
+
+  [key: string]: unknown
+}
+
+function ensurePoint3(entity: MLineEntity, key: 'startPoint' | 'endPoint'): PartialPoint3D {
+  entity[key] ??= {}
+  return entity[key]
+}
+
+export const process = (tuples: DXFTuple[]): MLineEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const code = tuple[0]
+      const value = tuple[1]
+
+      switch (code) {
+        // Start point
+        case 10:
+          ensurePoint3(entity, 'startPoint').x = value as number
+          break
+        case 20:
+          ensurePoint3(entity, 'startPoint').y = value as number
+          break
+        case 30:
+          ensurePoint3(entity, 'startPoint').z = value as number
+          break
+
+        // End point
+        case 11:
+          ensurePoint3(entity, 'endPoint').x = value as number
+          break
+        case 21:
+          ensurePoint3(entity, 'endPoint').y = value as number
+          break
+        case 31:
+          ensurePoint3(entity, 'endPoint').z = value as number
+          break
+
+        case 71:
+          entity.vertexCount = value as number
+          break
+
+        case 2:
+          entity.styleName = String(value)
+          break
+
+        default:
+          Object.assign(entity, common(code, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+    } as MLineEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/oleframe.ts

@@ -0,0 +1,62 @@
+import type { DXFTuple, OleFrameEntity } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'OLEFRAME'
+
+export const process = (tuples: DXFTuple[]): OleFrameEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 70:
+          entity.version = value
+          break
+        case 3:
+          entity.name = value
+          break
+        case 10:
+          entity.upperLeftX = value
+          break
+        case 20:
+          entity.upperLeftY = value
+          break
+        case 30:
+          entity.upperLeftZ = value
+          break
+        case 11:
+          entity.lowerRightX = value
+          break
+        case 21:
+          entity.lowerRightY = value
+          break
+        case 31:
+          entity.lowerRightZ = value
+          break
+        case 71:
+          entity.objectType = value
+          break
+        case 72:
+          entity.tile = value
+          break
+        case 90:
+          entity.length = value
+          break
+        case 310:
+          entity.data += String(value)
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      data: '',
+    } as OleFrameEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/ray.ts

@@ -0,0 +1,52 @@
+import type { DXFTuple, PartialPoint3D } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'RAY'
+
+interface RayEntity {
+  type: typeof TYPE
+  start: PartialPoint3D
+  direction: PartialPoint3D
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): RayEntity => {
+  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 11:
+          entity.direction.x = value as number
+          break
+        case 21:
+          entity.direction.y = value as number
+          break
+        case 31:
+          entity.direction.z = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      start: {},
+      direction: {},
+    } as RayEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/region.ts

@@ -0,0 +1,42 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'REGION'
+
+interface RegionEntity {
+  type: typeof TYPE
+
+  acisData?: string[]
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): RegionEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const code = tuple[0]
+      const value = tuple[1]
+
+      switch (code) {
+        // ACIS data text (first line: 1, additional lines: 3)
+        case 1:
+        case 3:
+          entity.acisData ??= []
+          entity.acisData.push(String(value))
+          break
+
+        default:
+          Object.assign(entity, common(code, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+    } as RegionEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/shape.ts

@@ -0,0 +1,73 @@
+import type { DXFTuple, PartialPoint3D } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'SHAPE'
+
+interface ShapeEntity {
+  type: typeof TYPE
+  insertionPoint: PartialPoint3D
+  name?: string
+  size?: number
+  rotation?: number
+  relativeXScale?: number
+  oblique?: number
+  thickness?: number
+  extrusionX?: number
+  extrusionY?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): ShapeEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          entity.insertionPoint.x = value as number
+          break
+        case 20:
+          entity.insertionPoint.y = value as number
+          break
+        case 30:
+          entity.insertionPoint.z = value as number
+          break
+        case 2:
+          entity.name = String(value)
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        case 40:
+          entity.size = value as number
+          break
+        case 41:
+          entity.relativeXScale = value as number
+          break
+        case 50:
+          entity.rotation = value as number
+          break
+        case 51:
+          entity.oblique = value as number
+          break
+        case 210:
+          entity.extrusionX = value as number
+          break
+        case 220:
+          entity.extrusionY = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: {},
+    } as ShapeEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/table.ts

@@ -0,0 +1,49 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'TABLE'
+
+interface TableEntity {
+  type: typeof TYPE
+
+  rows?: number
+  columns?: number
+  cellText?: string[]
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): TableEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const code = tuple[0]
+      const value = tuple[1]
+
+      switch (code) {
+        case 90:
+          entity.rows = value as number
+          break
+        case 91:
+          entity.columns = value as number
+          break
+
+        case 1:
+          entity.cellText ??= []
+          entity.cellText.push(String(value))
+          break
+
+        default:
+          Object.assign(entity, common(code, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+    } as TableEntity,
+  )
+}
+
+export default { TYPE, process }