@jscad/dxf-deserializer 2.3.22 → 3.0.0-alpha.0

package/package.json

@@ -1,22 +1,27 @@
 {
   "name": "@jscad/dxf-deserializer",
-  "version": "2.3.22",
+  "version": "3.0.0-alpha.0",
   "description": "DXF Deserializer for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
-  "main": "index.js",
+  "type": "module",
+  "main": "src/index.js",
+  "unpkg": "dist/jscad-dxf-deserializer.min.js",
+  "module": "dist/jscad-dxf-deserializer.es.js",
   "scripts": {
-    "coverage": "nyc --all --reporter=html --reporter=text npm test",
-    "test": "ava --verbose --timeout 2m './tests/test*.js'"
+    "build": "rollup --config",
+    "coverage": "c8 --all --reporter=html --reporter=text pnpm test",
+    "test": "ava --verbose --timeout 2m './tests/test*.js'",
+    "version": "pnpm run build && git add dist"
   },
   "contributors": [
     {
       "name": "z3dev",
-      "url": "http://www.z3d.jp"
+      "url": "https://github.com/z3dev"
     },
     {
       "name": "Mark 'kaosat-dev' Moissette",
-      "url": "http://kaosat.net"
+      "url": "https://github.com/kaosat-dev"
     }
   ],
   "keywords": [
@@ -28,11 +33,16 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@jscad/modeling": "2.12.0"
+    "@jscad/modeling": "3.0.0-alpha.0"
   },
   "devDependencies": {
-    "ava": "3.15.0",
-    "nyc": "15.1.0"
+    "@rollup/plugin-node-resolve": "^15.2.1",
+    "@rollup/plugin-terser": "^0.4.3",
+    "ava": "^4.3.3",
+    "c8": "^8.0.0",
+    "rollup": "^2.79.1",
+    "rollup-plugin-banner": "^0.2.1",
+    "rollup-plugin-version-injector": "^1.3.3"
   },
-  "gitHead": "e269f212db5a00cda740d2f7ad3e5206d1eb839f"
+  "gitHead": "3656d36ed9cd738ab884e86aae5a2ce08d52adf7"
 }

package/rollup.config.js

@@ -0,0 +1,27 @@
+import banner from 'rollup-plugin-banner'
+import { nodeResolve } from '@rollup/plugin-node-resolve'
+import versionInjector from 'rollup-plugin-version-injector'
+import terser from '@rollup/plugin-terser'
+
+export default {
+  input: 'src/index.js',
+
+  output: [
+    {
+      file: 'dist/jscad-dxf-deserializer.min.js',
+      format: 'umd',
+      name: 'jscadDxfDeserializer'
+    },
+    {
+      file: 'dist/jscad-dxf-deserializer.es.js',
+      format: 'es'
+    }
+  ],
+
+  plugins: [
+    nodeResolve(),
+    banner('<%= pkg.description %>\n@module <%= pkg.name %>\n@version <%= pkg.version %>\n@license <%= pkg.license %>'),
+    versionInjector({ injectInComments: { fileRegexp: /\.(html)$/ }, logLevel: 'warn' }),
+    terser({ compress: { module: true }, mangle: false, format: { comments: 'some'} })
+  ]
+}

package/src/DxfReader.js

