@jscad/x3d-deserializer 2.2.5 → 3.0.0-alpha.0

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@jscad/x3d-deserializer",
-  "version": "2.2.5",
+  "version": "3.0.0-alpha.0",
   "description": "X3D Deserializer for JSCAD",
+  "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org/",
+  "type": "module",
   "main": "src/index.js",
+  "unpkg": "dist/jscad-x3d-deserializer.min.js",
+  "module": "dist/jscad-x3d-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": [
     {
@@ -26,13 +32,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@jscad/array-utils": "2.1.4",
-    "@jscad/modeling": "2.12.0",
-    "saxes": "5.0.1"
+    "@jscad/array-utils": "3.0.0-alpha.0",
+    "@jscad/modeling": "3.0.0-alpha.0",
+    "saxes": "^6.0.0"
   },
   "devDependencies": {
-    "ava": "3.15.0",
-    "nyc": "15.1.0"
+    "@rollup/plugin-commonjs": "^23.0.4",
+    "@rollup/plugin-node-resolve": "^15.0.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,29 @@
+import banner from 'rollup-plugin-banner'
+import commonjs from '@rollup/plugin-commonjs'
+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-x3d-deserializer.min.js',
+      format: 'umd',
+      name: 'jscadX3dDeserializer'
+    },
+    {
+      file: 'dist/jscad-x3d-deserializer.es.js',
+      format: 'es'
+    }
+  ],
+
+  plugins: [
+    commonjs(),
+    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/constants.js

@@ -1,5 +1 @@
-const inchMM = (1 / 0.039370) // used for scaling AMF (inch) to coordinates (mm)
-
-module.exports = {
-  inchMM
-}
+export const inchMM = (1 / 0.039370) // used for scaling AMF (inch) to coordinates (mm)

package/src/createTransform.js

@@ -1,17 +1,15 @@
-const { maths } = require('@jscad/modeling')
+import { mat4, vec3 } from '@jscad/modeling'
 
-const createTransform = (center, rotation, scale, scaleOrientation, translation) => {
-  const matrix = maths.mat4.create()
-  const temp = maths.mat4.create()
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromTranslation(temp, translation))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromTranslation(temp, center))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromRotation(temp, rotation[3], rotation))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromRotation(temp, scaleOrientation[3], scaleOrientation))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromScaling(temp, scale))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromRotation(temp, scaleOrientation[3], maths.vec3.negate(maths.vec3.create(), scaleOrientation)))
-  maths.mat4.multiply(matrix, matrix, maths.mat4.fromTranslation(temp, maths.vec3.negate(maths.vec3.create(), center)))
+export const createTransform = (center, rotation, scale, scaleOrientation, translation) => {
+  const matrix = mat4.create()
+  const temp = mat4.create()
+  mat4.multiply(matrix, matrix, mat4.fromTranslation(temp, translation))
+  mat4.multiply(matrix, matrix, mat4.fromTranslation(temp, center))
+  mat4.multiply(matrix, matrix, mat4.fromRotation(temp, rotation[3], rotation))
+  mat4.multiply(matrix, matrix, mat4.fromRotation(temp, scaleOrientation[3], scaleOrientation))
+  mat4.multiply(matrix, matrix, mat4.fromScaling(temp, scale))
+  mat4.multiply(matrix, matrix, mat4.fromRotation(temp, scaleOrientation[3], vec3.negate(vec3.create(), scaleOrientation)))
+  mat4.multiply(matrix, matrix, mat4.fromTranslation(temp, vec3.negate(vec3.create(), center)))
 
   return matrix
 }
-
-module.exports = createTransform

package/src/extrudeX3D.js

