@linkiez/dxf-renew 5.3.1 → 7.1.0

package/src/handlers/entity/pdfUnderlay.ts

@@ -0,0 +1,94 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'PDFUNDERLAY'
+
+interface UnderlayEntity {
+  type: typeof TYPE
+
+  insertionPoint: { x: number; y: number; z: number }
+  scale: { x: number; y: number; z: number }
+  normal: { x: number; y: number; z: number }
+
+  underlayDefinitionHandle?: string
+  rotation?: number
+  flags?: number
+  contrast?: number
+  fade?: number
+
+  [key: string]: unknown
+}
+
+export const process = (tuples: DXFTuple[]): UnderlayEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const type = tuple[0]
+      const value = tuple[1]
+
+      switch (type) {
+        case 340:
+          entity.underlayDefinitionHandle = String(value)
+          break
+
+        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 41:
+          entity.scale.x = value as number
+          break
+        case 42:
+          entity.scale.y = value as number
+          break
+        case 43:
+          entity.scale.z = value as number
+          break
+
+        case 50:
+          entity.rotation = value as number
+          break
+
+        case 210:
+          entity.normal.x = value as number
+          break
+        case 220:
+          entity.normal.y = value as number
+          break
+        case 230:
+          entity.normal.z = value as number
+          break
+
+        case 280:
+          entity.flags = value as number
+          break
+        case 281:
+          entity.contrast = value as number
+          break
+        case 282:
+          entity.fade = value as number
+          break
+
+        default:
+          Object.assign(entity, common(type, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 },
+      normal: { x: 0, y: 0, z: 1 },
+    } as UnderlayEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/entity/tolerance.ts

@@ -0,0 +1,75 @@
+import type { DXFTuple } from '../../types'
+
+import common from './common'
+
+export const TYPE = 'TOLERANCE'
+
+interface ToleranceEntity {
+  type: typeof TYPE
+
+  insertionPoint: { x: number; y: number; z: number }
+  text?: string
+  dimensionStyleName?: string
+  xAxisDirection?: { x: number; y: number; z: number }
+
+  [key: string]: unknown
+}
+
+function ensureVector3(
+  entity: ToleranceEntity,
+  key: 'insertionPoint' | 'xAxisDirection',
+): { x: number; y: number; z: number } {
+  entity[key] ??= { x: 0, y: 0, z: 0 }
+  return entity[key] as { x: number; y: number; z: number }
+}
+
+export const process = (tuples: DXFTuple[]): ToleranceEntity => {
+  return tuples.reduce(
+    (entity, tuple) => {
+      const code = tuple[0]
+      const value = tuple[1]
+
+      switch (code) {
+        case 3:
+          entity.dimensionStyleName = String(value)
+          break
+
+        case 10:
+          ensureVector3(entity, 'insertionPoint').x = value as number
+          break
+        case 20:
+          ensureVector3(entity, 'insertionPoint').y = value as number
+          break
+        case 30:
+          ensureVector3(entity, 'insertionPoint').z = value as number
+          break
+
+        case 1:
+          entity.text = String(value)
+          break
+
+        case 11:
+          ensureVector3(entity, 'xAxisDirection').x = value as number
+          break
+        case 21:
+          ensureVector3(entity, 'xAxisDirection').y = value as number
+          break
+        case 31:
+          ensureVector3(entity, 'xAxisDirection').z = value as number
+          break
+
+        default:
+          Object.assign(entity, common(code, value))
+          break
+      }
+
+      return entity
+    },
+    {
+      type: TYPE,
+      insertionPoint: { x: 0, y: 0, z: 0 },
+    } as ToleranceEntity,
+  )
+}
+
+export default { TYPE, process }

package/src/handlers/objects.ts

@@ -1,152 +1,336 @@
-import type { DXFTuple, LayoutInternal, ParsedObjects } from '../types'
+import type {
+    DictionaryObject,
+    DXFTuple,
+    ImageDefObject,
+    ImageDefReactorObject,
+    LayoutInternal,
+    ParsedObjects,
+    UnderlayDefinitionObject,
+    XRecordObject,
+} from '../types'
 
-export default function parseObjects(tuples: DXFTuple[]): ParsedObjects {
-  let state: 'IDLE' | 'layout' | 'AcDbLayout' | undefined
-  const objects: ParsedObjects = {
-    layouts: [],
-  }
-  let layout: LayoutInternal | undefined
+type ObjectGroup = DXFTuple[]
+
+function groupObjectsByZero(tuples: DXFTuple[]): ObjectGroup[] {
+  const groups: ObjectGroup[] = []
+  let current: ObjectGroup | undefined
 
   for (const tuple of tuples) {
+    const code = tuple[0]
+    if (code === 0) {
+      if (current && current.length > 0) groups.push(current)
+      current = [tuple]
+      continue
+    }
+    if (!current) continue
+    current.push(tuple)
+  }
+
+  if (current && current.length > 0) groups.push(current)
+  return groups
+}
+
+const LAYOUT_FLOAT_FIELDS: Record<number, keyof LayoutInternal> = {
+  10: 'minLimitX',
+  20: 'minLimitY',
+  11: 'maxLimitX',
+  21: 'maxLimitY',
+  12: 'x',
+  22: 'y',
+  32: 'z',
+  14: 'minX',
+  24: 'minY',
+  34: 'minZ',
+  15: 'maxX',
+  25: 'maxY',
+  35: 'maxZ',
+  146: 'elevation',
+  13: 'ucsX',
+  23: 'ucsY',
+  33: 'ucsZ',
+  16: 'ucsXaxisX',
+  26: 'ucsXaxisY',
+  36: 'ucsXaxisZ',
+  17: 'ucsYaxisX',
+  27: 'ucsYaxisY',
+  37: 'ucsYaxisZ',
+}
+
+const LAYOUT_DIRECT_FIELDS: Record<number, keyof LayoutInternal> = {
+  1: 'name',
+  5: 'handle',
+  71: 'tabOrder',
+  330: 'tableRecord',
+  331: 'lastActiveViewport',
+  333: 'shadePlot',
+}
+
+const LAYOUT_UCS_TYPE: Record<number, LayoutInternal['ucsType']> = {
+  0: 'NOT ORTHOGRAPHIC',
+  1: 'TOP',
+  2: 'BOTTOM',
+  3: 'FRONT',
+  4: 'BACK',
+  5: 'LEFT',
+  6: 'RIGHT',
+}
+
+type LayoutParseState = {
+  state: 'IDLE' | 'layout' | 'AcDbLayout'
+  layout?: LayoutInternal
+}
+
+function consumeLayoutStartTuple(current: LayoutParseState, tuple: DXFTuple): LayoutParseState {
+  if (tuple[1] === 'LAYOUT') return { state: 'layout', layout: {} }
+  return { state: 'IDLE', layout: current.layout }
+}
+
+function consumeLayoutSubclassTuple(current: LayoutParseState, tuple: DXFTuple): LayoutParseState {
+  if (tuple[0] === 100 && tuple[1] === 'AcDbLayout') return { state: 'AcDbLayout', layout: current.layout }
+  return current
+}
+
+function applyLayoutFieldTuple(layout: LayoutInternal, tuple: DXFTuple): void {
+  const type = tuple[0]
+  const value = tuple[1]
+
+  const floatKey = LAYOUT_FLOAT_FIELDS[type]
+  if (floatKey) {
+    ;(layout as any)[floatKey] = Number.parseFloat(String(value))
+    return
+  }
+
+  const directKey = LAYOUT_DIRECT_FIELDS[type]
+  if (directKey) {
+    ;(layout as any)[directKey] = value
+    return
+  }
+
+  if (type === 70) {
+    layout.flag = value === 1 ? 'PSLTSCALE' : 'LIMCHECK'
+    return
+  }
+
+  if (type === 76) {
+    const ucsType = LAYOUT_UCS_TYPE[Number(value)]
+    if (ucsType) layout.ucsType = ucsType
+  }
+}
+
+function consumeLayoutTuple(current: LayoutParseState, tuple: DXFTuple): LayoutParseState {
+  if (tuple[0] === 0) return consumeLayoutStartTuple(current, tuple)
+
+  if (current.state === 'layout') return consumeLayoutSubclassTuple(current, tuple)
+
+  if (current.state === 'AcDbLayout' && current.layout) applyLayoutFieldTuple(current.layout, tuple)
+  return current
+}
+
+function parseLayoutObject(group: ObjectGroup): LayoutInternal | undefined {
+  let current: LayoutParseState = { state: 'IDLE' }
+  for (const tuple of group) current = consumeLayoutTuple(current, tuple)
+  return current.layout
+}
+
+function parseDictionaryObject(group: ObjectGroup): DictionaryObject | undefined {
+  if (group[0]?.[1] !== 'DICTIONARY') return undefined
+
+  const dict: DictionaryObject = {
+    type: 'DICTIONARY',
+    entries: {},
+  }
+
+  let pendingKey: string | undefined
+  for (const tuple of group.slice(1)) {
     const type = tuple[0]
     const value = tuple[1]
-    if (type === 0) {
-      state = 'IDLE'
+
+    if (type === 5) {
+      dict.handle = value
+      continue
     }
-    if (value === 'LAYOUT') {
-      state = 'layout'
-      layout = {}
-      objects.layouts.push(layout)
+    if (type === 330) {
+      dict.ownerHandle = value
+      continue
     }
-    if (state === 'layout' && type !== 0) {
-      // wait until AcDbLayout shows up
-      switch (type) {
-        case 100:
-          if (value === 'AcDbLayout') state = 'AcDbLayout'
-          break
-      }
+    if (type === 3) {
+      pendingKey = String(value)
+      continue
     }
-    if (state === 'AcDbLayout' && type !== 0 && layout) {
-      // save layout attributes
-      switch (type) {
-        case 1:
-          layout.name = value
-          break
-        case 5:
-          layout.handle = value
-          break
-        case 10:
-          layout.minLimitX = Number.parseFloat(String(value))
-          break
-        case 20:
-          layout.minLimitY = Number.parseFloat(String(value))
-          break
-        case 11:
-          layout.maxLimitX = Number.parseFloat(String(value))
-          break
-        case 21:
-          layout.maxLimitY = Number.parseFloat(String(value))
-          break
-        case 12:
-          layout.x = Number.parseFloat(String(value))
-          break
-        case 22:
-          layout.y = Number.parseFloat(String(value))
-          break
-        case 32:
-          layout.z = Number.parseFloat(String(value))
-          break
-        case 14:
-          layout.minX = Number.parseFloat(String(value))
-          break
-        case 24:
-          layout.minY = Number.parseFloat(String(value))
-          break
-        case 34:
-          layout.minZ = Number.parseFloat(String(value))
-          break
-        case 15:
-          layout.maxX = Number.parseFloat(String(value))
-          break
-        case 25:
-          layout.maxY = Number.parseFloat(String(value))
-          break
-        case 35:
-          layout.maxZ = Number.parseFloat(String(value))
-          break
-        case 70:
-          layout.flag = value === 1 ? 'PSLTSCALE' : 'LIMCHECK'
-          break
-        case 71:
-          layout.tabOrder = value
-          break
-        case 146:
-          layout.elevation = Number.parseFloat(String(value))
-          break
-        case 13:
-          layout.ucsX = Number.parseFloat(String(value))
-          break
-        case 23:
-          layout.ucsY = Number.parseFloat(String(value))
-          break
-        case 33:
-          layout.ucsZ = Number.parseFloat(String(value))
-          break
-        case 16:
-          layout.ucsXaxisX = Number.parseFloat(String(value))
-          break
-        case 26:
-          layout.ucsXaxisY = Number.parseFloat(String(value))
-          break
-        case 36:
-          layout.ucsXaxisZ = Number.parseFloat(String(value))
-          break
-        case 17:
-          layout.ucsYaxisX = Number.parseFloat(String(value))
-          break
-        case 27:
-          layout.ucsYaxisY = Number.parseFloat(String(value))
-          break
-        case 37:
-          layout.ucsYaxisZ = Number.parseFloat(String(value))
-          break
-        case 76:
-          switch (value) {
-            case 0:
-              layout.ucsType = 'NOT ORTHOGRAPHIC'
-              break
-            case 1:
-              layout.ucsType = 'TOP'
-              break
-            case 2:
-              layout.ucsType = 'BOTTOM'
-              break
-            case 3:
-              layout.ucsType = 'FRONT'
-              break
-            case 4:
-              layout.ucsType = 'BACK'
-              break
-            case 5:
-              layout.ucsType = 'LEFT'
-              break
-            case 6:
-              layout.ucsType = 'RIGHT'
-              break
-          }
-          break
-        case 330:
-          layout.tableRecord = value
-          break
-        case 331:
-          layout.lastActiveViewport = value
-          break
-        case 333:
-          layout.shadePlot = value
-          break
-      }
+    if ((type === 350 || type === 360) && pendingKey) {
+      dict.entries[pendingKey] = String(value)
+      pendingKey = undefined
     }
   }
 
+  return dict
+}
+
+function parseXRecordObject(group: ObjectGroup): XRecordObject | undefined {
+  if (group[0]?.[1] !== 'XRECORD') return undefined
+
+  const tuples = group.slice(1)
+
+  const xRecord: XRecordObject = {
+    type: 'XRECORD',
+    tuples,
+  }
+
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    const value = tuple[1]
+
+    if (type === 5) xRecord.handle = value
+    if (type === 330) xRecord.ownerHandle = value
+  }
+
+  return xRecord
+}
+
+function parseImageDefObject(group: ObjectGroup): ImageDefObject | undefined {
+  if (group[0]?.[1] !== 'IMAGEDEF') return undefined
+
+  const tuples = group.slice(1)
+
+  const imageDef: ImageDefObject = {
+    type: 'IMAGEDEF',
+    tuples,
+  }
+
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    const value = tuple[1]
+
+    if (type === 5) imageDef.handle = value
+    if (type === 330 && imageDef.ownerHandle === undefined) imageDef.ownerHandle = value
+    if (type === 1) imageDef.fileName = String(value)
+    if (type === 10) imageDef.pixelSizeX = Number(value)
+    if (type === 20) imageDef.pixelSizeY = Number(value)
+  }
+
+  return imageDef
+}
+
+function parseImageDefReactorObject(group: ObjectGroup): ImageDefReactorObject | undefined {
+  if (group[0]?.[1] !== 'IMAGEDEF_REACTOR') return undefined
+
+  const tuples = group.slice(1)
+
+  const reactor: ImageDefReactorObject = {
+    type: 'IMAGEDEF_REACTOR',
+    tuples,
+  }
+
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    const value = tuple[1]
+
+    if (type === 5) reactor.handle = value
+    if (type === 330) reactor.imageHandle = value
+  }
+
+  return reactor
+}
+
+const UNDERLAY_DEFINITION_OBJECT_TYPES = new Set([
+  'UNDERLAYDEFINITION',
+  'PDFDEFINITION',
+  'DWFDEFINITION',
+  'DGNDEFINITION',
+])
+
+function parseUnderlayDefinitionObject(group: ObjectGroup): UnderlayDefinitionObject | undefined {
+  const objectType = group[0]?.[1]
+  if (typeof objectType !== 'string') return undefined
+  if (!UNDERLAY_DEFINITION_OBJECT_TYPES.has(objectType)) return undefined
+
+  const tuples = group.slice(1)
+
+  const def: UnderlayDefinitionObject = {
+    type: objectType as UnderlayDefinitionObject['type'],
+    tuples,
+  }
+
+  for (const tuple of tuples) {
+    const type = tuple[0]
+    const value = tuple[1]
+
+    if (type === 5) def.handle = value
+    if (type === 330 && def.ownerHandle === undefined) def.ownerHandle = value
+    if (type === 1) def.fileName = String(value)
+    if (type === 2) def.underlayName = String(value)
+  }
+
+  return def
+}
+
+type ObjectGroupHandler = (objects: ParsedObjects, group: ObjectGroup) => void
+
+const OBJECT_GROUP_HANDLERS: Record<string, ObjectGroupHandler> = {
+  LAYOUT: (objects, group) => {
+    const layout = parseLayoutObject(group)
+    if (layout) objects.layouts.push(layout)
+  },
+  DICTIONARY: (objects, group) => {
+    const dict = parseDictionaryObject(group)
+    const handle = dict?.handle ? String(dict.handle) : undefined
+    if (dict && handle) objects.dictionaries![handle] = dict
+  },
+  XRECORD: (objects, group) => {
+    const xRecord = parseXRecordObject(group)
+    const handle = xRecord?.handle ? String(xRecord.handle) : undefined
+    if (xRecord && handle) objects.xRecords![handle] = xRecord
+  },
+  IMAGEDEF: (objects, group) => {
+    const imageDef = parseImageDefObject(group)
+    const handle = imageDef?.handle ? String(imageDef.handle) : undefined
+    if (imageDef && handle) objects.imageDefs![handle] = imageDef
+  },
+  IMAGEDEF_REACTOR: (objects, group) => {
+    const reactor = parseImageDefReactorObject(group)
+    const handle = reactor?.handle ? String(reactor.handle) : undefined
+    if (reactor && handle) objects.imageDefReactors![handle] = reactor
+  },
+  UNDERLAYDEFINITION: (objects, group) => {
+    const def = parseUnderlayDefinitionObject(group)
+    const handle = def?.handle ? String(def.handle) : undefined
+    if (def && handle) objects.underlayDefinitions![handle] = def
+  },
+  PDFDEFINITION: (objects, group) => {
+    const def = parseUnderlayDefinitionObject(group)
+    const handle = def?.handle ? String(def.handle) : undefined
+    if (def && handle) objects.underlayDefinitions![handle] = def
+  },
+  DWFDEFINITION: (objects, group) => {
+    const def = parseUnderlayDefinitionObject(group)
+    const handle = def?.handle ? String(def.handle) : undefined
+    if (def && handle) objects.underlayDefinitions![handle] = def
+  },
+  DGNDEFINITION: (objects, group) => {
+    const def = parseUnderlayDefinitionObject(group)
+    const handle = def?.handle ? String(def.handle) : undefined
+    if (def && handle) objects.underlayDefinitions![handle] = def
+  },
+}
+
+export default function parseObjects(tuples: DXFTuple[]): ParsedObjects {
+  const objects: ParsedObjects = {
+    layouts: [],
+    dictionaries: {},
+    xRecords: {},
+    imageDefs: {},
+    imageDefReactors: {},
+    underlayDefinitions: {},
+  }
+
+  const groups = groupObjectsByZero(tuples)
+  for (const group of groups) {
+    const objectType = group[0]?.[1]
+    if (typeof objectType !== 'string') continue
+
+    const handler = OBJECT_GROUP_HANDLERS[objectType]
+    if (handler) handler(objects, group)
+  }
+
   return objects
 }