@@ -0,0 +1,241 @@
+export const reader = (options) => new DxfReader(options)
+
+const STATES = [
+  'start',
+  'end',
+  'error'
+]
+
+/**
+ * Class DxfReader
+ * A class to hold state while reading DXF formatted data.
+ * @param {Object} [options] - options for parsing
+ * @param {Boolean} [options.track=true] - track position for error reporting
+ * @param {Boolean} [options.strict=false] - obey strict DXF specifications
+ * @constructor
+ *
+ * @example
+ * const dxfPath = path.resolve(__dirname, 'circle10.dxf')
+ * let src = fs.readFileSync(dxfPath, 'UTF8')
+ * let reader = dxf.reader({track: true})
+ * // setup state handling
+ * reader.on('error',handleError)
+ * reader.on('start',handleStart)
+ * reader.on('end'  ,handleEnd)
+ * // setup handling for groups of interest, skip the rest
+ * reader.absorb(0,handleEntity)
+ * // start the reader
+ * reader.write(src).close()
+ */
+export class DxfReader {
+  constructor (options) {
+    const defaults = {
+      strict: false,
+      track: true
+    }
+    this.options = Object.assign({ }, defaults, options)
+
+    this.trackPosition = this.options.track
+    if (this.trackPosition) {
+      this.line = 0
+      this.column = 0
+      this.c = 0
+    }
+  }
+
+  // set a handler for the given state
+  // see dxf.STATES above
+  on (state, callback) {
+    // verify the state
+    // set the callback
+    this['on' + state] = callback
+    return this
+  }
+
+  // set a handler for the given group and value
+  absorb (group, callback) {
+    if (this.absorbers === undefined) {
+      this.absorbers = new Map()
+    }
+    this.absorbers.set(group, callback)
+    return this
+  }
+
+  // write the given data into the reader, initiating parsing
+  write (data) {
+    parse(this, data)
+    return this
+  }
+
+  // close and clear all state
+  close () {
+    this.isclosed = true
+    return this
+  }
+}
+
+//
+// emit the start of processing to the onstart handler if any
+//
+const emitstart = (reader) => emitstate(reader, 'onstart', reader.data)
+
+//
+// emit the group (code and value) to asorbers
+//
+const emitgroup = (reader, group, value) => {
+  // emit this group to all listeners
+  if (reader.absorbers !== undefined) {
+    const absorber = reader.absorbers.get(group)
+    if (absorber !== undefined) {
+      absorber(reader, group, value)
+    }
+  }
+}
+
+//
+// wrap and emit the given error to the onerror handler if any
+//
+const emiterror = (reader, er) => {
+  // closeText(reader)
+  if (reader.trackPosition) {
+    er += `
+Line: ${reader.line}
+Column: ${reader.column}
+Char: ${reader.c}`
+  }
+  er = new Error(er)
+  reader.error = er
+  return emitstate(reader, 'onerror', er)
+}
+
+//
+// emit the end of processing to the onend handler if any
+//
+const emitend = (reader) => emitstate(reader, 'onend', reader.data)
+
+const emitstate = (reader, state, data) => {
+  const onhandler = state.toString()
+  reader[onhandler] && reader[onhandler](reader, data)
+  return reader
+}
+
+//
+// parse the given data in the context of the given reader
+//
+const parse = (reader, data) => {
+// check reader state
+  if (reader.error) {
+    throw reader.error // throw the last error
+  }
+  if (reader.isclosed) {
+    return emiterror(reader, 'Cannot write after close')
+  }
+
+  emitstart(reader)
+
+  if (data === null) {
+    return emitend(reader)
+  }
+
+  // initial state to initiate parsing
+  reader.group = null
+  reader.value = null
+  reader.error = null
+
+  reader.position = 0
+  reader.line = 0
+  reader.column = 0
+
+  // use or convert the data to String
+  let i = 0
+  let c = ''
+  let l = ''
+  while (reader.error === null) {
+    c = charAt(data, i++)
+    if (!c) {
+      break
+    }
+    if (reader.trackPosition) {
+      reader.position++
+      if (c === '\n') {
+        reader.line++
+        reader.column = 0
+      } else {
+        reader.column++
+      }
+    }
+    // dxf files are parsed line by line
+    if (c === '\n') {
+      parseLine(reader, l)
+      l = ''
+    } else {
+      l += c
+    }
+  }
+  // emit state change
+  emitend(reader)
+  return reader
+}
+
+/**
+ * Parse the given line in the context of the given reader, emitting group value pairs
+ * @param reader {DxfReader} - context DxfReader to use
+ * @param line {String} - line to parse
+ */
+const parseLine = (reader, line) => {
+  line = line.trim()
+  if (reader.group === null) {
+    setDxfGroup(reader, line)
+    reader.value = null
+  } else {
+    setDxfValue(reader, line)
+  }
+  // handle group and value pairs
+  if (reader.group !== null && reader.value !== null) {
+    // emit events for group and value pairs
+    emitgroup(reader, reader.group, reader.value)
+
+    reader.group = null
+    reader.value = null
+  }
+}
+
+/**
+ * Parse the given line in the context of the given reader, and update the group
+ * @param reader {DxfReader} - context DxfReader to use
+ * @param line {String} - line to parse
+ */
+const setDxfGroup = (reader, line) => {
+// groups are numeric
+  const code = parseInt(line)
+  if (isNaN(code)) {
+    emiterror(reader, 'Invalid group (int)')
+    reader.group = null
+  } else {
+    reader.group = code
+  }
+}
+
+/**
+ * Parse the given line in the context of the given reader, and update the (group) value
+ * @param reader {DxfReader} - context DxfReader to use
+ * @param line {String} - line to parse
+ */
+const setDxfValue = (reader, line) => {
+  if (reader.options.strict) {
+    // TODO evaluate the value based on DXF specifications
+    reader.value = line
+  } else {
+    reader.value = line
+  }
+}
+
+//
+// helper function to return expected values
+//
+const charAt = (data, i) => {
+  if (data && data.length > i) {
+    return data.charAt(i)
+  }
+  return ''
+}

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

@@ -1,11 +1,5 @@
 /*
 AutoCAD Constants
-
-## License
-
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
 */
 
 //
