@linkiez/dxf-renew 5.3.1

package/src/handlers/entity/mtext.ts

@@ -0,0 +1,150 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'MTEXT'
+
+
+interface SimpleCodes {
+  [key: number]: string
+}
+
+interface MTextEntity {
+  type: typeof TYPE
+  string: string
+  x?: number
+  y?: number
+  z?: number
+  nominalTextHeight?: number
+  refRectangleWidth?: number
+  attachmentPoint?: number
+  drawingDirection?: number
+  styleName?: string
+  xAxisX?: number
+  xAxisY?: number
+  xAxisZ?: number
+  horizontalWidth?: number
+  verticalHeight?: number
+  lineSpacingStyle?: number
+  lineSpacingFactor?: number
+  backgroundFill?: number
+  bgColorRGB0?: number
+  bgColorRGB1?: number
+  bgColorRGB2?: number
+  bgColorRGB3?: number
+  bgColorRGB4?: number
+  bgColorRGB5?: number
+  bgColorRGB6?: number
+  bgColorRGB7?: number
+  bgColorRGB8?: number
+  bgColorRGB9?: number
+  bgColorName0?: number
+  bgColorName1?: number
+  bgColorName2?: number
+  bgColorName3?: number
+  bgColorName4?: number
+  bgColorName5?: number
+  bgColorName6?: number
+  bgColorName7?: number
+  bgColorName8?: number
+  bgColorName9?: number
+  fillBoxStyle?: number
+  bgFillColor?: number
+  bgFillTransparency?: number
+  columnType?: number
+  columnCount?: number
+  columnFlowReversed?: number
+  columnAutoheight?: number
+  columnWidth?: number
+  columnGutter?: number
+  columnHeights?: number
+  [key: string]: unknown
+}
+
+const simpleCodes: SimpleCodes = {
+  10: 'x',
+  20: 'y',
+  30: 'z',
+  40: 'nominalTextHeight',
+  41: 'refRectangleWidth',
+  71: 'attachmentPoint',
+  72: 'drawingDirection',
+  7: 'styleName',
+  11: 'xAxisX',
+  21: 'xAxisY',
+  31: 'xAxisZ',
+  42: 'horizontalWidth',
+  43: 'verticalHeight',
+  73: 'lineSpacingStyle',
+  44: 'lineSpacingFactor',
+  90: 'backgroundFill',
+  420: 'bgColorRGB0',
+  421: 'bgColorRGB1',
+  422: 'bgColorRGB2',
+  423: 'bgColorRGB3',
+  424: 'bgColorRGB4',
+  425: 'bgColorRGB5',
+  426: 'bgColorRGB6',
+  427: 'bgColorRGB7',
+  428: 'bgColorRGB8',
+  429: 'bgColorRGB9',
+  430: 'bgColorName0',
+  431: 'bgColorName1',
+  432: 'bgColorName2',
+  433: 'bgColorName3',
+  434: 'bgColorName4',
+  435: 'bgColorName5',
+  436: 'bgColorName6',
+  437: 'bgColorName7',
+  438: 'bgColorName8',
+  439: 'bgColorName9',
+  45: 'fillBoxStyle',
+  63: 'bgFillColor',
+  441: 'bgFillTransparency',
+  75: 'columnType',
+  76: 'columnCount',
+  78: 'columnFlowReversed',
+  79: 'columnAutoheight',
+  48: 'columnWidth',
+  49: 'columnGutter',
+  50: 'columnHeights',
+}
+
+export const process = (tuples: DXFTuple[]): MTextEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      assign(entity, type, value)
+
+      return entity
+    },
+    {
+      type: TYPE,
+      string: '',
+    } as MTextEntity,
+  )
+}
+
+export const assign = (
+  entity: MTextEntity,
+  type: number,
+  value: string | number
+): MTextEntity => {
+  if (type in simpleCodes) {
+    entity[simpleCodes[type]] = value
+  } else if (type === 1 || type === 3) {
+    entity.string += value as string
+  } else if (type === 50) {
+    // Rotation angle in radians
+    entity.xAxisX = Math.cos(value as number)
+    entity.xAxisY = Math.sin(value as number)
+  } else {
+    Object.assign(entity, common(type, value))
+  }
+
+  return entity
+}
+
+export default { TYPE, process, assign }

package/src/handlers/entity/ole2Frame.ts

