@jscad/svg-deserializer 2.5.11 → 3.0.1-alpha.0

package/src/helpers.js

@@ -1,13 +1,13 @@
-const { inchMM, ptMM, pcMM, svgColors } = require('./constants')
+import { inchMM, ptMM, pcMM, svgColors } from './constants.js'
 
 // Calculate the CAG length/size from the given SVG value (float)
-const svg2cag = (vec, svgUnitsPmm) => [
+export const svg2cag = (vec, svgUnitsPmm) => [
   vec[0] / svgUnitsPmm[0],
   0 - vec[1] / svgUnitsPmm[1]
 ]
 
 // Calculate the CAG length/size from the given CSS value (string)
-const cagLengthX = (css, svgUnitsPmm, svgUnitsX) => {
+export const cagLengthX = (css, svgUnitsPmm, svgUnitsX) => {
   if (css.indexOf('%') < 0) {
     return css2cag(css, svgUnitsPmm[0])
   }
@@ -21,7 +21,7 @@ const cagLengthX = (css, svgUnitsPmm, svgUnitsX) => {
   return Math.round(v * 100000) / 100000
 }
 
-const cagLengthY = (css, svgUnitsPmm, svgUnitsY) => {
+export const cagLengthY = (css, svgUnitsPmm, svgUnitsY) => {
   if (css.indexOf('%') < 0) {
     return css2cag(css, svgUnitsPmm[1])
   }
@@ -35,7 +35,7 @@ const cagLengthY = (css, svgUnitsPmm, svgUnitsY) => {
   return Math.round(v * 100000) / 100000
 }
 
-const cagLengthP = (css, svgUnitsPmm, svgUnitsV) => {
+export const cagLengthP = (css, svgUnitsPmm, svgUnitsV) => {
   if (css.indexOf('%') < 0) {
     return css2cag(css, svgUnitsPmm[1])
   }
@@ -49,7 +49,7 @@ const cagLengthP = (css, svgUnitsPmm, svgUnitsV) => {
   return v
 }
 
-const css2cag = (css, unit) => {
+export const css2cag = (css, unit) => {
   let v = parseFloat(css) // number part
   if (isNaN(v)) { return 0.0 }
   if (v === 0) return v
@@ -80,7 +80,7 @@ const css2cag = (css, unit) => {
 }
 
 // convert the SVG color specification to CAG RGB
-const cagColor = (value) => {
+export const cagColor = (value) => {
   // let rgb = [0,0,0]; // default is black
   let rgb
   value = value.toLowerCase()
@@ -124,7 +124,7 @@ const cagColor = (value) => {
   return rgb
 }
 
-const cssStyle = (element, name) => {
+export const cssStyle = (element, name) => {
   if ('style' in element) {
     const list = element.style + ';'
     const pat = name + '\\s*:\\s*(\\S+);'
@@ -141,7 +141,7 @@ const cssStyle = (element, name) => {
   return undefined
 }
 
-const reflect = (x, y, px, py) => {
+export const reflect = (x, y, px, py) => {
   const ox = x - px
   const oy = y - py
   if (x === px && y === px) return [x, y]
@@ -151,7 +151,7 @@ const reflect = (x, y, px, py) => {
 }
 
 // Return the value for the given attribute from the group hiearchy
-const groupValue = (svgGroups, name) => {
+export const groupValue = (svgGroups, name) => {
   let i = svgGroups.length
   while (i > 0) {
     const g = svgGroups[i - 1]
@@ -163,7 +163,7 @@ const groupValue = (svgGroups, name) => {
   return undefined
 }
 
-const svgColorForTarget = (target, svgObject) => {
+export const svgColorForTarget = (target, svgObject) => {
   let color = null
   if (target === 'path') {
     if (svgObject.stroke) {
@@ -185,16 +185,3 @@ const svgColorForTarget = (target, svgObject) => {
   }
   return color
 }
-
-module.exports = {
-  svg2cag,
-  cagLengthX,
-  cagLengthY,
-  cagLengthP,
-  css2cag,
-  cagColor,
-  cssStyle,
-  reflect,
-  groupValue,
-  svgColorForTarget
-}

package/src/index.js

@@ -1,27 +1,16 @@
-/*
-## License
-
-Copyright (c) 2016 Z3 Development https://github.com/z3dev
-              2017 Mark 'kaosat-dev' Moissette
-
-The upgrades (direct geometry instantiation from this deserializer) and refactoring
-have been very kindly sponsored by [Copenhagen Fabrication / Stykka](https://www.stykka.com/)
+import saxes from 'saxes'
 
-All code released under MIT license
-*/
+import { colorize, mirrorX, mirrorY, rotateZ, translate, scale } from '@jscad/modeling'
+import { toArray } from '@jscad/array-utils'
+import { ensureString } from '@jscad/io-utils'
 
-const saxes = require('saxes')
+import { pxPmm } from './constants.js'
+import { cagLengthX, cagLengthY, svgColorForTarget } from './helpers.js'
+import { svgSvg, svgRect, svgCircle, svgGroup, svgLine, svgPath, svgEllipse, svgPolygon, svgPolyline, svgUse } from './svgElementHelpers.js'
+import { shapesMapGeometry } from './shapesMapGeometry.js'
+import { shapesMapJscad } from './shapesMapJscad.js'
 
-const { colors, transforms } = require('@jscad/modeling')
-const { toArray } = require('@jscad/array-utils')
-const { ensureString } = require('@jscad/io-utils')
-
-const version = require('../package.json').version
-
-const { cagLengthX, cagLengthY, svgColorForTarget } = require('./helpers')
-const { svgSvg, svgRect, svgCircle, svgGroup, svgLine, svgPath, svgEllipse, svgPolygon, svgPolyline, svgUse } = require('./svgElementHelpers')
-const shapesMapGeometry = require('./shapesMapGeometry')
-const shapesMapJscad = require('./shapesMapJscad')
+const version = '[VI]{version}[/VI]' // version is injected by rollup
 
 /**
  * Deserializer of SVG source data to JSCAD geometries.
@@ -52,15 +41,16 @@ const deserialize = (options, input) => {
     addMetaData: true,
     filename: 'svg',
     output: 'script',
-    pxPmm: require('./constants').pxPmm,
+    pxPmm,
     segments: 32,
     target: 'path', // target - 'geom2' or 'path'
     pathSelfClosed: 'error',
     version
   }
   options = Object.assign({}, defaults, options)
+
   input = ensureString(input)
-  return options.output === 'script' ? translate(input, options) : instantiate(input, options)
+  return options.output === 'script' ? translateScript(input, options) : instantiate(input, options)
 }
 
 /*
@@ -102,7 +92,7 @@ const instantiate = (src, options) => {
  *    at the start of the file
  * @return {string} a string (JSCAD script)
  */
-const translate = (src, options) => {
+const translateScript = (src, options) => {
   const { filename, version, pxPmm, addMetaData } = options
 
   options && options.statusCallback && options.statusCallback({ progress: 0 })
@@ -194,29 +184,29 @@ const objectify = (options, group) => {
         if (scaleAttribute !== null) {
           let x = Math.abs(scaleAttribute.scale[0])
           let y = Math.abs(scaleAttribute.scale[1])
-          shape = transforms.scale([x, y, 1], shape)
+          shape = scale([x, y, 1], shape)
           // and mirror if necessary
           x = scaleAttribute.scale[0]
           y = scaleAttribute.scale[1]
           if (x < 0) {
-            shape = transforms.mirrorX(shape)
+            shape = mirrorX(shape)
           }
           if (y < 0) {
-            shape = transforms.mirrorY(shape)
+            shape = mirrorY(shape)
           }
         }
         if (rotateAttribute !== null) {
           const z = 0 - rotateAttribute.rotate * 0.017453292519943295 // radians
-          shape = transforms.rotateZ(z, shape)
+          shape = rotateZ(z, shape)
         }
         if (translateAttribute !== null) {
           const x = cagLengthX(translateAttribute.translate[0], svgUnitsPmm, svgUnitsX)
           const y = (0 - cagLengthY(translateAttribute.translate[1], svgUnitsPmm, svgUnitsY))
-          shape = transforms.translate([x, y, 0], shape)
+          shape = translate([x, y, 0], shape)
         }
       }
       const color = svgColorForTarget(target, obj)
-      if (color) shape = colors.colorize(color, shape)
+      if (color) shape = colorize(color, shape)
       return shape
     })
     geometries = geometries.concat(shapes)
@@ -366,7 +356,7 @@ const createSvgParser = (src, pxPmm) => {
     // this is just like an embedded SVG but does NOT render directly, only named
     // this requires another set of control objects
     // only add to named objects for later USE
-    //  break;
+    //  break
 
     if (obj) {
       // add to named objects if necessary
@@ -397,7 +387,7 @@ const createSvgParser = (src, pxPmm) => {
           if (svgGroups.length > 0) {
             const group = svgGroups.pop()
             if ('objects' in group) {
-              // TBD apply presentation attributes from the group
+            // TBD apply presentation attributes from the group
               group.objects.push(obj)
             }
             svgGroups.push(group)
@@ -424,7 +414,7 @@ const createSvgParser = (src, pxPmm) => {
       DEFS: () => { svgInDefs = false },
       USE: popGroup,
       G: popGroup,
-      undefined: () => { }
+      undefined: () => {}
     }
     const elementName = node.name.toUpperCase()
     const obj = objMap[elementName] ? objMap[elementName]() : undefined
@@ -444,9 +434,9 @@ const createSvgParser = (src, pxPmm) => {
   return parser
 }
 
-const extension = 'svg'
+const mimeType = 'image/svg+xml'
 
-module.exports = {
-  deserialize,
-  extension
+export {
+  mimeType,
+  deserialize
 }

package/src/shapesMapGeometry.js

@@ -1,8 +1,8 @@
-const { geometries, primitives } = require('@jscad/modeling')
+import { circle, ellipse, geom2, line, path2, rectangle, roundedRectangle } from '@jscad/modeling'
 
-const { svg2cag, cagLengthX, cagLengthY, cagLengthP, reflect } = require('./helpers')
+import { svg2cag, cagLengthX, cagLengthY, cagLengthP, reflect } from './helpers.js'
 
-const shapesMapGeometry = (obj, objectify, params) => {
+export const shapesMapGeometry = (obj, objectify, params) => {
   const { svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, target, segments, pathSelfClosed } = params
 
   const types = {
@@ -21,12 +21,12 @@ const shapesMapGeometry = (obj, objectify, params) => {
         x = (x + (w / 2)) // position the object via the center
         y = (y - (h / 2)) // position the object via the center
         if (rx === 0) {
-          shape = primitives.rectangle({ center: [x, y], size: [w, h] })
+          shape = rectangle({ center: [x, y], size: [w, h] })
         } else {
-          shape = primitives.roundedRectangle({ center: [x, y], segments, size: [w, h], roundRadius: rx })
+          shape = roundedRectangle({ center: [x, y], segments, size: [w, h], roundRadius: rx })
         }
         if (target === 'path') {
-          shape = geometries.path2.fromPoints({ closed: true }, geometries.geom2.toPoints(shape))
+          shape = path2.fromPoints({ closed: true }, geom2.toPoints(shape))
         }
       }
       return shape
@@ -39,9 +39,9 @@ const shapesMapGeometry = (obj, objectify, params) => {
 
       let shape
       if (r > 0) {
-        shape = primitives.circle({ center: [x, y], segments, radius: r })
+        shape = circle({ center: [x, y], segments, radius: r })
         if (target === 'path') {
-          shape = geometries.path2.fromPoints({ closed: true }, geometries.geom2.toPoints(shape))
+          shape = path2.fromPoints({ closed: true }, geom2.toPoints(shape))
         }
       }
       return shape
@@ -55,9 +55,9 @@ const shapesMapGeometry = (obj, objectify, params) => {
 
       let shape
       if (rx > 0 && ry > 0) {
-        shape = primitives.ellipse({ center: [cx, cy], segments, radius: [rx, ry] })
+        shape = ellipse({ center: [cx, cy], segments, radius: [rx, ry] })
         if (target === 'path') {
-          shape = geometries.path2.fromPoints({ closed: true }, geometries.geom2.toPoints(shape))
+          shape = path2.fromPoints({ closed: true }, geom2.toPoints(shape))
         }
       }
       return shape
@@ -78,7 +78,7 @@ const shapesMapGeometry = (obj, objectify, params) => {
       //   }
       // }
 
-      const shape = primitives.line([[x1, y1], [x2, y2]])
+      const shape = line([[x1, y1], [x2, y2]])
       if (target === 'geom2') {
         // TODO expand if 2D target
       }
@@ -96,9 +96,9 @@ const shapesMapGeometry = (obj, objectify, params) => {
         }
       }
       if (target === 'geom2') {
-        return geometries.geom2.fromPoints(points)
+        return geom2.create([points])
       }
-      return geometries.path2.fromPoints({}, points)
+      return path2.fromPoints({}, points)
     },
 
     polyline: (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV) => {
@@ -121,7 +121,7 @@ const shapesMapGeometry = (obj, objectify, params) => {
         }
       }
 
-      const shape = primitives.line(points)
+      const shape = line(points)
       if (target === 'geom2') {
         // TODO expand if 2D target
         // .expandToCAG(r, CSG.defaultResolution2D)
@@ -136,9 +136,8 @@ const shapesMapGeometry = (obj, objectify, params) => {
       const shapes = listofentries.map((entry) => {
         const path = entry[1]
         if (target === 'geom2' && path.isClosed) {
-          const points = geometries.path2.toPoints(path).slice()
-          points.push(points[0]) // add first point again to create closing sides
-          return geometries.geom2.fromPoints(points)
+          const points = path2.toPoints(path)
+          return geom2.create([points])
         }
         return path
       })
@@ -149,11 +148,9 @@ const shapesMapGeometry = (obj, objectify, params) => {
   return types[obj.type](obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments)
 }
 
-module.exports = shapesMapGeometry
-
 const appendPoints = (points, geometry) => {
-  if (geometry) return geometries.path2.appendPoints(points, geometry)
-  return geometries.path2.fromPoints({ }, points)
+  if (geometry) return path2.appendPoints(points, geometry)
+  return path2.fromPoints({ }, points)
 }
 
 const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups, segments, pathSelfClosed) => {
@@ -188,7 +185,9 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
     pc = false
   }
   const ensurePath = () => {
-    if (!paths[pathName]) paths[pathName] = geometries.path2.fromPoints({}, [])
+    if (!paths[pathName]) {
+      paths[pathName] = path2.fromPoints({}, [])
+    }
   }
   for (let j = 0; j < obj.commands.length; j++) {
     const co = obj.commands[j]
@@ -249,7 +248,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = cx + parseFloat(pts[i++])
           cy = cy + parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendArc({
+          paths[pathName] = path2.appendArc({
             segments,
             endpoint: svg2cag([cx, cy], svgUnitsPmm),
             radius: svg2cag([rx, ry], svgUnitsPmm),
@@ -269,7 +268,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = parseFloat(pts[i++])
           cy = parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendArc({
+          paths[pathName] = path2.appendArc({
             segments,
             endpoint: svg2cag([cx, cy], svgUnitsPmm),
             radius: svg2cag([rx, ry], svgUnitsPmm),
@@ -288,7 +287,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = cx + parseFloat(pts[i++])
           cy = cy + parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag([x1, y1], svgUnitsPmm),
@@ -310,7 +309,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = parseFloat(pts[i++])
           cy = parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag([x1, y1], svgUnitsPmm),
@@ -333,7 +332,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           const q1 = [p0[0] + (2 / 3) * (qx - p0[0]), p0[1] + (2 / 3) * (qy - p0[1])]
           const q2 = [q1[0] + (1 / 3) * (cx - p0[0]), q1[1] + (1 / 3) * (cy - p0[1])]
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag(q1, svgUnitsPmm),
@@ -356,7 +355,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           const q1 = [p0[0] + (2 / 3) * (qx - p0[0]), p0[1] + (2 / 3) * (qy - p0[1])]
           const q2 = [q1[0] + (1 / 3) * (cx - p0[0]), q1[1] + (1 / 3) * (cy - p0[1])]
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag(q1, svgUnitsPmm),
@@ -377,7 +376,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           const q1 = [p0[0] + (2 / 3) * (qx - p0[0]), p0[1] + (2 / 3) * (qy - p0[1])]
           const q2 = [q1[0] + (1 / 3) * (cx - p0[0]), q1[1] + (1 / 3) * (cy - p0[1])]
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag(q1, svgUnitsPmm),
@@ -398,7 +397,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           const q1 = [p0[0] + (2 / 3) * (qx - p0[0]), p0[1] + (2 / 3) * (qy - p0[1])]
           const q2 = [q1[0] + (1 / 3) * (cx - p0[0]), q1[1] + (1 / 3) * (cy - p0[1])]
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag(q1, svgUnitsPmm),
@@ -420,13 +419,14 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = cx + parseFloat(pts[i++])
           cy = cy + parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier(
-            {
-              segments,
-              controlPoints: [svg2cag([x1, y1], svgUnitsPmm), svg2cag([bx, by], svgUnitsPmm), svg2cag([cx, cy], svgUnitsPmm)]
-            },
-            paths[pathName]
-          )
+          paths[pathName] = path2.appendBezier({
+            segments,
+            controlPoints: [
+              svg2cag([x1, y1], svgUnitsPmm),
+              svg2cag([bx, by], svgUnitsPmm),
+              svg2cag([cx, cy], svgUnitsPmm)
+            ]
+          }, paths[pathName])
           const rf = reflect(bx, by, cx, cy)
           bx = rf[0]
           by = rf[1]
@@ -441,7 +441,7 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           cx = parseFloat(pts[i++])
           cy = parseFloat(pts[i++])
           ensurePath()
-          paths[pathName] = geometries.path2.appendBezier({
+          paths[pathName] = path2.appendBezier({
             segments,
             controlPoints: [
               svg2cag([x1, y1], svgUnitsPmm),
@@ -454,13 +454,13 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
           by = rf[1]
         }
         break
-      case 'h': // relative Horzontal line to
+      case 'h': // relative Horizontal line to
         while (pts.length >= i + 1) {
           cx = cx + parseFloat(pts[i++])
           paths[pathName] = appendPoints([svg2cag([cx, cy], svgUnitsPmm)], paths[pathName])
         }
         break
-      case 'H': // absolute Horzontal line to
+      case 'H': // absolute Horizontal line to
         while (pts.length >= i + 1) {
           cx = parseFloat(pts[i++])
           paths[pathName] = appendPoints([svg2cag([cx, cy], svgUnitsPmm)], paths[pathName])
@@ -494,13 +494,13 @@ const expandPath = (obj, svgUnitsPmm, svgUnitsX, svgUnitsY, svgUnitsV, svgGroups
         break
       case 'z': // close current line
       case 'Z':
-        paths[pathName] = geometries.path2.close(paths[pathName])
+        paths[pathName] = path2.close(paths[pathName])
         cx = sx
         cy = sy // return to the starting point
         pc = true
         break
       default:
-        console.log('Warning: Unknow PATH command [' + co.c + ']')
+        console.log('Warning: Unknown PATH command [' + co.c + ']')
         break
     }