@jscad/dxf-deserializer 2.3.27 → 3.0.1-alpha.0

package/{translate.js → src/translate.js}

@@ -1,16 +1,8 @@
-/*
-## License
+import { poly3, vec2, vec3 } from '@jscad/modeling'
 
-Copyright (c) 2017-2019 Z3 Development https://github.com/z3dev
+import { instantiatePolygon, instantiateVector } from './instantiate.js'
 
-All code released under MIT license
-
-*/
-const { maths, geometries } = require('@jscad/modeling')
-
-const { instantiatePolygon, instantiateVector } = require('./instantiate')
-
-const { findLayer, getColor, getColorNumber } = require('./helpers')
+import { findLayer, getColor, getColorNumber } from './helpers.js'
 
 //
 // translate the give 2D vector to JSCAD script
@@ -32,7 +24,7 @@ const translateVector3D = (vector) => {
 // translate the given polygon into JSCAD script
 //
 const translatePolygon = (polygon) => {
-  const vertices = geometries.poly3.toPoints(polygon)
+  const vertices = poly3.toVertices(polygon)
   let script = 'createPolygon(['
   vertices.forEach((vertice) => {
     script += `[${translateVector3D(vertice)}],`
@@ -64,16 +56,16 @@ const translateLine = (obj, layers, options) => {
 
   let script = ''
   if (!obj.pptz || (obj.pptz === obj.sptz && obj.pptz === 0)) {
-    const p1 = maths.vec2.fromValues(obj.pptx, obj.ppty)
-    const p2 = maths.vec2.fromValues(obj.sptx, obj.spty)
-    script = `  let ${name} = primitives.line([[${translateVector2D(p1)}],[${translateVector2D(p2)}]])\n`
+    const p1 = vec2.fromValues(obj.pptx, obj.ppty)
+    const p2 = vec2.fromValues(obj.sptx, obj.spty)
+    script = `  let ${name} = line([[${translateVector2D(p1)}],[${translateVector2D(p2)}]])\n`
   } else {
-    const p1 = maths.vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
-    const p2 = maths.vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
-    script = `  let ${name} = primitives.line([[${translateVector3D(p1)}],[${translateVector3D(p2)}]])\n`
+    const p1 = vec3.fromValues(obj.pptx, obj.ppty, obj.pptz)
+    const p2 = vec3.fromValues(obj.sptx, obj.spty, obj.sptz)
+    script = `  let ${name} = line([[${translateVector3D(p1)}],[${translateVector3D(p2)}]])\n`
   }
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -86,21 +78,21 @@ const translateSection = (name, x1, y1, bulg, px, py) => {
   // console.log('translateSection',x1,y1,bulg,px,py)
   if (bulg === 0) {
   // add straight line to the end of the path
-    return `geometries.path2.appendPoints([[${x1},${y1}]], ${name})
+    return `path2.appendPoints([[${x1},${y1}]], ${name})
 `
   }
 
   // add arc to the end of the path
-  const prev = maths.vec2.fromValues(px, py)
-  const curr = maths.vec2.fromValues(x1, y1)
-  const u = maths.vec2.distance(prev, curr)
+  const prev = vec2.fromValues(px, py)
+  const curr = vec2.fromValues(x1, y1)
+  const u = vec2.distance(prev, curr)
   const r = u * ((1 + Math.pow(bulg, 2)) / (4 * bulg))
   const clockwise = (bulg < 0)
   const large = false // FIXME how to determine?
   const d = Math.atan(bulg) * 4
   // FIXME need to determine segments from object/layer/variables
   const res = 16
-  return `geometries.path2.appendArc({endpoint: [${x1},${y1}],radius: [${r},${r}],xaxisrotation: ${d},clockwise: ${clockwise},large: ${large},segments: ${res}}, ${name})
+  return `path2.appendArc({endpoint: [${x1},${y1}],radius: [${r},${r}],xaxisrotation: ${d},clockwise: ${clockwise},large: ${large},segments: ${res}}, ${name})
 `
 }
 
@@ -122,11 +114,11 @@ const translatePath2D = (obj, layers, options) => {
   const color = getColor(cn, options.colorindex)
 
   // translation
-  let script = `  let ${name} = geometries.path2.create()\n`
+  let script = `  let ${name} = path2.create()\n`
   const isclosed = ((flags & closed) === closed)
   if (vlen === pptxs.length && vlen === pptys.length && vlen === bulgs.length) {
     // add initial point
-    script += `  ${name} = geometries.path2.appendPoints([[${pptxs[0]}, ${pptys[0]}]], ${name})\n`
+    script += `  ${name} = path2.appendPoints([[${pptxs[0]}, ${pptys[0]}]], ${name})\n`
     // add sections
     for (let i = 0; i < pptxs.length; i++) {
       const j = (i + 1) % pptxs.length
@@ -149,12 +141,12 @@ const translatePath2D = (obj, layers, options) => {
     return
   }
   if (isclosed) {
-    script += `  ${name} = geometries.path2.close(${name})\n`
+    script += `  ${name} = path2.close(${name})\n`
   } else {
     script += '\n'
   }
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -186,18 +178,18 @@ const translateArc = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    let script = `  let ${name} = primitives.arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
+    let script = `  let ${name} = arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
     return
   }
   // FIXME how to represent 3D arc?
-  let script = `  let ${name} = primitives.arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
+  let script = `  let ${name} = arc({center: [${pptx}, ${ppty}], radius: ${swid}, startAngle: ${ang0}, endAngle: ${ang1}, segements: ${res}})\n`
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
   obj.script = script
   addToLayer(obj, layers)
@@ -223,9 +215,9 @@ const translateCircle = (obj, layers, options) => {
 
   // convert to 2D object
   if (lthk === 0.0) {
-    let script = `  let ${name} = primitives.circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}})\n`
+    let script = `  let ${name} = circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}})\n`
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
@@ -233,9 +225,9 @@ const translateCircle = (obj, layers, options) => {
   }
 
   // convert to 3D object
-  let script = `  let ${name} = primitives.circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}}).extrude({offset: [0,0,${lthk}]}))\n`
+  let script = `  let ${name} = circle({center: [${pptx}, ${ppty}], radius: ${swid}, segments: ${res}}).extrude({offset: [0,0,${lthk}]}))\n`
   if (color) {
-    script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+    script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
   }
 
   // FIXME need to use 210/220/230 for direction of rotation
@@ -265,19 +257,19 @@ const translateEllipse = (obj, layers, options) => {
 
   // convert to 2D object
   if (pptz === 0.0 && sptz === 0.0) {
-    const center = maths.vec2.fromValues(0, 0)
-    const mjaxis = maths.vec2.fromValues(sptx, spty)
-    const rx = maths.vec2.distance(center, mjaxis)
+    const center = vec2.fromValues(0, 0)
+    const mjaxis = vec2.fromValues(sptx, spty)
+    const rx = vec2.distance(center, mjaxis)
     const ry = rx * swid
     const angle = Math.atan2(spty, sptx) // * 180 / Math.PI
     // FIXME add start and end angle when supported
 
-    let script = `  let ${name} = primitives.ellipse({center: [0, 0, 0], radius: [${rx}, ${ry}], segments: ${res}})
-  let ${name}matrix = maths.mat4.multiply(maths.mat4.create(), maths.mat4.fromTranslation(maths.mat4.create(), [${pptx}, ${ppty}, 0]), maths.mat4.fromZRotation(maths.mat4.create(), ${angle}))
-  ${name} = geometries.geom2.transform(${name}matrix, ${name})
+    let script = `  let ${name} = ellipse({center: [0, 0, 0], radius: [${rx}, ${ry}], segments: ${res}})
+  let ${name}matrix = mat4.multiply(mat4.create(), mat4.fromTranslation(mat4.create(), [${pptx}, ${ppty}, 0]), mat4.fromZRotation(mat4.create(), ${angle}))
+  ${name} = geom2.transform(${name}matrix, ${name})
 `
     if (color) {
-      script += `  ${name} = colors.colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
+      script += `  ${name} = colorize([${color[0]}, ${color[1]}, ${color[2]}, 1], ${name})\n`
     }
     obj.script = script
     addToLayer(obj, layers)
@@ -345,7 +337,7 @@ const translateMesh = (obj, layers, options) => {
         let vi = 0
         while (vi < face.length) {
           const pi = face[vi]
-          const vector = maths.vec3.clone(points[pi])
+          const vector = vec3.clone(points[pi])
           vertices.push(vector)
           vi++
         }
@@ -354,7 +346,7 @@ const translateMesh = (obj, layers, options) => {
         }
         // FIXME how to correct bad normals?
 
-        const poly = geometries.poly3.create(vertices)
+        const poly = poly3.create(vertices)
         if (color) poly.color = color
         polygons.push(poly)
 
@@ -374,7 +366,7 @@ const translateMesh = (obj, layers, options) => {
     script += '    ' + translatePolygon(polygon) + ',\n'
   }
   script += `  ]