@@ -0,0 +1,64 @@
+import type { DXFTuple, Ole2FrameEntity } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'OLE2FRAME'
+
+export const process = (tuples: DXFTuple[]): Ole2FrameEntity => {
+  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:
+          // 1 = Link; 2 = Embedded; 3 = Static
+          entity.objectType = value
+          break
+        case 72:
+          // 0 = Object resides in model space, 1 = Object resides in paper space
+          entity.tile = value
+          break
+        case 90:
+          entity.length = value
+          break
+        case 310:
+          entity.data += value
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      data: '',
+    } as Ole2FrameEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/point.ts

@@ -0,0 +1,47 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'POINT'
+
+
+interface PointEntity {
+  type: typeof TYPE
+  x?: number
+  y?: number
+  z?: number
+  thickness?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): PointEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        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 39:
+          entity.thickness = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+    } as PointEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/polyline.ts

@@ -0,0 +1,49 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'POLYLINE'
+
+
+interface Vertex {
+  [key: string]: unknown
+}
+
+interface PolylineEntity {
+  type: typeof TYPE
+  vertices: Vertex[]
+  closed?: boolean
+  polygonMesh?: boolean
+  polyfaceMesh?: boolean
+  thickness?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): PolylineEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 70:
+          entity.closed = ((value as number) & 1) === 1
+          entity.polygonMesh = ((value as number) & 16) === 16
+          entity.polyfaceMesh = ((value as number) & 64) === 64
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      vertices: [],
+    } as PolylineEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/solid.ts

@@ -0,0 +1,73 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import type { Point3D } from '../../types'
+import common from './common'
+
+
+interface SolidEntity {
+  type: string
+  corners: Point3D[]
+  thickness?: number
+}
+
+export const TYPE = 'SOLID'
+
+export const process = (tuples: DXFTuple[]): SolidEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          entity.corners[0].x = value as number
+          break
+        case 20:
+          entity.corners[0].y = value as number
+          break
+        case 30:
+          entity.corners[0].z = value as number
+          break
+        case 11:
+          entity.corners[1].x = value as number
+          break
+        case 21:
+          entity.corners[1].y = value as number
+          break
+        case 31:
+          entity.corners[1].z = value as number
+          break
+        case 12:
+          entity.corners[2].x = value as number
+          break
+        case 22:
+          entity.corners[2].y = value as number
+          break
+        case 32:
+          entity.corners[2].z = value as number
+          break
+        case 13:
+          entity.corners[3].x = value as number
+          break
+        case 23:
+          entity.corners[3].y = value as number
+          break
+        case 33:
+          entity.corners[3].z = value as number
+          break
+        case 39:
+          entity.thickness = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      corners: [{} as Point3D, {} as Point3D, {} as Point3D, {} as Point3D],
+    } as SolidEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/spline.ts

@@ -0,0 +1,103 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'SPLINE'
+
+
+interface ControlPoint {
+  x: number
+  y: number
+  z?: number
+}
+
+interface SplineEntity {
+  type: typeof TYPE
+  controlPoints: ControlPoint[]
+  knots: number[]
+  weights?: number[]
+  knotTolerance?: number
+  controlPointTolerance?: number
+  fitTolerance?: number
+  flag?: number
+  closed?: boolean
+  degree?: number
+  numberOfKnots?: number
+  numberOfControlPoints?: number
+  numberOfFitPoints?: number
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): SplineEntity => {
+  let controlPoint: ControlPoint
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          controlPoint = {
+            x: value as number,
+            y: 0,
+          }
+          entity.controlPoints.push(controlPoint)
+          break
+        case 20:
+          controlPoint.y = value as number
+          break
+        case 30:
+          controlPoint.z = value as number
+          break
+        case 40:
+          entity.knots.push(value as number)
+          break
+        case 41:
+          // Only create weights if needed
+          entity.weights ??= []
+          entity.weights.push(value as number)
+          break
+        case 42:
+          entity.knotTolerance = value as number
+          break
+        case 43:
+          entity.controlPointTolerance = value as number
+          break
+        case 44:
+          entity.fitTolerance = value as number
+          break
+        case 70: // Spline flag (bit coded):
+          // 1 = Closed spline
+          // 2 = Periodic spline
+          // 4 = Rational spline
+          // 8 = Planar
+          // 16 = Linear (planar bit is also set)
+          entity.flag = value as number
+          entity.closed = ((value as number) & 1) === 1
+          break
+        case 71:
+          entity.degree = value as number
+          break
+        case 72:
+          entity.numberOfKnots = value as number
+          break
+        case 73:
+          entity.numberOfControlPoints = value as number
+          break
+        case 74:
+          entity.numberOfFitPoints = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      controlPoints: [],
+      knots: [],
+    } as SplineEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/text.ts