@@ -1,7 +1,4 @@
-const { extrusions, geometries, maths } = require('@jscad/modeling')
-
-const { mat4, vec3, utils } = maths
-const { extrudeFromSlices, slice } = extrusions
+import { extrudeFromSlices, geom2, mat4, poly2, slice, vec3 } from '@jscad/modeling'
 
 const calculateYaxes = (spine) => {
   const slength = spine.length
@@ -128,12 +125,11 @@ const rotationMatrixFromSCP = (out, xaxis, yaxis, zaxis) => {
   return out
 }
 
-const extrudeX3D = (x3dshape) => {
-  // console.log(x3dshape)
+export const extrudeX3D = (x3dshape) => {
   let { beginCap, endCap, crossSection, orientations, scales, spine } = Object.assign({}, x3dshape)
 
   // orientate the crossection for extruding
-  if (utils.area(crossSection) < 0) crossSection.reverse()
+  if (poly2.measureArea(poly2.create(crossSection)) < 0) crossSection.reverse()
 
   // complete scales if necessary
   if (scales.length === 1) {
@@ -151,16 +147,13 @@ const extrudeX3D = (x3dshape) => {
   }
 
   // Create the initial slice
-  const initialShape = geometries.geom2.fromPoints(crossSection)
-  const initialSlice = slice.fromSides(geometries.geom2.toSides(initialShape))
+  const initialShape = geom2.create([crossSection])
+  const initialSlice = slice.fromGeom2(initialShape)
 
   // Calculate SCP values
   let yaxes = calculateYaxes(spine)
-  // console.log(yaxes)
   let zaxes = calculateZaxes(spine)
-  // console.log(zaxes)
   let xaxes = calculateXaxes(yaxes, zaxes)
-  // console.log(xaxes)
 
   // initial Y=0 matrix
   const y0direction = [0, 1, 0]
@@ -212,5 +205,3 @@ const extrudeX3D = (x3dshape) => {
     }
   }, initialSlice)
 }
-
-module.exports = extrudeX3D

package/src/index.js

@@ -1,11 +1,3 @@
-/*
-## License
-
-Copyright (c) 2021 Z3 Development https://github.com/z3dev
-
-All code released under MIT license
-*/
-
 // //////////////////////////////////////////
 //
 // Extensible 3D (X3D) Graphics is the open standard for publishing, viewing, printing and archiving interactive 3D models
@@ -21,10 +13,10 @@ All code released under MIT license
  * const { deserializer, extension } = require('@jscad/x3d-deserializer')
  */
 
-const version = require('../package.json').version
+import { translate } from './translate.js'
+import { instantiate } from './instantiate.js'
 
-const translate = require('./translate')
-const instantiate = require('./instantiate')
+const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 /**
  * Deserialize the given X3D source (XML Encoding) into either a script or an array of geometry
@@ -52,9 +44,9 @@ const deserialize = (options, input) => {
   return options.output === 'script' ? translate(options, input) : instantiate(options, input)
 }
 
-const extension = 'x3d'
+const mimeType = 'model/x3d+xml'
 
-module.exports = {
-  deserialize,
-  extension
+export {
+  mimeType,
+  deserialize
 }

package/src/instantiate.js

@@ -1,20 +1,18 @@
-const { flatten } = require('@jscad/array-utils')
+import { flatten } from '@jscad/array-utils'
 
-const parse = require('./parse')
-const instantiateDefinitions = require('./instantiateDefinitions')
-const { x3dTypes } = require('./objects')
+import { parse } from './parse.js'
+import { instantiateDefinitions } from './instantiateDefinitions.js'
+import { x3dTypes } from './objects.js'
 
-const instantiate = (options, src) => {
+export const instantiate = (options, src) => {
   const defaults = {
-    pxPmm: require('./constants').pxPmm
   }
   options = Object.assign({}, defaults, options)
-  const { pxPmm } = options
 
   options && options.statusCallback && options.statusCallback({ progress: 0 })
 
   // parse the X3D source
-  const { x3dObj } = parse(src, pxPmm)
+  const { x3dObj } = parse(src)
 
   if (x3dObj.definition !== x3dTypes.X3D || (!x3dObj.objects)) throw new Error('X3D malformed')
   if (x3dObj.objects.length < 1 || x3dObj.objects[0].definition !== x3dTypes.SCENE) throw new Error('X3D did not define a SCENE')
@@ -32,5 +30,3 @@ const instantiate = (options, src) => {
 
   return geometries
 }
-
-module.exports = instantiate

package/src/instantiateDefinitions.js

@@ -1,13 +1,13 @@
-const { colors, transforms } = require('@jscad/modeling')
+import { colorize, transform } from '@jscad/modeling'
 
-const createTransform = require('./createTransform')
+import { createTransform } from './createTransform.js'
 
-const { x3dTypes } = require('./objects')
-const { findColor } = require('./translateHelpers')
+import { x3dTypes } from './objects.js'
+import { findColor } from './translateHelpers.js'
 
-const instantiatePrimitive = require('./instantiatePrimitive')
-const { instantiateLine } = require('./instantiateLine')
-const { instantiateMesh } = require('./instantiateMesh')
+import { instantiatePrimitive } from './instantiatePrimitive.js'
+import { instantiateLine } from './instantiateLine.js'
+import { instantiateMesh } from './instantiateMesh.js'
 
 const instantiatedList = new Map()
 
@@ -21,7 +21,7 @@ const instantiateTransform = (options, object) => {
 
   return geometries.map((geometry) => {
     const color = geometry.color
-    geometry = transforms.transform(matrix, geometry)
+    geometry = transform(matrix, geometry)
     if (color) geometry.color = color
     return geometry
   })
@@ -38,7 +38,7 @@ const instantiateShape = (options, object) => {
   if (!geometry) geometry = null
 
   if (geometry && color) {
-    geometry = colors.colorize(color, geometry)
+    geometry = colorize(color, geometry)
   }
   return geometry
 }
@@ -69,12 +69,10 @@ const instantiateDefinition = (options, object) => {
   return geometry
 }
 
-const instantiateDefinitions = (options, objects) => {
+export const instantiateDefinitions = (options, objects) => {
   const geometries = objects.map((object) => instantiateDefinition(options, object)).filter((g) => g != null)
 
   instantiatedList.clear()
 
   return geometries
 }
-
-module.exports = instantiateDefinitions

package/src/instantiateLine.js

@@ -1,9 +1,9 @@
-const jscad = require('@jscad/modeling')
+import { colorize, line } from '@jscad/modeling'
 
-const { createColors, findNode } = require('./translateHelpers')
-const { x3dTypes } = require('./objects')
+import { createColors, findNode } from './translateHelpers.js'
+import { x3dTypes } from './objects.js'
 
-const convertLine = (options, objects) => {
+export const convertLine = (options, objects) => {
   let shape = findNode(x3dTypes.INDEXEDLINESET, objects)
   if (shape) {
     const coordinate = findNode(x3dTypes.COORDINATE, shape.objects)
@@ -71,27 +71,22 @@ const convertLine = (options, objects) => {
   return null
 }
 
-const instantiateLine = (options, objects) => {
+export const instantiateLine = (options, objects) => {
   let geometry
 
   const components = convertLine(options, objects)
   if (components) {
-    const { pointsSet, colors } = components
+    const { pointsSet, segColors } = components
     geometry = pointsSet.map((points, i) => {
-      let line
-      if (colors) {
-        line = jscad.colors.colorize(colors[i], jscad.primitives.line(points))
+      let l
+      if (segColors) {
+        l = colorize(segColors[i], line(points))
       } else {
-        line = jscad.primitives.line(points)
+        l = line(points)
       }
-      return line
+      return l
     })
   }
 
   return geometry
 }
-
-module.exports = {
-  convertLine,
-  instantiateLine
-}

package/src/instantiateMesh.js

@@ -1,9 +1,9 @@
-const { primitives } = require('@jscad/modeling')
+import { polyhedron } from '@jscad/modeling'
 
-const { x3dTypes } = require('./objects')
-const { findNode, createColors } = require('./translateHelpers')
+import { x3dTypes } from './objects.js'
+import { findNode, createColors } from './translateHelpers.js'
 
-const convertMesh = (options, objects) => {
+export const convertMesh = (options, objects) => {
   let shape = findNode(x3dTypes.TRIANGLESET, objects)
   if (shape) {
     const coordinate = findNode(x3dTypes.COORDINATE, shape.objects)
@@ -277,17 +277,12 @@ const convertMesh = (options, objects) => {
   return null
 }
 
-const instantiateMesh = (options, objects) => {
+export const instantiateMesh = (options, objects) => {
   let geometry
 
   const components = convertMesh(options, objects)
   if (components) {
-    geometry = primitives.polyhedron(components)
+    geometry = polyhedron(components)
   }
   return geometry
 }
-
-module.exports = {
-  convertMesh,
-  instantiateMesh
-}

package/src/instantiatePrimitive.js

@@ -1,24 +1,37 @@
-const { booleans, geometries, primitives, transforms } = require('@jscad/modeling')
-
-const { x3dTypes } = require('./objects')
-const { findNode } = require('./translateHelpers')
-
-const extrudeX3D = require('./extrudeX3D')
-
-const instantiatePrimitive = (options, objects) => {
+import {
+  arc,
+  circle,
+  cuboid,
+  cylinder,
+  cylinderElliptic,
+  geom2,
+  line,
+  path2,
+  rectangle,
+  rotateX,
+  sphere,
+  subtract
+} from '@jscad/modeling'
+
+import { x3dTypes } from './objects.js'
+import { findNode } from './translateHelpers.js'
+
+import { extrudeX3D } from './extrudeX3D.js'
+
+export const instantiatePrimitive = (options, objects) => {
   let geometry
 
   // 3D primitives
 
   let object = findNode(x3dTypes.BOX, objects)
   if (object) {
-    geometry = primitives.cuboid({ size: object.size })
+    geometry = cuboid({ size: object.size })
     return geometry
   }
 
   object = findNode(x3dTypes.CONE, objects)
   if (object) {
-    geometry = transforms.rotateX(-Math.PI / 2, primitives.cylinderElliptic({
+    geometry = rotateX(-Math.PI / 2, cylinderElliptic({
       startRadius: [object.bottomRadius, object.bottomRadius],
       height: object.height,
       segments: object.subdivision,
@@ -29,7 +42,7 @@ const instantiatePrimitive = (options, objects) => {
 
   object = findNode(x3dTypes.CYLINDER, objects)
   if (object) {
-    geometry = transforms.rotateX(-Math.PI / 2, primitives.cylinder({
+    geometry = rotateX(-Math.PI / 2, cylinder({
       radius: object.radius,
       height: object.height,
       segments: object.subdivision
@@ -39,7 +52,7 @@ const instantiatePrimitive = (options, objects) => {
 
   object = findNode(x3dTypes.SPHERE, objects)
   if (object) {
-    geometry = primitives.sphere({ radius: object.radius, segments: object.subdivision })
+    geometry = sphere({ radius: object.radius, segments: object.subdivision })
     return geometry
   }
 
@@ -53,18 +66,18 @@ const instantiatePrimitive = (options, objects) => {
 
   object = findNode(x3dTypes.ARC2D, objects)
   if (object) {
-    geometry = primitives.arc({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
+    geometry = arc({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
     return geometry
   }
 
   object = findNode(x3dTypes.ARCCLOSE2D, objects)
   if (object) {
     if (object.closureType === 'PIE') {
-      geometry = primitives.circle({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
+      geometry = circle({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
     } else {
-      geometry = geometries.geom2.fromPoints(geometries.path2.toPoints(geometries.path2.close(
-        primitives.arc({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
-      )))
+      geometry = geom2.create([path2.toPoints(path2.close(
+        arc({ radius: object.radius, startAngle: object.startAngle, endAngle: object.endAngle, segments: object.subdivision })
+      ))])
     }
     return geometry
   }
@@ -72,19 +85,19 @@ const instantiatePrimitive = (options, objects) => {
   object = findNode(x3dTypes.CIRCLE2D, objects)
   if (object) {
     // NOTE: X3D circles are really closed arcs (lines)
-    geometry = primitives.arc({ radius: object.radius, segments: object.subdivision })
+    geometry = arc({ radius: object.radius, segments: object.subdivision })
     return geometry
   }
 
   object = findNode(x3dTypes.DISK2D, objects)
   if (object) {
     if (object.innerRadius === object.outerRadius) {
-      geometry = primitives.arc({ radius: object.outerRadius, segments: object.subdivision })
+      geometry = arc({ radius: object.outerRadius, segments: object.subdivision })
     } else {
       if (object.innerRadius === 0) {
-        geometry = primitives.circle({ radius: object.outerRadius, segments: object.subdivision })
+        geometry = circle({ radius: object.outerRadius, segments: object.subdivision })
       } else {
-        geometry = booleans.subtract(primitives.circle({ radius: object.outerRadius, segments: object.subdivision }), primitives.circle({ radius: object.innerRadius, segments: object.subdivision }))
+        geometry = subtract(circle({ radius: object.outerRadius, segments: object.subdivision }), circle({ radius: object.innerRadius, segments: object.subdivision }))
       }
     }
     return geometry
@@ -92,13 +105,13 @@ const instantiatePrimitive = (options, objects) => {
 
   object = findNode(x3dTypes.POLYLINE2D, objects)
   if (object) {
-    geometry = primitives.line([object.lineSegments])
+    geometry = line([object.lineSegments])
     return geometry
   }
 
   object = findNode(x3dTypes.RECTANGLE2D, objects)
   if (object) {
-    geometry = primitives.rectangle({ size: object.size })
+    geometry = rectangle({ size: object.size })
     return geometry
   }
 
@@ -109,12 +122,10 @@ const instantiatePrimitive = (options, objects) => {
     const numfaces = Math.trunc(numpoints / 3)
     geometry = []
     for (let i = 0; i < numfaces; i = i + 3) {
-      geometry.push(geometries.geom2.fromPoints([vertices[i], vertices[i + 1], vertices[i + 2]]))
+      geometry.push(geom2.create([[vertices[i], vertices[i + 1], vertices[i + 2]]]))
     }
     return geometry
   }
 
   return geometry
 }
-
-module.exports = instantiatePrimitive