-  let ${name} = geometries.geom3.create(${name}_polygons)
+  let ${name} = geom3.create(${name}_polygons)
 `
   obj.script = script
   addToLayer(obj, layers)
@@ -497,8 +489,8 @@ const instantiateFacets = (meshM, meshN, parts, color, options) => {
       if (options.dxf.angdir === 1) {
         facet = facet.reverse()
       }
-      const polygon = geometries.poly3.create(facet)
-      const plane = geometries.poly3.plane(polygon)
+      const polygon = poly3.create(facet)
+      const plane = poly3.plane(polygon)
       if (Number.isFinite(plane[3])) {
         if (color) polygon.color = color
         facets.push(polygon)
@@ -556,7 +548,7 @@ const instantiatePolyFaces = (meshM, meshN, parts, color, options) => {
       if (options.dxf.angdir === 1) {
         vertices = vertices.reverse()
       }
-      const polygon = geometries.poly3.create(vertices)
+      const polygon = poly3.create(vertices)
       faces.push(polygon)
     }
     i++
@@ -640,7 +632,7 @@ const translateCurrent = (obj, layers, parts, options) => {
     script += '    ' + translatePolygon(polygon) + ',\n'
   }
   script += `  ]
-  let ${name} = geometries.geom3.create(${name}_polygons)
+  let ${name} = geom3.create(${name}_polygons)
 `
   if (color) {
     script += `  ${name}.color = [${color}]