@@ -0,0 +1,83 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import common from './common'
+
+export const TYPE = 'TEXT'
+
+
+interface SimpleCodes {
+  [key: number]: string
+}
+
+interface TextEntity {
+  type: typeof TYPE
+  string: string
+  x?: number
+  y?: number
+  z?: number
+  x2?: number
+  y2?: number
+  z2?: number
+  thickness?: number
+  textHeight?: number
+  relScaleX?: number
+  rotation?: number
+  obliqueAngle?: number
+  styleName?: string
+  mirror?: number
+  hAlign?: number
+  vAlign?: number
+  [key: string]: unknown
+}
+
+const simpleCodes: SimpleCodes = {
+  1: 'string',
+  10: 'x',
+  20: 'y',
+  30: 'z',
+  11: 'x2',
+  21: 'y2',
+  31: 'z2',
+  39: 'thickness',
+  40: 'textHeight',
+  41: 'relScaleX',
+  50: 'rotation',
+  51: 'obliqueAngle',
+  7: 'styleName',
+  71: 'mirror',
+  72: 'hAlign',
+  73: 'vAlign',
+}
+
+// const EXCEPTION_STRINGS = ['\\A1;', '%%u']
+
+export const process = (tuples: DXFTuple[]): TextEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      assign(entity, type, value)
+
+      return entity
+    },
+    {
+      type: TYPE,
+      string: '',
+    } as TextEntity,
+  )
+}
+
+export const assign = (
+  entity: TextEntity,
+  type: number,
+  value: string | number
+): void => {
+  if (type in simpleCodes) {
+    entity[simpleCodes[type]] = value
+  } else {
+    Object.assign(entity, common(type, value))
+  }
+}
+
+export default { TYPE, process, assign }

package/src/handlers/entity/threeDFace.ts

@@ -0,0 +1,69 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import type { Point3D } from '../../types'
+import common from './common'
+
+
+interface ThreeDFaceEntity {
+  type: string
+  vertices: Point3D[]
+}
+
+export const TYPE = '3DFACE'
+
+export const process = (tuples: DXFTuple[]): ThreeDFaceEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+      switch (type) {
+        case 10:
+          entity.vertices[0].x = value as number
+          break
+        case 20:
+          entity.vertices[0].y = value as number
+          break
+        case 30:
+          entity.vertices[0].z = value as number
+          break
+        case 11:
+          entity.vertices[1].x = value as number
+          break
+        case 21:
+          entity.vertices[1].y = value as number
+          break
+        case 31:
+          entity.vertices[1].z = value as number
+          break
+        case 12:
+          entity.vertices[2].x = value as number
+          break
+        case 22:
+          entity.vertices[2].y = value as number
+          break
+        case 32:
+          entity.vertices[2].z = value as number
+          break
+        case 13:
+          entity.vertices[3].x = value as number
+          break
+        case 23:
+          entity.vertices[3].y = value as number
+          break
+        case 33:
+          entity.vertices[3].z = value as number
+          break
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+      return entity
+    },
+    {
+      type: TYPE,
+      vertices: [{} as Point3D, {} as Point3D, {} as Point3D, {} as Point3D],
+    } as ThreeDFaceEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/vertex.ts

@@ -0,0 +1,55 @@
+import type { DXFTuple } from '../../types/dxf'
+
+import type { Vertex } from '../../types'
+
+export const TYPE = 'VERTEX'
+
+
+const ensureFaces = (entity: Vertex): void => {
+  entity.faces = entity.faces || []
+  if ('x' in entity && !entity.x) delete entity.x
+  if ('y' in entity && !entity.y) delete entity.y
+  if ('z' in entity && !entity.z) delete entity.z
+}
+
+export const process = (tuples: DXFTuple[]): Vertex => {
+  return tuples.reduce((entity, tuple) => {
+    const type = tuple[0]
+    const value = tuple[1]
+    switch (type) {
+      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 42:
+        entity.bulge = value as number
+        break
+      case 71:
+        ensureFaces(entity)
+        entity.faces![0] = value as number
+        break
+      case 72:
+        ensureFaces(entity)
+        entity.faces![1] = value as number
+        break
+      case 73:
+        ensureFaces(entity)
+        entity.faces![2] = value as number
+        break
+      case 74:
+        ensureFaces(entity)
+        entity.faces![3] = value as number
+        break
+      default:
+        break
+    }
+    return entity
+  }, {} as Vertex)
+}
+
+export default { TYPE, process }