@@ -35,12 +29,12 @@ const dxfTLA = [
 
 const dxfMap = new Map(dxfTLA)
 
-const getTLA = (group) => dxfMap.get(group)
+export const getTLA = (group) => dxfMap.get(group)
 
 /*
  * AutoCAD Drawing Units
  */
-const drawingUnits = [
+export const drawingUnits = [
   [0, 'none'],
   [1, 'inches'],
   [2, 'feet'],
@@ -64,12 +58,5 @@ const drawingUnits = [
   [20, 'parsecs']
 ]
 
-const BYBLOCK = 0
-const BYLAYER = 256
-
-module.exports = {
-  drawingUnits,
-  BYBLOCK,
-  BYLAYER,
-  getTLA
-}
+export const BYBLOCK = 0
+export const BYLAYER = 256

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

@@ -2,7 +2,7 @@
  * AutoCAD 2014 Color Index (1-255) as RGB + ALPHA colors
  */
 
-const colorIndex = [
+export const colorIndex = [
   [0, 0, 0, 255], // index 0, added for easy maintenance
   // 1
   [255, 0, 0, 255],
@@ -286,5 +286,3 @@ const colorIndex = [
   [224, 224, 224, 255],
   [0, 0, 0, 255]
 ]
-
-module.exports = colorIndex

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

@@ -2,7 +2,7 @@
  * AutoCAD 2017 2018 Color Index (1-255) as RGB + ALPHA colors
  */
 
-const colorIndex = [
+export const colorIndex = [
   [0, 0, 0, 255], // index 0, added for easy maintenance
   // 1
   [255, 0, 0, 255],
@@ -286,5 +286,3 @@ const colorIndex = [
   [204, 204, 204, 255],
   [255, 255, 255, 255]
 ]
-
-module.exports = colorIndex

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

@@ -1,18 +1,9 @@
-/*
-## License
-
-Copyright (c) 2017-2019 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
-
-*/
-
-const { BYBLOCK, BYLAYER } = require('./autocad')
+import { BYBLOCK, BYLAYER } from './autocad.js'
 
 //
 // find the layer referenced by the given object
 //
-const findLayer = (obj, layers) => {
+export const findLayer = (obj, layers) => {
   const lname = obj.lnam || '0'
   for (const layer of layers) {
     if (layer.name === lname) {
@@ -26,7 +17,7 @@ const findLayer = (obj, layers) => {
 // get the color number of the object, possibly looking at layer
 // returns -1 if a color number was not found
 //
-const getColorNumber = (obj, layers) => {
+export const getColorNumber = (obj, layers) => {
   let cn = obj.cnmb || -1
   if (cn === BYLAYER) {
     // use the color number from the layer
@@ -50,7 +41,7 @@ const mod = (num, mod) => {
 //
 // instantiate color using the given index into the given color index
 // Note: 0 > index <= length of colorindex
-const getColor = (index, colorindex) => {
+export const getColor = (index, colorindex) => {
   if (index < 1) { return null }
 
   index = mod(index, colorindex.length)
@@ -58,9 +49,3 @@ const getColor = (index, colorindex) => {
   const rgba = [color[0] / 255, color[1] / 255, color[2] / 255, color[3] / 255]
   return rgba
 }
-
-module.exports = {
-  findLayer,
-  getColor,
-  getColorNumber
-}

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

@@ -1,18 +1,10 @@
-/*
-## License
+import { BYLAYER, getTLA } from './autocad.js'
+import { colorIndex } from './colorindex2017.js'
+import { DxfReader } from './DxfReader.js'
+import { instantiateAsciiDxf } from './instantiate.js'
+import { translateAsciiDxf } from './translate.js'
 
-Copyright (c) 2017 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
-
-*/
-
-const version = require('./package.json').version
-const { BYLAYER, getTLA } = require('./autocad')
-const colorIndex = require('./colorindex2017')
-const dxf = require('./DxfReader')
-const { instantiateAsciiDxf } = require('./instantiate')
-const translateAsciiDxf = require('./translate')
+const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 // //////////////////////////////////////////
 //
@@ -490,64 +482,65 @@ const handleName = (reader, group, value) => {
 //
 const createReader = (src, options) => {
   // create a reader for the DXF
-  const reader = dxf.reader(options)
+  const dxfreader = new DxfReader(options)
 
   // setup event handling from the reader
-  reader.on('error', handleError)
-  reader.on('start', handleStart)
-  reader.on('end', handleEnd)
+  dxfreader.on('error', handleError)
+  dxfreader.on('start', handleStart)
+  dxfreader.on('end', handleEnd)
 
   // setup group handling
-  reader.absorb(0, handleEntity)
-  reader.absorb(1, handleString)
-  reader.absorb(2, handleName)
-  reader.absorb(3, handleName)
-  reader.absorb(6, handleString)
-  reader.absorb(7, handleString)
-  reader.absorb(8, handleString)
-  reader.absorb(9, handleVariable)
-  reader.absorb(10, handleXcoord)
-  reader.absorb(11, handleDouble)
-  reader.absorb(12, handleDouble)
-  reader.absorb(13, handleDouble)
-  reader.absorb(20, handleYcoord)
-  reader.absorb(21, handleDouble)
-  reader.absorb(22, handleDouble)
-  reader.absorb(23, handleDouble)
-  reader.absorb(30, handleZcoord)
-  reader.absorb(31, handleDouble)
-  reader.absorb(32, handleDouble)
-  reader.absorb(33, handleDouble)
-  reader.absorb(39, handleDouble)
-  reader.absorb(40, handleDouble)
-  reader.absorb(41, handleDouble)
-  reader.absorb(42, handleBulge)
-  reader.absorb(50, handleDouble)
-  reader.absorb(51, handleDouble)
-  reader.absorb(62, handleInt)
-  reader.absorb(70, handleInt)
-  reader.absorb(71, handleInt)
-  reader.absorb(72, handleInt)
-  reader.absorb(73, handleInt)
-  reader.absorb(74, handleInt)
-  reader.absorb(75, handleInt)
-  reader.absorb(90, handleValue)
-  reader.absorb(91, handleLen) // MESH
-  reader.absorb(92, handleLen) // MESH
-  reader.absorb(93, handleLen) // MESH
-  reader.absorb(94, handleLen) // MESH
-  reader.absorb(95, handleLen) // MESH
-  reader.absorb(210, handleInt)
-  reader.absorb(220, handleInt)
-  reader.absorb(230, handleInt)
+  dxfreader.absorb(0, handleEntity)
+  dxfreader.absorb(1, handleString)
+  dxfreader.absorb(2, handleName)
+  dxfreader.absorb(3, handleName)
+  dxfreader.absorb(6, handleString)
+  dxfreader.absorb(7, handleString)
+  dxfreader.absorb(8, handleString)
+  dxfreader.absorb(9, handleVariable)
+  dxfreader.absorb(10, handleXcoord)
+  dxfreader.absorb(11, handleDouble)
+  dxfreader.absorb(12, handleDouble)
+  dxfreader.absorb(13, handleDouble)
+  dxfreader.absorb(20, handleYcoord)
+  dxfreader.absorb(21, handleDouble)
+  dxfreader.absorb(22, handleDouble)
+  dxfreader.absorb(23, handleDouble)
+  dxfreader.absorb(30, handleZcoord)
+  dxfreader.absorb(31, handleDouble)
+  dxfreader.absorb(32, handleDouble)
+  dxfreader.absorb(33, handleDouble)
+  dxfreader.absorb(39, handleDouble)
+  dxfreader.absorb(40, handleDouble)
+  dxfreader.absorb(41, handleDouble)
+  dxfreader.absorb(42, handleBulge)
+  dxfreader.absorb(50, handleDouble)
+  dxfreader.absorb(51, handleDouble)
+  dxfreader.absorb(62, handleInt)
+  dxfreader.absorb(70, handleInt)
+  dxfreader.absorb(71, handleInt)
+  dxfreader.absorb(72, handleInt)
+  dxfreader.absorb(73, handleInt)
+  dxfreader.absorb(74, handleInt)
+  dxfreader.absorb(75, handleInt)
+  dxfreader.absorb(90, handleValue)
+  dxfreader.absorb(91, handleLen) // MESH
+  dxfreader.absorb(92, handleLen) // MESH
+  dxfreader.absorb(93, handleLen) // MESH
+  dxfreader.absorb(94, handleLen) // MESH
+  dxfreader.absorb(95, handleLen) // MESH
+  dxfreader.absorb(210, handleInt)
+  dxfreader.absorb(220, handleInt)
+  dxfreader.absorb(230, handleInt)
 
   // initial state
-  reader.objstack = []
-  reader.objstack.push({ type: 'dxf' })
+  dxfreader.objstack = []
+  dxfreader.objstack.push({ type: 'dxf' })
 
   // start the reader
-  reader.write(src).close()
-  return reader
+  dxfreader.write(src)
+  dxfreader.close()
+  return dxfreader
 }
 
 //
@@ -603,9 +596,9 @@ const deserialize = (options, src) => {
   return options.output === 'script' ? translate(src, options) : instantiate(src, options)
 }
 
-const extension = 'dxf'
+const mimeType = 'image/vnd.dxf'
 
-module.exports = {
-  deserialize,
-  extension
+export {
+  mimeType,
+  deserialize
 }