@@ -657,7 +649,7 @@ const translateCurrent = (obj, layers, parts, options) => {
 const translateLayer = (layer) => {
   const name = layer.lnam || 'Unknown'
 
-  let script = `function ${name}() {
+  let script = `const ${name} = () => {
 `
   for (const object of layer.objects) {
     script += object.script
@@ -685,7 +677,7 @@ const saveVariable = (obj, options) => {
   }
 }
 
-const translateAsciiDxf = (reader, options) => {
+export const translateAsciiDxf = (reader, options) => {
   // console.log('**************************************************')
   // console.log(JSON.stringify(reader.objstack))
   // console.log('**************************************************')
@@ -815,28 +807,23 @@ const translateAsciiDxf = (reader, options) => {
         break
     }
     // accumlate polygons if necessary
-    if (geometries.poly3.isA(p)) {
-      // console.log('##### push Polygon')
+    if (poly3.isA(p)) {
       parts.push(p)
     }
     // accumlate vectors if necessary
     if (p && 'vec' in p && p.vec.length === 3) {
-      // console.log('##### push vec3')
       parts.push(p)
     }
     if (p && 'vec' in p && p.vec.length === 2) {
-      // console.log('##### push vec2')
       parts.push(p)
     }
   }
   // translate the last object if necessary
   current = translateCurrent(current, layers, parts, options)
 
-  // debug output
-  // console.log('**************************************************')
-  let script = `const {colors, geometries, maths, primitives, transforms} = require('@jscad/modeling')
+  let script = `import * from '@jscad/modeling'
 
-const main = () => {
+export const main = () => {
   let layers = []
   return layers.concat(`
 
@@ -849,10 +836,9 @@ const main = () => {
   // add helper functions for polygons and lines
   script +=
 `
-function createPolygon(listofpoints, color) {
-  let polygon = geometries.poly3.fromPoints(listofpoints)
-  if (color) polygon.color = color
-  return polygon
+const createPolygon = (listofpoints, color) => {
+  let polygon = poly3.create(listofpoints)
+  return colorize(color, polygon)
 }
 `
 
@@ -860,11 +846,5 @@ function createPolygon(listofpoints, color) {
     script += translateLayer(layer)
   })
 
-  script += 'module.exports = {main}\n'
-
-  // console.log(script)
-  // console.log('**************************************************')
   return script
 }
-
-module.exports = translateAsciiDxf

package/tests/test-2d-entities.js

@@ -1,12 +1,13 @@
-const fs = require('fs')
-const path = require('path')
-const test = require('ava')
+import fs from 'fs'
+import path from 'path'
 
-const { geometries } = require('@jscad/modeling')
+import test from 'ava'
 
-const { deserialize } = require('../index')
+import { geom2, path2 } from '@jscad/modeling'
 
-const samplesPath = path.dirname(require.resolve('@jscad/sample-files/package.json'))
+import { deserialize } from '../src/index.js'
+
+const samplesPath = '../../../node_modules/@jscad/sample-files'
 
 //
 // Test suite for DXF deserialization (import)
@@ -21,7 +22,7 @@ test('ASCII DXF 2D Entities from JSCAD to Object Conversion', (t) => {
   // expect one layer, containing 1 objects (path2)
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
-  t.true(geometries.path2.isA(objs[0]))
+  t.true(path2.isA(objs[0]))
   t.true(objs[0].isClosed)
 
   dxfPath = path.resolve(samplesPath, 'dxf/jscad/circle10.dxf')
@@ -33,9 +34,9 @@ test('ASCII DXF 2D Entities from JSCAD to Object Conversion', (t) => {
   // expect one layer, containing 1 objects (path2)
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
-  t.true(geometries.path2.isA(objs[0]))
+  t.true(path2.isA(objs[0]))
   t.true(objs[0].isClosed)
-  t.is(geometries.path2.toPoints(objs[0]).length, 32) // path
+  t.is(path2.toPoints(objs[0]).length, 32) // path
 })
 
 test('ASCII DXF 2D Lines from Autocad 2017 to Object Conversion', (t) => {
@@ -49,12 +50,12 @@ test('ASCII DXF 2D Lines from Autocad 2017 to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 23)
   // NOTE: the extra objects are from the page layout
-  t.true(geometries.path2.isA(objs[20]))
-  t.is(geometries.path2.toPoints(objs[20]).length, 2) // line
-  t.true(geometries.path2.isA(objs[21]))
-  t.is(geometries.path2.toPoints(objs[21]).length, 2) // line
-  t.true(geometries.path2.isA(objs[22]))
-  t.is(geometries.path2.toPoints(objs[22]).length, 2) // line
+  t.true(path2.isA(objs[20]))
+  t.is(path2.toPoints(objs[20]).length, 2) // line
+  t.true(path2.isA(objs[21]))
+  t.is(path2.toPoints(objs[21]).length, 2) // line
+  t.true(path2.isA(objs[22]))
+  t.is(path2.toPoints(objs[22]).length, 2) // line
 })
 
 test('ASCII DXF 2D Circles from Autocad 2017 to Object Conversion', (t) => {
@@ -68,11 +69,11 @@ test('ASCII DXF 2D Circles from Autocad 2017 to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 23)
   // NOTE: the extra objects are from the page layout
-  t.true(geometries.path2.isA(objs[20]))
-  t.true(geometries.geom2.isA(objs[21]))
-  t.is(geometries.geom2.toSides(objs[21]).length, 16) // circle
-  t.true(geometries.geom2.isA(objs[22]))
-  t.is(geometries.geom2.toSides(objs[22]).length, 16) // circle
+  t.true(path2.isA(objs[20]))
+  t.true(geom2.isA(objs[21]))
+  t.is(geom2.toPoints(objs[21]).length, 16) // circle
+  t.true(geom2.isA(objs[22]))
+  t.is(geom2.toPoints(objs[22]).length, 16) // circle
 })
 
 test('ASCII DXF 2D Rectangles from Autocad 2017 to Object Conversion', (t) => {
@@ -87,14 +88,14 @@ test('ASCII DXF 2D Rectangles from Autocad 2017 to Object Conversion', (t) => {
   t.is(objs.length, 23)
   // NOTE: the extra objects are from the page layout
   let obj = objs[20]
-  t.true(geometries.path2.isA(obj))
-  t.is(geometries.path2.toPoints(obj).length, 4) // rectangle
+  t.true(path2.isA(obj))
+  t.is(path2.toPoints(obj).length, 4) // rectangle
   obj = objs[21]
-  t.true(geometries.path2.isA(obj))
-  t.is(geometries.path2.toPoints(obj).length, 4) // rectangle
+  t.true(path2.isA(obj))
+  t.is(path2.toPoints(obj).length, 4) // rectangle
   obj = objs[22]
-  t.true(geometries.path2.isA(obj))
-  t.is(geometries.path2.toPoints(obj).length, 4) // rectangle
+  t.true(path2.isA(obj))
+  t.is(path2.toPoints(obj).length, 4) // rectangle
 })
 
 test('ASCII DXF 2D Donuts from Autocad 2017 to Object Conversion', (t) => {
@@ -108,12 +109,12 @@ test('ASCII DXF 2D Donuts from Autocad 2017 to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 23)
   // NOTE: the extra ojbects are from the page layout
-  t.true(geometries.path2.isA(objs[20]))
-  t.is(geometries.path2.toPoints(objs[20]).length, 18) // line
-  t.true(geometries.path2.isA(objs[21]))
-  t.is(geometries.path2.toPoints(objs[21]).length, 18) // line
-  t.true(geometries.path2.isA(objs[22]))
-  t.is(geometries.path2.toPoints(objs[22]).length, 18) // arc
+  t.true(path2.isA(objs[20]))
+  t.is(path2.toPoints(objs[20]).length, 18) // line
+  t.true(path2.isA(objs[21]))
+  t.is(path2.toPoints(objs[21]).length, 18) // line
+  t.true(path2.isA(objs[22]))
+  t.is(path2.toPoints(objs[22]).length, 18) // arc
 })
 
 test('ASCII DXF 2D Ellipses from Autocad 2017 to Object Conversion', (t) => {
@@ -127,9 +128,9 @@ test('ASCII DXF 2D Ellipses from Autocad 2017 to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 23)
   // NOTE: the extra ojbects are from the page layout
-  t.true(geometries.geom2.isA(objs[20]))
-  t.true(geometries.geom2.isA(objs[21]))
-  t.true(geometries.geom2.isA(objs[22]))
+  t.true(geom2.isA(objs[20]))
+  t.true(geom2.isA(objs[21]))
+  t.true(geom2.isA(objs[22]))
 })
 
 test('ASCII DXF 2D Arcs from Autocad 2017 to Object Conversion', (t) => {
@@ -143,9 +144,9 @@ test('ASCII DXF 2D Arcs from Autocad 2017 to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 23)
   // NOTE: the extra ojbects are from the page layout
-  t.true(geometries.path2.isA(objs[20]))
-  t.true(geometries.path2.isA(objs[21]))
-  t.true(geometries.path2.isA(objs[22]))
+  t.true(path2.isA(objs[20]))
+  t.true(path2.isA(objs[21]))
+  t.true(path2.isA(objs[22]))
 })
 
 // HATCH as what ?

package/tests/test-2d-translation.js

@@ -1,6 +1,6 @@
-const test = require('ava')
+import test from 'ava'
 
-const { deserialize } = require('../index')
+import { deserialize } from '../src/index.js'
 
 //
 // Test suite for DXF deserialization (import)
@@ -10,9 +10,9 @@ test('ASCII DXF 2D Entities translated to JSCAD Scripts', (t) => {
   const dxf1 = ''
   const src1 = deserialize({ filename: 'dxf1 test', output: 'script' }, dxf1)
   const ss1 = src1.split('\n')
-  t.is(ss1.length, 16)
+  t.is(ss1.length, 14)
   t.true(src1.indexOf('main = ()') > 0)
-  t.true(src1.indexOf('createPolygon(') > 0)
+  t.true(src1.indexOf('createPolygon = (') > 0)
 
   // DXF CIRCLE, translates to script with a 'circle' function
   const dxf2 = `0
@@ -37,10 +37,10 @@ CIRCLE
 ENDSEC`
   const src2 = deserialize({ filename: 'dxf2 test', output: 'script' }, dxf2)
   const ss2 = src2.split('\n')
-  t.is(ss2.length, 21)
+  t.is(ss2.length, 19)
   t.true(src2.indexOf('main = ()') > 0)
   t.true(src2.indexOf('circle(') > 0)
-  t.true(src2.indexOf('colors.colorize(') > 0)
+  t.true(src2.indexOf('colorize(') > 0)
 
   // DXF LINE, translates to script with a 'line' created from points
   const dxf3 = `0
@@ -65,7 +65,7 @@ LINE
 ENDSEC`
   const src3 = deserialize({ filename: 'dxf3-test', output: 'script' }, dxf3)
   const ss3 = src3.split('\n')
-  t.is(ss3.length, 20)
+  t.is(ss3.length, 18)
   t.true(src3.indexOf('main = ()') > 0)
   t.true(src3.indexOf('line(') > 0)
 
@@ -102,7 +102,7 @@ AcDbArc
 ENDSEC`
   const src4 = deserialize({ filename: 'dxf4-test', output: 'script' }, dxf4)
   const ss4 = src4.split('\n')
-  t.is(ss4.length, 20)
+  t.is(ss4.length, 18)
   t.true(src4.indexOf('main = ()') > 0)
   t.true(src4.indexOf('arc(') > 0)
 
@@ -139,7 +139,7 @@ LWPOLYLINE
 ENDSEC`
   const src5 = deserialize({ filename: 'dxf5-test', output: 'script' }, dxf5)
   const ss5 = src5.split('\n')
-  t.is(ss5.length, 25)
+  t.is(ss5.length, 23)
   t.true(src5.indexOf('main = ()') > 0)
   t.true(src5.indexOf('path2.create(') > 0)
   t.true(src5.indexOf('path2.appendPoints(') > 0)
@@ -186,13 +186,13 @@ LWPOLYLINE
 ENDSEC`
   const src6 = deserialize({ filename: 'dxf6-test', output: 'script' }, dxf6)
   const ss6 = src6.split('\n')
-  t.is(ss6.length, 26)
+  t.is(ss6.length, 24)
   t.true(src6.indexOf('main = ()') > 0)
   t.true(src6.indexOf('path2.create(') > 0)
   t.true(src6.indexOf('path2.appendPoints(') > 0)
   t.true(src6.indexOf('path2.appendArc(') > 0)
   t.true(src6.indexOf('path2.close(') > 0)
-  t.true(src6.indexOf('fromPoints(') > 0)
+  t.true(src6.indexOf('poly3.create(') > 0)
 
   // DXF ELLIPSE, translates to script with a 'ellipse' function
   const dxf7 = `0
@@ -231,7 +231,7 @@ ELLIPSE
 ENDSEC`
   const src7 = deserialize({ filename: 'dxf7-test', output: 'script' }, dxf7)
   const ss7 = src7.split('\n')
-  t.is(ss7.length, 22)
+  t.is(ss7.length, 20)
   t.true(src7.indexOf('main = ()') > 0)
   t.true(src7.indexOf('ellipse(') > 0)
 })
@@ -290,7 +290,7 @@ SEQEND
 ENDSEC`
   const src1 = deserialize({ filename: 'dxf1-test', output: 'script' }, dxf1)
   const ss1 = src1.split('\n')
-  t.is(ss1.length, 23)
+  t.is(ss1.length, 21)
   t.true(src1.indexOf('path2.create(') > 0)
   t.true(src1.indexOf('appendPoints(') > 0)
 
@@ -337,7 +337,7 @@ SEQEND
 ENDSEC`
   const src2 = deserialize({ filename: 'dxf2-test', output: 'script' }, dxf2)
   const ss2 = src2.split('\n')
-  t.is(ss2.length, 24)
+  t.is(ss2.length, 22)
   t.true(src2.indexOf('path2.create(') > 0)
   t.true(src2.indexOf('appendPoints(') > 0)
   t.true(src2.indexOf('appendArc(') > 0)
@@ -389,8 +389,8 @@ SEQEND
 ENDSEC`
   const src3 = deserialize({ filename: 'dxf3-test', output: 'script' }, dxf3)
   const ss3 = src3.split('\n')
-  t.is(ss3.length, 23)
-  t.true(src3.indexOf('function layer0(') > 0)
-  t.true(src3.indexOf('function layer1(') > 0)
+  t.is(ss3.length, 21)
+  t.true(src3.indexOf('const layer0 = (') > 0)
+  t.true(src3.indexOf('const layer1 = (') > 0)
   t.true(src3.indexOf('circle(') > 0)
 })

package/tests/test-3d-entities.js

@@ -1,12 +1,12 @@
-const fs = require('fs')
-const path = require('path')
-const test = require('ava')
+import fs from 'fs'
+import path from 'path'
+import test from 'ava'
 
-const { geometries } = require('@jscad/modeling')
+import { geom3, path2 } from '@jscad/modeling'
 
-const { deserialize } = require('../index')
+import { deserialize } from '../src/index.js'
 
-const samplesPath = path.dirname(require.resolve('@jscad/sample-files/package.json'))
+const samplesPath = '../../../node_modules/@jscad/sample-files'
 
 //
 // Test suite for DXF deserialization (import)
@@ -21,7 +21,7 @@ test('ASCII DXF from Bourke 3D Entities to Object Conversion', (t) => {
   // expect one layer, containing 2 objects (geom3 and line3)
   t.true(Array.isArray(objs))
   t.is(objs.length, 2)
-  t.true(geometries.geom3.isA(objs[0]))
+  t.true(geom3.isA(objs[0]))
   // t.true(objs[1] instanceof CSG.Line3D)
 })
 
@@ -37,7 +37,7 @@ test('ASCII DXF from JSCAD 3D Shapes to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
   let csg = objs[0]
-  t.true(geometries.geom3.isA(csg))
+  t.true(geom3.isA(csg))
 
   // instantiate from a simple shape
   dxfPath = path.resolve(samplesPath, 'dxf/jscad/cube.dxf')
@@ -50,7 +50,7 @@ test('ASCII DXF from JSCAD 3D Shapes to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
   csg = objs[0]
-  t.true(geometries.geom3.isA(csg))
+  t.true(geom3.isA(csg))
 
   // instantiate from a simple shape
   dxfPath = path.resolve(samplesPath, 'dxf/jscad/sphere.dxf')
@@ -63,7 +63,7 @@ test('ASCII DXF from JSCAD 3D Shapes to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
   csg = objs[0]
-  t.true(geometries.geom3.isA(csg))
+  t.true(geom3.isA(csg))
 
   // instantiate from a simple shape
   dxfPath = path.resolve(samplesPath, 'dxf/jscad/cylinder.dxf')
@@ -76,7 +76,7 @@ test('ASCII DXF from JSCAD 3D Shapes to Object Conversion', (t) => {
   t.true(Array.isArray(objs))
   t.is(objs.length, 1)
   csg = objs[0]
-  t.true(geometries.geom3.isA(csg))
+  t.true(geom3.isA(csg))
 })
 
 test('ASCII DXF from Autocad2017 3D Lines to Object Conversion', (t) => {
@@ -91,11 +91,11 @@ test('ASCII DXF from Autocad2017 3D Lines to Object Conversion', (t) => {
   t.is(objs.length, 3)
 
   let obj = objs[0]
-  t.true(geometries.path2.isA(obj))
+  t.true(path2.isA(obj))
   obj = objs[1]
-  t.true(geometries.path2.isA(obj))
+  t.true(path2.isA(obj))
   obj = objs[2]
-  t.true(geometries.path2.isA(obj)) // FYI the DXF is incorrect
+  t.true(path2.isA(obj)) // FYI the DXF is incorrect
 })
 
 test('ASCII DXF from Autocad2017 3D Boxes to Object Conversion', (t) => {
@@ -134,8 +134,8 @@ test('ASCII DXF from exdxf 3D Mesh to Object Conversion', (t) => {
   t.is(objs.length, 5)
 
   const obj4 = objs[4]
-  t.true(geometries.geom3.isA(obj4))
-  t.is(geometries.geom3.toPolygons(obj4).length, 6)
+  t.true(geom3.isA(obj4))
+  t.is(geom3.toPolygons(obj4).length, 6)
 })
 
 test('ASCII DXF from Autocad2017 3D Mesh to Object Conversion', (t) => {
@@ -150,8 +150,8 @@ test('ASCII DXF from Autocad2017 3D Mesh to Object Conversion', (t) => {
   t.is(objs.length, 2)
 
   const obj0 = objs[0]
-  t.is(geometries.geom3.toPolygons(obj0).length, 54)
+  t.is(geom3.toPolygons(obj0).length, 54)
 
   const obj1 = objs[1]
-  t.is(geometries.geom3.toPolygons(obj1).length, 54)
+  t.is(geom3.toPolygons(obj1).length, 54)
 })