@linkiez/dxf-renew 7.0.0 → 7.1.0

package/src/toSVG.ts

@@ -1,9 +1,10 @@
 import { Box2 } from 'vecks'
 
 import denormalise from './denormalise'
-import dimensionToSVG from './dimensionToSVG'
+import dimensionToSVG, { getDimensionGeometryBBox } from './dimensionToSVG'
 import entityToPolyline from './entityToPolyline'
 import getRGBForEntity from './getRGBForEntity'
+import escapeXmlText from './util/escapeXmlText'
 import logger from './util/logger'
 import rgbToColorAttribute from './util/rgbToColorAttribute'
 import rotate from './util/rotate'
@@ -16,10 +17,13 @@ import type {
   DimensionEntity,
   EllipseEntity,
   Entity,
+  LeaderEntity,
   MTextEntity,
   ParsedDXF,
   SplineEntity,
   TextEntity,
+  ToleranceEntity,
+  ToSVGOptions,
 } from './types'
 import type { BoundsAndElement } from './types/svg'
 
@@ -90,6 +94,26 @@ const lwpolyline = (entity: Entity): BoundsAndElement => {
   )
 }
 
+const leader = (entity: LeaderEntity): BoundsAndElement | null => {
+  if (!entity.vertices || entity.vertices.length < 2) return null
+
+  const bbox0 = entity.vertices.reduce(
+    (acc, p) => acc.expandByPoint({ x: p.x, y: p.y }),
+    new Box2(),
+  )
+  const d = entity.vertices.reduce((acc, p, i) => {
+    acc += i === 0 ? 'M' : 'L'
+    acc += p.x + ',' + p.y
+    return acc
+  }, '')
+
+  return transformBoundingBoxAndElement(
+    bbox0,
+    `<path d="${d}" />`,
+    entity.transforms ?? [],
+  )
+}
+
 
 /**
  * Create a <circle /> element for the CIRCLE entity.
@@ -311,7 +335,7 @@ const text = (entity: TextEntity): BoundsAndElement => {
     .expandByPoint({ x: x + textWidth, y: y + height })
 
   const rotationDegrees = (rotation * 180) / Math.PI
-  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${content}</text>`
+  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${escapeXmlText(content)}</text>`
 
   const { bbox, element } = addFlipXIfApplicable(entity, {
     bbox: bbox0,
@@ -340,8 +364,36 @@ const mtext = (entity: MTextEntity): BoundsAndElement => {
     ? Math.atan2(entity.xAxisY, entity.xAxisX)
     : 0
   const rotationDegrees = (rotation * 180) / Math.PI
+  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${escapeXmlText(content)}</text>`
+
+  const { bbox, element } = addFlipXIfApplicable(entity, {
+    bbox: bbox0,
+    element: element0,
+  })
+  return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? [])
+}
+
+/**
+ * Minimal <text /> fallback for TOLERANCE entities.
+ * DXF uses special control codes; we preserve the raw string.
+ */
+const tolerance = (entity: ToleranceEntity): BoundsAndElement => {
+  const x = entity.insertionPoint?.x ?? 0
+  const y = entity.insertionPoint?.y ?? 0
+  const height = 1
+  const content = entity.text ?? ''
+
+  const rotation = entity.xAxisDirection
+    ? Math.atan2(entity.xAxisDirection.y, entity.xAxisDirection.x)
+    : 0
+  const rotationDegrees = (rotation * 180) / Math.PI
+
+  const textWidth = content.length * height * 0.6
+  const bbox0 = new Box2()
+    .expandByPoint({ x, y })
+    .expandByPoint({ x: x + textWidth, y: y + height })
 
-  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${content}</text>`
+  const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${escapeXmlText(content)}</text>`
 
   const { bbox, element } = addFlipXIfApplicable(entity, {
     bbox: bbox0,
@@ -356,8 +408,10 @@ const mtext = (entity: MTextEntity): BoundsAndElement => {
 const dimension = (
   entity: DimensionEntity,
   dimStyle?: any,
+  options?: ToSVGOptions,
+  viewport?: { width: number; height: number },
 ): BoundsAndElement => {
-  const result = dimensionToSVG(entity, dimStyle)
+  const result = dimensionToSVG(entity, dimStyle, options, viewport)
   return transformBoundingBoxAndElement(
     result.bbox,
     result.element,
@@ -410,6 +464,8 @@ const bezier = (entity: SplineEntity): BoundsAndElement => {
 const entityToBoundsAndElement = (
   entity: Entity,
   dimStyles?: { [name: string]: any },
+  options?: ToSVGOptions,
+  viewport?: { width: number; height: number },
 ): BoundsAndElement | null => {
   switch (entity.type) {
     case 'CIRCLE':
@@ -430,7 +486,7 @@ const entityToBoundsAndElement = (
       const dimStyle = styleName && dimStyles
         ? dimStyles[styleName]
         : undefined
-      return dimension(dimEntity, dimStyle)
+      return dimension(dimEntity, dimStyle, options, viewport)
     }
     case 'SPLINE': {
       const splineEntity = entity as SplineEntity
@@ -454,22 +510,57 @@ const entityToBoundsAndElement = (
     case 'LWPOLYLINE': {
       return lwpolyline(entity)
     }
+    case 'LEADER': {
+      return leader(entity as LeaderEntity)
+    }
+    case 'TOLERANCE': {
+      return tolerance(entity as ToleranceEntity)
+    }
     default:
       logger.warn('entity type not supported in SVG rendering:', entity.type)
       return null
   }
 }
 
-export default function toSVG(parsed: ParsedDXF): string {
+export default function toSVG(parsed: ParsedDXF, options: ToSVGOptions = {}): string {
   const entities = denormalise(parsed)
   const dimStyles = parsed.tables.dimStyles
+
+  const geometryBBox = entities.reduce((acc: Box2, entity: Entity): Box2 => {
+    if (entity.type === 'DIMENSION') {
+      const bbox = getDimensionGeometryBBox(entity as DimensionEntity)
+      if (bbox.valid) {
+        acc.expandByPoint(bbox.min)
+        acc.expandByPoint(bbox.max)
+      }
+      return acc
+    }
+
+    const boundsAndElement = entityToBoundsAndElement(entity, dimStyles, options)
+    if (boundsAndElement?.bbox.valid) {
+      acc.expandByPoint(boundsAndElement.bbox.min)
+      acc.expandByPoint(boundsAndElement.bbox.max)
+    }
+    return acc
+  }, new Box2())
+
+  const viewport = geometryBBox.valid
+    ? {
+        width: geometryBBox.max.x - geometryBBox.min.x,
+        height: geometryBBox.max.y - geometryBBox.min.y,
+      }
+    : {
+        width: 0,
+        height: 0,
+      }
+
   const { bbox, elements } = entities.reduce(
     (
       acc: { bbox: Box2; elements: string[] },
       entity: Entity,
     ): { bbox: Box2; elements: string[] } => {
       const rgb = getRGBForEntity(parsed.tables.layers, entity)
-      const boundsAndElement = entityToBoundsAndElement(entity, dimStyles)
+      const boundsAndElement = entityToBoundsAndElement(entity, dimStyles, options, viewport)
       // Ignore entities that don't produce SVG elements or have unsupported types
       if (boundsAndElement) {
         const { bbox, element } = boundsAndElement

package/src/types/dimension-entity.ts

@@ -7,6 +7,17 @@ export interface DimensionEntity extends BaseEntity {
   type: 'DIMENSION'
   block?: string
   start: Point3D
+  /**
+   * Angular vertex for DIMENSION type 5 (Angular 3-point).
+   * This is parsed from group codes 15/25/35.
+   */
+  angleVertex?: Point3D
+
+  /**
+   * Angular arc location point for DIMENSION angular types.
+   * This is parsed from group codes 16/26/36 (OCS in the DXF reference).
+   */
+  arcPoint?: Point3D
   measureStart: Point3D
   measureEnd: Point3D
   textMidpoint: Point3D

package/src/types/entity.ts

@@ -6,7 +6,9 @@ import type { CircleEntity } from './circle-entity'
 import type { DimensionEntity } from './dimension-entity'
 import type { EllipseEntity } from './ellipse-entity'
 import type { HatchEntity } from './hatch-entity'
+import type { ImageEntity } from './image-entity'
 import type { InsertEntity } from './insert-entity'
+import type { LeaderEntity } from './leader-entity'
 import type { LineEntity } from './line-entity'
 import type { MTextEntity } from './mtext-entity'
 import type { PointEntity } from './point-entity'
@@ -14,6 +16,8 @@ import type { PolylineEntity } from './polyline-entity'
 import type { SolidEntity } from './solid-entity'
 import type { SplineEntity } from './spline-entity'
 import type { TextEntity } from './text-entity'
+import type { ToleranceEntity } from './tolerance-entity'
+import type { DgnUnderlayEntity, DwfUnderlayEntity, PdfUnderlayEntity } from './underlay-entity'
 
 export type Entity =
   | LineEntity
@@ -28,5 +32,11 @@ export type Entity =
   | DimensionEntity
   | SolidEntity
   | InsertEntity
+  | ImageEntity
+  | LeaderEntity
+  | ToleranceEntity
+  | DwfUnderlayEntity
+  | DgnUnderlayEntity
+  | PdfUnderlayEntity
   | HatchEntity
   | BaseEntity

package/src/types/image-entity.ts

@@ -0,0 +1,35 @@
+// IMAGE entity type
+
+import type { BaseEntity } from './base-entity'
+import type { Point3D } from './common'
+
+export interface ImageEntity extends BaseEntity {
+  type: 'IMAGE'
+
+  insertionPoint: Point3D
+  uVector: Point3D
+  vVector: Point3D
+
+  /** Image size in pixels. */
+  pixelSizeX: number
+  pixelSizeY: number
+
+  /** Hard reference to IMAGEDEF object. */
+  imageDefHandle?: string
+
+  /** Hard reference to IMAGEDEF_REACTOR object. */
+  imageDefReactorHandle?: string
+
+  /** Image display properties bitmask. */
+  displayProperties?: number
+
+  /** Clipping state: 0 = Off; 1 = On. */
+  clippingState?: number
+
+  brightness?: number
+  contrast?: number
+  fade?: number
+
+  /** DXF class version. */
+  classVersion?: number
+}

package/src/types/index.ts

@@ -12,7 +12,9 @@ export * from './circle-entity'
 export * from './dimension-entity'
 export * from './ellipse-entity'
 export * from './hatch-entity'
+export * from './image-entity'
 export * from './insert-entity'
+export * from './leader-entity'
 export * from './line-entity'
 export * from './mtext-entity'
 export * from './ole2frame-entity'
@@ -21,6 +23,8 @@ export * from './polyline-entity'
 export * from './solid-entity'
 export * from './spline-entity'
 export * from './text-entity'
+export * from './tolerance-entity'
+export * from './underlay-entity'
 export * from './viewport-entity'
 
 // Union type

package/src/types/leader-entity.ts

@@ -0,0 +1,40 @@
+// LEADER entity type
+
+import type { BaseEntity } from './base-entity'
+import type { Point3D } from './common'
+
+export interface LeaderEntity extends BaseEntity {
+  type: 'LEADER'
+
+  /** Leader vertices, in drawing coordinates. */
+  vertices: Point3D[]
+
+  /** Dimension style name. */
+  dimensionStyleName?: string
+
+  /** Arrowhead flag: 0 = Disabled; 1 = Enabled. */
+  arrowheadFlag?: number
+
+  /** Leader path type: 0 = Straight line segments; 1 = Spline. */
+  pathType?: number
+
+  /** Leader creation flag: 0 = text; 1 = tolerance; 2 = insert; 3 = none. */
+  creationFlag?: number
+
+  hooklineDirectionFlag?: number
+  hooklineFlag?: number
+
+  textHeight?: number
+  textWidth?: number
+
+  /** Color to use if leader's DIMCLR D = BYBLOCK. */
+  color?: number
+
+  /** Hard reference to associated annotation entity. */
+  annotationHandle?: string
+
+  normal?: Point3D
+  horizontalDirection?: Point3D
+  blockOffset?: Point3D
+  annotationOffset?: Point3D
+}

package/src/types/options.ts

@@ -4,9 +4,50 @@ export interface ToPolylinesOptions {
   interpolationsPerSplineSegment?: number
 }
 
+/**
+ * Viewport percentage controls for DIMENSION autoScale.
+ *
+ * Each value is a percentage (0..100) of the viewport minimum dimension.
+ */
+export interface DimensionAutoScaleViewportPercentages {
+  /** Arrowhead marker size (markerWidth/markerHeight) */
+  arrowSize?: number
+  /** Text height (`font-size`) */
+  textHeight?: number
+  /** Extension line offset from the measured points */
+  extLineOffset?: number
+  /** Extension line overshoot beyond the dimension line */
+  extLineExtension?: number
+}
+
 export interface ToSVGOptions {
   width?: number
   height?: number
+  dimension?: {
+    /**
+     * Automatically scale DIMENSION arrow size, extension endpoints, and
+     * text height estimates based on the SVG viewport size.
+     */
+    autoScale?: boolean
+
+    /**
+     * Viewport reference size used by DIMENSION autoScale.
+     * Scale factor is: min(viewBoxWidth, viewBoxHeight) / autoScaleViewportReference.
+     * Default: 40.
+     */
+    autoScaleViewportReference?: number
+
+    /**
+     * Per-element viewport-percentage overrides for DIMENSION autoScale.
+     *
+     * When provided (and `autoScale` is enabled), these values set the final
+     * sizes directly as a percentage of the viewport minimum dimension:
+     * `size = min(viewBoxWidth, viewBoxHeight) * (percent / 100)`.
+     *
+     * Percent values are expected in the `0..100` range.
+     */
+    autoScaleViewportPercentages?: DimensionAutoScaleViewportPercentages
+  }
 }
 
 export interface Config {

package/src/types/tables.ts

@@ -1,6 +1,7 @@
 // DXF Tables parsing types
 
 import type { Point2D, Point3D } from './common'
+import type { DXFTuple } from './dxf'
 
 /**
  * Partial point for parsing (all coordinates optional)
@@ -408,7 +409,90 @@ export interface DimStyleInternal {
 /**
  * DXF Objects section result
  */
+export interface DictionaryObject {
+  type: 'DICTIONARY'
+  handle?: string | number
+  ownerHandle?: string | number
+  entries: Record<string, string>
+}
+
+export interface XRecordObject {
+  type: 'XRECORD'
+  handle?: string | number
+  ownerHandle?: string | number
+
+  /** Raw tuples for downstream consumers (excluding the initial 0/XRECORD tuple). */
+  tuples: DXFTuple[]
+}
+
+export interface ImageDefObject {
+  type: 'IMAGEDEF'
+  handle?: string | number
+
+  /** Soft-pointer ID/handle to the ACAD_IMAGE_dict dictionary (when present). */
+  ownerHandle?: string | number
+
+  /** File name of the referenced image. */
+  fileName?: string
+
+  /** Image size in pixels (when available). */
+  pixelSizeX?: number
+  pixelSizeY?: number
+
+  /** Raw tuples for downstream consumers (excluding the initial 0/IMAGEDEF tuple). */
+  tuples: DXFTuple[]
+}
+
+export interface ImageDefReactorObject {
+  type: 'IMAGEDEF_REACTOR'
+  handle?: string | number
+
+  /** Object ID/handle for the associated IMAGE entity (when present). */
+  imageHandle?: string | number
+
+  /** Raw tuples for downstream consumers (excluding the initial 0/IMAGEDEF_REACTOR tuple). */
+  tuples: DXFTuple[]
+}
+
+export type UnderlayDefinitionObjectType =
+  | 'UNDERLAYDEFINITION'
+  | 'PDFDEFINITION'
+  | 'DWFDEFINITION'
+  | 'DGNDEFINITION'
+
+export interface UnderlayDefinitionObject {
+  type: UnderlayDefinitionObjectType
+  handle?: string | number
+
+  /** Soft-pointer ID/handle to the owning dictionary (when present). */
+  ownerHandle?: string | number
+
+  /** File name or path of the referenced underlay. */
+  fileName?: string
+
+  /** Underlay name within the file (e.g., sheet name). */
+  underlayName?: string
+
+  /** Raw tuples for downstream consumers (excluding the initial 0/<TYPE> tuple). */
+  tuples: DXFTuple[]
+}
+
 export interface ParsedObjects {
   /** Layout objects */
   layouts: LayoutInternal[]
+
+  /** DICTIONARY objects keyed by handle */
+  dictionaries?: Record<string, DictionaryObject>
+
+  /** XRECORD objects keyed by handle */
+  xRecords?: Record<string, XRecordObject>
+
+  /** IMAGEDEF objects keyed by handle */
+  imageDefs?: Record<string, ImageDefObject>
+
+  /** IMAGEDEF_REACTOR objects keyed by handle */
+  imageDefReactors?: Record<string, ImageDefReactorObject>
+
+  /** UNDERLAYDEFINITION objects keyed by handle */
+  underlayDefinitions?: Record<string, UnderlayDefinitionObject>
 }

package/src/types/tolerance-entity.ts

@@ -0,0 +1,20 @@
+// TOLERANCE entity type (feature control frame)
+
+import type { BaseEntity } from './base-entity'
+import type { Point3D } from './common'
+
+export interface ToleranceEntity extends BaseEntity {
+  type: 'TOLERANCE'
+
+  /** Insertion point (WCS). */
+  insertionPoint: Point3D
+
+  /** Raw tolerance string (may include control codes like %%v). */
+  text?: string
+
+  /** Dimension style name (group code 3). */
+  dimensionStyleName?: string
+
+  /** X-axis direction vector (group codes 11/21/31). */
+  xAxisDirection?: Point3D
+}

package/src/types/underlay-entity.ts

@@ -0,0 +1,35 @@
+// UNDERLAY entity types (DWFUNDERLAY / DGNUNDERLAY / PDFUNDERLAY)
+
+import type { BaseEntity } from './base-entity'
+import type { Point3D } from './common'
+
+export interface UnderlayReferenceEntityBase extends BaseEntity {
+  insertionPoint: Point3D
+  scale: Point3D
+  rotation?: number
+  normal?: Point3D
+
+  /** Hard reference to UNDERLAYDEFINITION object. */
+  underlayDefinitionHandle?: string
+
+  /** Display properties bitmask. */
+  flags?: number
+
+  /** Contrast in range [0, 100]. */
+  contrast?: number
+
+  /** Fade in range [0, 100]. */
+  fade?: number
+}
+
+export interface DwfUnderlayEntity extends UnderlayReferenceEntityBase {
+  type: 'DWFUNDERLAY'
+}
+
+export interface DgnUnderlayEntity extends UnderlayReferenceEntityBase {
+  type: 'DGNUNDERLAY'
+}
+
+export interface PdfUnderlayEntity extends UnderlayReferenceEntityBase {
+  type: 'PDFUNDERLAY'
+}

package/src/util/escapeXmlText.ts

@@ -0,0 +1,10 @@
+export default function escapeXmlText(value: string): string {
+  // Escape text for use inside XML/SVG text nodes.
+  // Keep it small and dependency-free.
+  return value
+    .split('&').join('&')
+    .split('<').join('&lt;')
+    .split('>').join('&gt;')
+    .split('"').join('&quot;')
+    .split("'").join('&apos;')
+}

package/tools/browser_test_server.cjs

@@ -0,0 +1,87 @@
+const http = require('node:http')
+const { createReadStream, existsSync, statSync } = require('node:fs')
+const { extname, join, normalize, resolve } = require('node:path')
+
+const projectRoot = resolve(__dirname, '..')
+const port = Number(process.env.PORT || 4173)
+
+const harnessHtmlPath = join(projectRoot, 'test', 'browser', 'harness.html')
+const distBundlePath = join(projectRoot, 'dist', 'dxf.js')
+const fixturesDir = join(projectRoot, 'test', 'resources')
+
+function sendText(res, statusCode, text, contentType = 'text/plain; charset=utf-8') {
+  res.writeHead(statusCode, { 'Content-Type': contentType })
+  res.end(text)
+}
+
+function contentTypeForPath(filePath) {
+  const ext = extname(filePath).toLowerCase()
+  switch (ext) {
+    case '.html':
+      return 'text/html; charset=utf-8'
+    case '.js':
+      return 'text/javascript; charset=utf-8'
+    case '.dxf':
+      return 'text/plain; charset=utf-8'
+    case '.json':
+      return 'application/json; charset=utf-8'
+    default:
+      return 'application/octet-stream'
+  }
+}
+
+function safeJoin(baseDir, requestedPath) {
+  const cleaned = requestedPath.replace(/^\/+/, '')
+  const target = normalize(join(baseDir, cleaned))
+  const resolvedBase = resolve(baseDir)
+  const resolvedTarget = resolve(target)
+  if (!resolvedTarget.startsWith(resolvedBase + '/')) {
+    return null
+  }
+  return resolvedTarget
+}
+
+const server = http.createServer((req, res) => {
+  const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`)
+  const pathname = url.pathname
+
+  if (pathname === '/' || pathname === '/harness') {
+    if (!existsSync(harnessHtmlPath)) {
+      return sendText(res, 500, 'Missing test/browser/harness.html')
+    }
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+    return createReadStream(harnessHtmlPath).pipe(res)
+  }
+
+  if (pathname === '/dist/dxf.js') {
+    if (!existsSync(distBundlePath)) {
+      return sendText(
+        res,
+        500,
+        'Missing dist/dxf.js. Run `yarn dist` before running browser tests.'
+      )
+    }
+    res.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8' })
+    return createReadStream(distBundlePath).pipe(res)
+  }
+
+  if (pathname.startsWith('/fixtures/')) {
+    const fixtureName = pathname.slice('/fixtures/'.length)
+    const fixturePath = safeJoin(fixturesDir, fixtureName)
+    if (!fixturePath) {
+      return sendText(res, 400, 'Invalid fixture path')
+    }
+    if (!existsSync(fixturePath) || !statSync(fixturePath).isFile()) {
+      return sendText(res, 404, 'Fixture not found')
+    }
+    res.writeHead(200, { 'Content-Type': contentTypeForPath(fixturePath) })
+    return createReadStream(fixturePath).pipe(res)
+  }
+
+  return sendText(res, 404, 'Not found')
+})
+
+server.listen(port, () => {
+  // Used by Playwright webServer readiness checks.
+  console.log(`Browser test server listening on http://localhost:${port}`)
+})